// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC-20 standard as defined in the ERC.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the value of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 value) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}

// SPDX-License-Identifier: None
// Super Champs Foundation 2024

pragma solidity ^0.8.24;

/// @title Interface for protocol permissions registry
/// @author Chance Santana-Wees (Coelacanth/Coel.eth)
interface IPermissionsManager{
    ///@notice All available roles.
    ///@dev EXT roles are available for future application.
    enum Role {
        ANY,
        GLOBAL_ADMIN,
        MINT_ADMIN,
        TRANSFER_ADMIN,
        SYSTEMS_ADMIN,
        EXT1,
        EXT2,
        EXT3,
        EXT4,
        EXT5,
        EXT6,
        EXT7,
        EXT8,
        EXT9,
        EXT10
    }

    /**
    * @param role_ ISCPermissionsManager.Role to query
    * @param account_ Address to check for role_
    */
    function hasRole(Role role_, address account_) external view returns(bool);

    /**
    * @param role_ ISCPermissionsManager.Role to add
    * @param account_ Address to add role_ on
    */
    function addRole(Role role_, address account_) external;

    /**
    * @param role_ ISCPermissionsManager.Role to remove
    * @param account_ Address to remove role_ from
    */
    function removeRole(Role role_, address account_) external;
}

// SPDX-License-Identifier: None
// Super Champs Foundation 2024

pragma solidity ^0.8.24;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

/// @title Metagame staking pool interface
/// @author Chance Santana-Wees (Coelacanth/Coel.eth)
/// @notice Interface for staking pool for Super Champ tokens metagame.
interface ISCMetagamePool{
    event Stake(address staker, address source, uint256 amount, uint256 balance);
    event Unstake(address staker, uint256 amount, uint256 balance);
    event SpendFromStake(address staker, address source, uint256 amount, uint256 balance, address receiver, string data);

    error UnableToTransferTokens(address staker, uint256 amount);
    error UnableToUnstakeTokens(address staker, uint256 amount, uint256 total_staked_supply);
    error UnexpectedBalance();

    function stake(uint256 amount_) external;
    function stakeFor(address staker_, uint256 amount_) external;
    function approve(address spender_, uint256 amount_) external;
    function spend(uint256 amount_, address staker_, address receiver_, string memory data_) external;
    function unstake(uint256 amount_) external;
}

// SPDX-License-Identifier: None
// Super Champs Foundation 2024

pragma solidity ^0.8.24;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "../Utils/SCPermissionedAccess.sol";
import "../../interfaces/IPermissionsManager.sol";
import "../../interfaces/ISCMetagamePool.sol";

/// @title Metagame staking pool.
/// @author Chance Santana-Wees (Coelacanth/Coel.eth)
/// @notice Staking pool for Super Champ tokens.
/// @dev This pool does not issue on-chain rewards. Rewards are tabulated off-chain.
contract SCMetagamePool is SCPermissionedAccess, ISCMetagamePool {
    
    struct StakingData {
        uint256 balance; //we will know whether a check point is stake/unstake by seeing if balance increased/decreased.
        address msg_sender; //in case of stake, if msg_sender is season_contract_address, then it is claimAndStake else it simple stake. in case of unstake, if sender is 'our decided aaddress', then it is spendFromStake else it is simple unstake.
    }

    IERC20 public immutable token;

    mapping(address => mapping(uint256 => StakingData)) _user_to_checkpoint_to_data;
    mapping(address => uint256[]) _user_checkpoints;

    mapping(address => mapping(address => uint256)) _user_to_approved_spend;

    /// @param permissions_ Address of the protocol permissions registry. Must conform to IPermissionsManager
    constructor(address permissions_, address token_) SCPermissionedAccess(permissions_) {
        token = IERC20(token_);
    }

    /// @notice Stake tokens directly
    /// @param amount_ Quantity of tokens to stake
    function stake(uint256 amount_) external {
        bool success = token.transferFrom(msg.sender, address(this), amount_);
        if(!success) {
            revert UnableToTransferTokens(msg.sender, amount_);
        }
        _stake(msg.sender, amount_);
    }

    /// @notice Stake tokens for another address
    /// @param staker_ The address to stake tokens for
    /// @param amount_ Quantity of tokens to stake
    /// @dev Tokens are transferred from msg.sender and credited to staker_
    function stakeFor(address staker_, uint256 amount_) external {
        bool success = token.transferFrom(msg.sender, address(this), amount_);
        if(!success) {
            revert UnableToTransferTokens(msg.sender, amount_);
        }
        _stake(staker_, amount_);
    }

    /// @notice Approve an address to spend staked tokens
    /// @param spender_ The address to approve
    /// @param amount_ Quantity of tokens to approve spending
    /// @dev This mirrors approve(...) defined in ERC20 standard
    function approve(address spender_, uint256 amount_) external {
        _user_to_approved_spend[msg.sender][spender_] = amount_;
    }

    /// @notice Spend tokens from a stakers staked tokens
    /// @param amount_ Quantity of tokens to unstake/spend
    /// @param staker_ The address of the staker
    /// @param receiver_ The address of the reciever of the spent tokens
    /// @param data_ data related to spent tokens
    /// @dev This does NOT trigger an Unstake event, allowing stakers to spend tokens without penalty
    /// @dev This is expected to be called from the spending contract, which must be first permissioned through a direct call to approve(...)
    function spend(uint256 amount_, address staker_, address receiver_, string memory data_) external {
        if(staker_ != msg.sender) {
            uint256 approvedAmount = _user_to_approved_spend[staker_][msg.sender];
            require(approvedAmount >= amount_, "Insufficient allowance");
            _user_to_approved_spend[staker_][msg.sender] -= amount_;
        }
        uint256 _balance = _unstake(amount_, staker_, receiver_);
        emit SpendFromStake(staker_, msg.sender, amount_, _balance, receiver_, data_);
    }

    /// @notice Unstake tokens and transfer to staker
    /// @param amount_ Quantity of tokens to unstake
    /// @dev This triggers an Unstake event which can cause penalties in the metagame
    function unstake(uint256 amount_) external {
        uint256 _balance = _unstake(amount_, msg.sender, msg.sender);
        emit Unstake(msg.sender, amount_, _balance);
    }

    /// @notice Returns the list of all of the users staking checkpoint timestamps
    /// @param staker_ Address of the staker
    function checkpoint_timestamps(address staker_) public view returns (uint256[] memory) {
        return _user_checkpoints[staker_];
    }

    /// @notice Returns the list of all of the users staking checkpoint timestamps
    /// @param staker_ Address of the staker
    function checkpoint_timestamps_range(address staker_, uint256 start_, uint256 count_) public view returns (uint256[] memory _user_checkpoints_) {
        uint256 totalCheckpoints = _user_checkpoints[staker_].length;
        require(start_ < totalCheckpoints, "Start index out of bounds");
        uint256 end = start_ + count_;
        if (end > totalCheckpoints) {
            end = totalCheckpoints;
        }
        _user_checkpoints_ = new uint256[](end - start_);
        for (uint256 i = start_; i < end; i++) {
            _user_checkpoints_[i - start_] = _user_checkpoints[staker_][i];
        }
    }

    /// @notice Returns the list of all of the user's checkpoint data from a list of timestamps
    /// @param staker_ Address of the staker
    /// @param checkpoint_timestamps_ A list of checkpoints timestamps, retrievable with checkpoint_timestamps(...)
    function checkpoints(address staker_, uint256[] memory checkpoint_timestamps_) public view returns (StakingData[] memory _data_) {
        _data_ = new StakingData[](checkpoint_timestamps_.length);
        uint256 len = checkpoint_timestamps_.length;
        for(uint256 i = 0; i < len; i++) {
            _data_[i] = _user_to_checkpoint_to_data[staker_][checkpoint_timestamps_[i]];
        }
    }

    function _unstake(uint256 amount_, address staker_, address receiver_) internal returns (uint256) {
        uint256[] storage _checkpoints = _user_checkpoints[staker_];
        
        uint256 _balance = 0;
        if(_checkpoints.length > 0) {
            uint256 _last_ts = _checkpoints[_checkpoints.length-1];
            _balance += _user_to_checkpoint_to_data[staker_][_last_ts].balance;
        }

        require(_balance >= amount_, "Insufficient balance");

        _balance -= amount_;
        bool success = token.transfer(receiver_, amount_);
        if(!success) {
            revert UnableToUnstakeTokens(staker_, amount_, token.balanceOf(address(this)));
        }

        uint256 _current_ts = block.timestamp;
        _checkpoints.push(_current_ts);

        StakingData memory newStakingData = StakingData({
            balance: _balance,
            msg_sender: msg.sender
        });
        
        _user_to_checkpoint_to_data[staker_][_current_ts] = newStakingData;

        return _balance;
    }

    function _stake(address staker_, uint256 amount_) internal {
        uint256[] storage _checkpoints = _user_checkpoints[staker_];
        
        uint256 _balance = amount_;
        if(_checkpoints.length > 0) {
            uint256 _last_ts = _checkpoints[_checkpoints.length-1];
            _balance += _user_to_checkpoint_to_data[staker_][_last_ts].balance;
        }

        uint256 _current_ts = block.timestamp;
        _checkpoints.push(_current_ts);

        StakingData memory newStakingData = StakingData({
            balance: _balance,
            msg_sender: msg.sender
        });
        _user_to_checkpoint_to_data[staker_][_current_ts] = newStakingData;

        emit Stake(staker_, msg.sender, amount_, _balance);
    }
}

// SPDX-License-Identifier: None
// Super Champs Foundation 2024

pragma solidity ^0.8.24;

import "../../interfaces/IPermissionsManager.sol";

contract SCPermissionedAccess {
    IPermissionsManager public immutable permissions;

    /// @notice Function modifier which requires the sender to possess the global admin permission as recorded in "permissions"
    modifier isGlobalAdmin() {
        require(permissions.hasRole(IPermissionsManager.Role.GLOBAL_ADMIN, msg.sender), "Not a Global Admin");
        _;
    }

    /// @notice Function modifier which requires the sender to possess the systems admin permission as recorded in "permissions"
    modifier isSystemsAdmin() {
        require(permissions.hasRole(IPermissionsManager.Role.SYSTEMS_ADMIN, msg.sender), "Not a Systems Admin");
        _;
    }

    constructor(address _permissions){
        permissions = IPermissionsManager(_permissions);
    }
}

{
  "compilationTarget": {
    "SuperChamps/contracts/Metagame/SCMetagamePool.sol": "SCMetagamePool"
  },
  "evmVersion": "cancun",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 20
  },
  "remappings": []
}