Introducing Our First P2E Smart Contract for the $ALEIN Arcade

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.0.1/contracts/token/ERC20/IERC20.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.0.1/contracts/access/Ownable.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.0.1/contracts/utils/ReentrancyGuard.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.0.1/contracts/utils/cryptography/EIP712.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.0.1/contracts/utils/cryptography/ECDSA.sol";

/**
 * @title AleinInvaders
 * @dev This contract uses EIP-712 signed messages to securely reward players.
 * A backend server signs a player's score, and the player submits that signature
 * to claim their tokens, preventing cheating while maintaining a good user experience.
 */
contract AleinInvaders is Ownable, ReentrancyGuard, EIP712 {
    // The BEP-20 token contract used for rewards.
    IERC20 public immutable aleinToken;

    // A rate to determine how many tokens are awarded per score point.
    uint256 public scoreToTokenRate = 1000;

    // --- Claim Limit Variables ---
    // Note: This limit should include token decimals (e.g., 7500 * 10**18 for 7,500 tokens).
    uint256 public weeklyTokenLimit = 7500 * (10**18);
    uint256 public currentWeekStartTimestamp;
    uint256 public tokensClaimedThisWeek;
    uint256 public minTokenBalanceToClaim = 50000 * (10**18);

    // Mapping to store the highest score claimed by each player to prevent replays.
    mapping(address => uint256) public claimedHighScores;

    // A nonce for each player to prevent signature replay attacks.
    mapping(address => uint256) public playerNonces;

    // Event to log when a player successfully claims a reward.
    event TokensClaimed(address indexed player, uint256 score, uint256 tokensAwarded);

    bytes32 private constant CLAIM_TYPEHASH = keccak256("Claim(address player,uint256 score,uint256 nonce)");

    /**
     * @dev Sets token address, EIP712 domain, and initial weekly timestamp.
     */
    constructor(address _tokenAddress, address initialOwner)
        Ownable(initialOwner)
        EIP712("AleinInvaders", "1")
    {
        require(_tokenAddress != address(0), "Token address cannot be zero");
        aleinToken = IERC20(_tokenAddress);
        currentWeekStartTimestamp = block.timestamp;
    }

    /**
     * @dev Allows a player to claim tokens by providing a valid signature from the owner.
     * @param _player The address of the player receiving the reward.
     * @param _score The score being claimed.
     * @param _signature A signature generated by the owner's private key.
     */
    function claimWithSignature(address _player, uint256 _score, bytes calldata _signature) external nonReentrant {
        require(_player == msg.sender, "Signature is not for you.");
        
        uint256 nonce = playerNonces[_player];

        // Hash the claim data according to EIP-712 standard.
        bytes32 structHash = keccak256(abi.encode(CLAIM_TYPEHASH, _player, _score, nonce));
        bytes32 digest = _hashTypedDataV4(structHash);

        // Recover the address that signed the message.
        address signerAddress = ECDSA.recover(digest, _signature);
        
        // Verify that the signer is the contract owner.
        require(signerAddress == owner(), "Invalid signature.");

        // Check if the player holds the minimum required token balance.
        require(aleinToken.balanceOf(_player) >= minTokenBalanceToClaim, "Insufficient token balance to claim.");

        // Ensure the new score is higher than any previously claimed score.
        require(_score > claimedHighScores[_player], "Score must be higher than your last claimed score.");
        
        // --- Weekly Limit Logic ---
        // Check if a week has passed to reset the weekly counter.
        if (block.timestamp >= currentWeekStartTimestamp + 7 days) {
            currentWeekStartTimestamp = block.timestamp;
            tokensClaimedThisWeek = 0;
        }

        // Calculate the reward.
        uint256 tokensToAward = _score / scoreToTokenRate;
        require(tokensToAward > 0, "Score not high enough for a reward.");

        // Check if this claim exceeds the weekly limit.
        require(tokensClaimedThisWeek + tokensToAward <= weeklyTokenLimit, "Weekly token limit reached.");
        // --- End of Weekly Limit Logic ---

        // Check if the contract has enough tokens.
        uint256 contractBalance = aleinToken.balanceOf(address(this));
        require(contractBalance >= tokensToAward, "Contract has insufficient token balance.");

        // --- Effects (State Changes) ---
        // Increment the nonce to prevent this signature from being used again.
        playerNonces[_player]++;
        // Update the player's claimed high score.
        claimedHighScores[_player] = _score;
        // Update the weekly claim count.
        tokensClaimedThisWeek += tokensToAward;

        // --- Interaction ---
        // Transfer the tokens to the player.
        aleinToken.transfer(_player, tokensToAward);

        emit TokensClaimed(_player, _score, tokensToAward);
    }

    /**
     * @dev Allows the contract owner to withdraw any remaining tokens.
     */
    function withdrawRemainingTokens() external onlyOwner {
        uint256 balance = aleinToken.balanceOf(address(this));
        if (balance > 0) {
            aleinToken.transfer(owner(), balance);
        }
    }

    /**
     * @dev Allows the owner to update the score-to-token conversion rate.
     */
    function setScoreToTokenRate(uint256 _newRate) external onlyOwner {
        require(_newRate > 0, "Rate must be greater than zero.");
        scoreToTokenRate = _newRate;
    }

    /**
     * @dev Allows the owner to update the weekly token claim limit.
     * @param _newLimit The new weekly limit, including decimals (e.g., 10000 * 10**18 for 10,000 tokens).
     */
    function setWeeklyTokenLimit(uint256 _newLimit) external onlyOwner {
        weeklyTokenLimit = _newLimit;
    }

    /**
     * @dev Allows the owner to update the minimum token balance required to claim rewards.
     * @param _newBalance The new minimum balance, including decimals.
     */
    function setMinTokenBalanceToClaim(uint256 _newBalance) external onlyOwner {
        minTokenBalanceToClaim = _newBalance;
    }
}