Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Is this a proxy?
• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity 0.8.28;

import {IERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {LinearPoolzk} from "./LinearPoolzk.sol";
import {ERC20StakingLinearPoolzk} from "./stake/ERC20StakingLinearPoolzk.sol";
import {LinearPool_PointsRewardszk} from "./reward/LinearPool_PointsRewardszk.sol";
import {IPointsV2} from "../../points/interface/IPointsV2.sol";

/// @title ERC20StakingPointsRewardsLinearPoolzk
/// @notice This contract is used to stake ERC20 tokens and obtain Points rewards.
/// @notice Staking can be done by the user or via a claim contract.
contract ERC20StakingPointsRewardsLinearPoolzk is ERC20StakingLinearPoolzk, LinearPool_PointsRewardszk {
    address public immutable CLAIM_CONTRACT;

    /// @dev Reverts with {InvalidPointsContract} if the points contract address is zero.
    /// @param claimContract The address of the claim contract.
    /// @param stakingToken The ERC20 token used for staking.
    /// @param pointsContract The address of the points contract.
    /// @param depositReasonCode The reason code for the deposit.
    constructor(
        address claimContract,
        IERC20 stakingToken,
        IPointsV2 pointsContract,
        bytes32 depositReasonCode
    ) ERC20StakingLinearPoolzk(stakingToken) LinearPool_PointsRewardszk(pointsContract, depositReasonCode) {
        CLAIM_CONTRACT = claimContract;
    }

    /// @inheritdoc ERC20StakingLinearPoolzk
    function onERC20Received(address operator, address from, uint256 value, bytes calldata data) external virtual override returns (bytes4) {
        require(msg.sender == address(STAKING_TOKEN), InvalidToken());
        bool requiresTransfer = false;
        if (operator == CLAIM_CONTRACT) {
            address staker = abi.decode(data, (address));
            _stake(staker, abi.encode(requiresTransfer, abi.encode(value)));
        } else {
            _stake(from, abi.encode(requiresTransfer, abi.encode(value)));
        }
        return this.onERC20Received.selector;
    }

    /// @inheritdoc LinearPool_PointsRewardszk
    function _computeClaim(
        address staker,
        uint256 reward
    ) internal virtual override(LinearPoolzk, LinearPool_PointsRewardszk) returns (bytes memory claimData) {
        return LinearPool_PointsRewardszk._computeClaim(staker, reward);
    }

    /// @inheritdoc LinearPool_PointsRewardszk
    function _computeAddReward(address rewarder, uint256 reward, uint256 dust) internal virtual override(LinearPoolzk, LinearPool_PointsRewardszk) {
        LinearPool_PointsRewardszk._computeAddReward(rewarder, reward, dust);
    }
}

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.28;

interface IPointsV2 {
    /// @notice Emitted when an amount is deposited to a balance.
    /// @param depositor The depositor.
    /// @param reasonCode The reason code of the deposit.
    /// @param holder The holder of the balance deposited to.
    /// @param amount The amount deposited.
    event Deposited(address indexed depositor, bytes32 indexed reasonCode, address indexed holder, uint256 amount);

    /// @notice Emitted when an approval is made.
    /// @param holder The holder of the balance.
    /// @param spender The spender allowed to spend the balance.
    /// @param amount The amount approved.
    event Approval(address indexed holder, address indexed spender, uint256 amount);

    /// @notice Emitted when an amount is spent from a balance.
    /// @param spender The spender of the balance.
    /// @param holder The holder of the balance spent from.
    /// @param amount The amount spent.
    event Spent(address indexed spender, address indexed holder, uint256 amount);

    /// @notice Deposits an amount to a holder's balance for a given reason code.
    /// @dev Emits a {Deposited} event.
    /// @param holder The holder of the balance to deposit to.
    /// @param amount The amount to deposit.
    /// @param depositReasonCode The reason code for the deposit.
    function deposit(address holder, uint256 amount, bytes32 depositReasonCode) external;

    /// @notice Approves a spender to spend an amount from the caller's balance.
    /// @dev Emits an {Approval} event.
    /// @param spender The spender allowed to spend the balance.
    /// @param amount The amount approved.
    function approve(address spender, uint256 amount) external;

    /// @notice Approves a spender to spend an amount from a holder's balance using a signature.
    /// @dev Emits an {Approval} event.
    /// @param holder The holder of the balance.
    /// @param spender The spender allowed to spend the balance.
    /// @param amount The amount approved.
    /// @param deadline The deadline timestamp by which the signature must be submitted.
    /// @param signature The signature of the approval.
    function approveWithSignature(address holder, address spender, uint256 amount, uint256 deadline, bytes calldata signature) external;

    /// @notice Spends an amount from a holder's balance.
    /// @dev Emits an {Approval} event if the caller is not the holder.
    /// @dev Emits a {Spent} event.
    /// @param holder The holder of the balance to spend from.
    /// @param amount The amount to spend.
    function spendFrom(address holder, uint256 amount) external;

    /// @notice Spends an amount and calls a target contract with data.
    /// @dev Emits a {Spent} event.
    /// @param amount The amount to spend.
    /// @param target The target contract to call.
    /// @param data The data to call the target contract with.
    function spendAndCall(uint256 amount, address target, bytes calldata data) external;
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.28;

import {IPointsV2} from "../../../points/interface/IPointsV2.sol";

/// @title LinearPool_PointsRewardszk
/// @notice This contract is used to handle the points rewards for linear pools.
// solhint-disable-next-line contract-name-capwords
abstract contract LinearPool_PointsRewardszk {
    IPointsV2 public immutable POINTS_CONTRACT;
    bytes32 public immutable DEPOSIT_REASON_CODE;

    error InvalidPointsContract();

    /// @dev Reverts with {InvalidPointsContract} if the points contract address is zero.
    /// @param pointsContract The address of the points contract.
    /// @param depositReasonCode The reason code for the deposit.
    constructor(IPointsV2 pointsContract, bytes32 depositReasonCode) {
        require(address(pointsContract) != address(0), InvalidPointsContract());
        POINTS_CONTRACT = pointsContract;
        DEPOSIT_REASON_CODE = depositReasonCode;
    }

    /// @notice Deposits `reward` points to the `sender`'s account.
    /// @param sender The address of the user receiving the points.
    /// @param reward The amount of points to be deposited.
    /// @return claimData The data to be used for claiming the reward, encoded as (uint256 reward).
    function _computeClaim(address sender, uint256 reward) internal virtual returns (bytes memory claimData) {
        claimData = abi.encode(reward);
        POINTS_CONTRACT.deposit(sender, reward, DEPOSIT_REASON_CODE);
    }

    /// @notice Computes the reward for a staker.
    /// @dev This function is empty since the rewards do not need to be transferred to this contract.
    function _computeAddReward(address, uint256, uint256) internal virtual {}
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.28;

import {ContractOwnership} from "@animoca/ethereum-contracts/contracts/access/ContractOwnership.sol";
import {AccessControl} from "@animoca/ethereum-contracts/contracts/access/AccessControl.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import {TokenRecovery} from "@animoca/ethereum-contracts/contracts/security/TokenRecovery.sol";
import {AccessControlStorage} from "@animoca/ethereum-contracts/contracts/access/libraries/AccessControlStorage.sol";
import {SafeERC20, IERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {ILinearPoolzk} from "./interfaces/ILinearPoolzk.sol";

// design inspired from https://github.com/k06a/Unipool/blob/master/contracts/Unipool.sol

/// @title Linear rewards distribution staking pool.
/// @notice Implements the base logic for linear reward pools, while the nature of the staking and rewards is left to the deriving contracts.
/// @notice Stakes, whether fungible or non-fungible, map to an amount of "stake points", then used to compute the user rewards share.
/// @notice NB: This contract inherits TokenRecovery functions. In the likely event that the deriving contract does keep tokens in stake,
/// @notice the corresponding functions must be overriden to prevent recovering tokens legitimately staked in the contract.
abstract contract LinearPoolzk is ILinearPoolzk, AccessControl, ReentrancyGuard, TokenRecovery {
    using AccessControlStorage for AccessControlStorage.Layout;
    using SafeERC20 for IERC20;

    bytes32 public constant REWARDER_ROLE = "rewarder";
    uint256 public constant SCALING_FACTOR = 1e18;

    uint256 public totalStaked;
    uint256 public lastUpdated;
    uint256 public rewardRate;
    uint256 public rewardPerStakePointStored;
    uint256 public distributionEnd;

    mapping(address staker => uint256 stakePoints) public staked;
    mapping(address staker => uint256 reward) public rewards;
    mapping(address staker => uint256 paid) public rewardPerStakePointPaid;

    event Staked(address indexed staker, bytes stakeData, uint256 stakePoints);
    event Withdrawn(address indexed staker, bytes withdrawData, uint256 stakePoints);
    event Claimed(address indexed staker, bytes claimData, uint256 reward);
    event RewardAdded(address indexed rewarder, uint256 reward, uint256 duration, uint256 dust);

    error InvalidStakeAmount();
    error InvalidWithdrawAmount();
    error NotEnoughStake(address staker, uint256 stake, uint256 withdraw);
    error InvalidRewardAmount();
    error InvalidDuration();
    error RewardTooSmallForDuration(uint256 reward, uint256 duration);
    error RewardDilution(uint256 currentRewardRate, uint256 newRewardRate);

    constructor() ContractOwnership(msg.sender) {}

    function _updateReward(address account) internal {
        rewardPerStakePointStored = rewardPerStakePoint();
        if (block.timestamp >= distributionEnd || totalStaked != 0) {
            // ensure rewards before the first staker do not get lost
            lastUpdated = lastTimeRewardApplicable();
        }
        if (account != address(0)) {
            rewards[account] = earned(account);
            rewardPerStakePointPaid[account] = rewardPerStakePointStored;
        }
    }

    /// @notice Returns the last time rewards are applicable.
    /// @return The minimum of the current block timestamp and the distribution end.
    function lastTimeRewardApplicable() public view returns (uint256) {
        uint256 currentDistributionEnd = distributionEnd;
        return block.timestamp < currentDistributionEnd ? block.timestamp : currentDistributionEnd;
    }

    /// @notice Returns the current reward per stake point.
    /// @return The sum of the last stored value and the new rewards since the last update
    function rewardPerStakePoint() public view returns (uint256) {
        uint256 currentTotalStaked = totalStaked;
        if (currentTotalStaked == 0) {
            return rewardPerStakePointStored;
        }
        return rewardPerStakePointStored + (((lastTimeRewardApplicable() - lastUpdated) * rewardRate * SCALING_FACTOR) / currentTotalStaked);
    }

    /// @notice Returns the amount of rewards earned by the account.
    /// @return The account's stake points times the difference between the current reward per stake point and the last paid reward per stake point.
    /// @param account The address of the account to check.
    function earned(address account) public view returns (uint256) {
        return (staked[account] * (rewardPerStakePoint() - rewardPerStakePointPaid[account])) / SCALING_FACTOR + rewards[account];
    }

    /// @notice Stakes to the pool.
    /// @dev Reverts with {ReentrancyGuardReentrantCall} if the function is re-entered.
    /// @dev Reverts with {InvalidStakeAmount} if the stake amount is 0.
    /// @dev Emits a {Staked} event with the staker address, stakeData and stake points.
    /// @dev The stakeData is passed to the _computeStake function, which must be implemented in the deriving contract.
    /// @param stakeData The data to be used for the stake (encoding freely determined by the deriving contracts).
    function stake(bytes calldata stakeData) public payable virtual {
        _stake(_msgSender(), stakeData);
    }

    /// @notice Stakes to the pool.
    /// NB: If a reward is ongoing while there are no stakers, the accumulated rewards so far will go to the first staker.
    /// @dev Reverts with {ReentrancyGuardReentrantCall} if the function is re-entered.
    /// @dev Reverts with {InvalidStakeAmount} if the stake amount is 0.
    /// @dev Emits a {Staked} event with the staker address, stakeData and stake points.
    /// @dev The stakeData is passed to the _computeStake function, which must be implemented in the deriving contract.
    /// @param staker The address of the staker.
    /// @param stakeData The data to be used for the stake (encoding freely determined by the deriving contracts).
    function _stake(address staker, bytes memory stakeData) internal virtual nonReentrant {
        _updateReward(staker);
        uint256 stakePoints = _computeStake(staker, stakeData);
        require(stakePoints != 0, InvalidStakeAmount());
        totalStaked += stakePoints;
        staked[staker] += stakePoints;
        emit Staked(staker, stakeData, stakePoints);
    }

    /// @notice Withdraws from the pool.
    /// @dev Reverts with {ReentrancyGuardReentrantCall} if the function is re-entered.
    /// @dev Reverts with {InvalidWithdrawAmount} if the withdraw amount is 0.
    /// @dev Reverts with {NotEnoughStake} if the staker does not have enough stake points to withdraw.
    /// @dev Emits a {Withdrawn} event with the staker address, withdrawData and stake points.
    /// @dev The withdrawData is passed to the _computeWithdraw function, which must be implemented in the deriving contract.
    /// @param withdrawData The data to be used for the withdraw (encoding freely determined by the deriving contracts).
    function withdraw(bytes calldata withdrawData) public virtual {
        _withdraw(_msgSender(), withdrawData);
    }

    /// @notice Withdraws from the pool.
    /// @dev Reverts with {ReentrancyGuardReentrantCall} if the function is re-entered.
    /// @dev Reverts with {InvalidWithdrawAmount} if the withdraw amount is 0.
    /// @dev Reverts with {NotEnoughStake} if the staker does not have enough stake points to withdraw.
    /// @dev Emits a {Withdrawn} event with the staker address, withdrawData and stake points.
    /// @dev The withdrawData is passed to the _computeWithdraw function, which must be implemented in the deriving contract.
    /// @param staker The address of the staker.
    /// @param withdrawData The data to be used for the withdraw (encoding freely determined by the deriving contracts).
    function _withdraw(address staker, bytes memory withdrawData) internal virtual nonReentrant {
        _updateReward(staker);
        uint256 stakePoints = _computeWithdraw(staker, withdrawData);
        require(stakePoints != 0, InvalidWithdrawAmount());
        uint256 currentStaked = staked[staker];
        require(currentStaked >= stakePoints, NotEnoughStake(staker, currentStaked, stakePoints));
        unchecked {
            // no underflow possible
            staked[staker] = currentStaked - stakePoints;
            totalStaked -= stakePoints;
        }
        emit Withdrawn(staker, withdrawData, stakePoints);
    }

    /// @notice Claims the rewards for the sender.
    /// @dev Emits a {Claimed} event with the staker address, claimData and reward.
    /// @dev The claimData is generated by the _computeClaim function, which must be implemented in the deriving contract.
    function claim() public virtual {
        address staker = _msgSender();
        _updateReward(staker);
        uint256 reward = earned(staker);
        if (reward != 0) {
            rewards[staker] = 0;
            bytes memory claimData = _computeClaim(staker, reward);
            emit Claimed(staker, claimData, reward);
        }
    }

    /// @notice Adds rewards to the pool.
    /// @notice If there is an ongoing distribution, the new rewards are added to the current distribution:
    /// @notice - If the new distribution ends before the current one, the new rewards are added to the current distribution.
    /// @notice - If the new distribution ends after the current one, the remaining rewards are added to the new distribution.
    /// @notice NB: Any dust (remainder of the division of the reward by the duration) will not be distributed.
    /// @dev Reverts with {NotRoleHolder} if the sender does not have the REWARDER_ROLE.
    /// @dev Reverts with {InvalidRewardAmount} if the reward amount is 0.
    /// @dev Reverts with {InvalidDuration} if the duration is 0.
    /// @dev Reverts with {RewardTooSmallForDuration} if the reward is too small for the duration.
    /// @dev Reverts with {RewardDilution} if the new reward rate is lower than the current one.
    /// @dev Emits a {RewardAdded} event with the rewarder address, reward amount, duration and dust.
    /// @param reward The amount of rewards to be added.
    /// @param duration The duration of the rewards distribution.
    function addReward(uint256 reward, uint256 duration) public payable virtual {
        address rewarder = _msgSender();
        AccessControlStorage.layout().enforceHasRole(REWARDER_ROLE, rewarder);

        require(reward != 0, InvalidRewardAmount());
        require(duration != 0, InvalidDuration());

        _updateReward(address(0));

        uint256 dust;
        uint256 currentDistributionEnd = distributionEnd;
        uint256 newDisrtibutionEnd = block.timestamp + duration;

        if (block.timestamp >= currentDistributionEnd) {
            // No current distribution
            uint256 newRewardRate = reward / duration;
            require(newRewardRate != 0, RewardTooSmallForDuration(reward, duration));
            rewardRate = newRewardRate;
            dust = reward % duration;
            distributionEnd = newDisrtibutionEnd;
        } else {
            if (newDisrtibutionEnd <= currentDistributionEnd) {
                // New distribution ends before current distribution
                duration = currentDistributionEnd - block.timestamp;
                uint256 additionalRewardRate = reward / duration;
                require(additionalRewardRate != 0, RewardTooSmallForDuration(reward, duration));
                rewardRate += additionalRewardRate;
                dust = reward % duration;
            } else {
                // New distribution ends after current distribution
                require(reward / duration != 0, RewardTooSmallForDuration(reward, duration));
                uint256 currentRewardRate = rewardRate;
                uint256 remainingReward = currentRewardRate * (currentDistributionEnd - block.timestamp);
                uint256 totalReward = remainingReward + reward;
                uint256 newRewardRate = totalReward / duration;
                require(newRewardRate >= currentRewardRate, RewardDilution(currentRewardRate, newRewardRate));
                rewardRate = newRewardRate;
                distributionEnd = newDisrtibutionEnd;
                dust = totalReward % duration;
            }
        }
        lastUpdated = block.timestamp;

        _computeAddReward(rewarder, reward, dust);

        emit RewardAdded(rewarder, reward, duration, dust);
    }

    /// @notice Performs a stake (deposit some asset in the pool), for example by transferring staking tokens to this contract.
    /// @notice Computes the amount of stake points for the sender based on the stakeData.
    /// @param sender The address of the sender.
    /// @param stakeData The data to be used for the stake (encoding freely determined by the deriving contracts).
    /// @return stakePoints The amount of stake points computed from the stakeData.
    function _computeStake(address sender, bytes memory stakeData) internal virtual returns (uint256 stakePoints);

    /// @notice Performs a withdrawal (remove some asset from the pool), for example by transferring taking tokens from this contract.
    /// @notice Computes the amount of stake points for the sender based on the withdrawData.
    /// @param sender The address of the sender.
    /// @param withdrawData The data to be used for the withdraw (encoding freely determined by the deriving contracts).
    /// @return stakePoints The amount of stake points computed from the withdrawData.
    function _computeWithdraw(address sender, bytes memory withdrawData) internal virtual returns (uint256 stakePoints);

    /// @notice Performs a claim, for examples by transferring reward tokens to the sender.
    /// @param sender The address of the sender.
    /// @param reward The amount of rewards to be claimed.
    /// @return claimData The data used in the claim process (encoding freely determined by the deriving contracts).
    function _computeClaim(address sender, uint256 reward) internal virtual returns (bytes memory claimData);

    /// @notice Performs addition of rewards to the pool, for example by transferring rewards tokens to this contract.
    /// @param sender The address of the sender.
    /// @param reward The amount of rewards to be added.
    /// @param dust The amount of dust (remainder of the division of the reward by the duration).
    function _computeAddReward(address sender, uint256 reward, uint256 dust) internal virtual;
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.28;

import {LinearPoolzk} from "../LinearPoolzk.sol";
import {ERC20Receiver} from "@animoca/ethereum-contracts/contracts/token/ERC20/ERC20Receiver.sol";
import {TokenRecoveryBase} from "@animoca/ethereum-contracts/contracts/security/base/TokenRecoveryBase.sol";
import {SafeERC20, IERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

/// @title ERC20StakingLinearPool
/// @notice A linear pool that allows staking of ERC20 tokens.
/// @notice WARNING: This contract is not compatible with fee-on-transfer and rebasing tokens.
abstract contract ERC20StakingLinearPoolzk is LinearPoolzk, ERC20Receiver {
    using SafeERC20 for IERC20;

    IERC20 public immutable STAKING_TOKEN;

    error InvalidToken();
    error InvalidRecoveryAmount(uint256 requested, uint256 recoverable);

    constructor(IERC20 stakingToken) {
        STAKING_TOKEN = stakingToken;
    }

    /// @notice Callback called when the contract receives ERC20 tokens via the IERC20SafeTransfers functions.
    /// @dev Reverts  with {InvalidToken} if the sender is not the staking token.
    /// @param from The address of the sender.
    /// @param value The amount of tokens received.
    /// @return bytes4 The function selector of the callback.
    function onERC20Received(address, address from, uint256 value, bytes calldata) external virtual override returns (bytes4) {
        if (msg.sender != address(STAKING_TOKEN)) revert InvalidToken();
        bool requiresTransfer = false;
        _stake(from, abi.encode(requiresTransfer, abi.encode(value)));
        return this.onERC20Received.selector;
    }

    /// @inheritdoc LinearPoolzk
    /// @param stakeData The data to be used for staking, encoded as (uint256 value)
    function stake(bytes calldata stakeData) public payable virtual override {
        bool requiresTransfer = true;
        _stake(_msgSender(), abi.encode(requiresTransfer, stakeData));
    }

    /// @inheritdoc LinearPoolzk
    /// @param stakeData The data to be used for staking, encoded as (bool requiresTransfer, bytes data) where data is (uint256 value).
    function _computeStake(address staker, bytes memory stakeData) internal virtual override returns (uint256 stakePoints) {
        (bool requiresTransfer, bytes memory data) = abi.decode(stakeData, (bool, bytes));
        stakePoints = abi.decode(data, (uint256));
        if (requiresTransfer) {
            STAKING_TOKEN.safeTransferFrom(staker, address(this), stakePoints);
        }
    }

    /// @inheritdoc LinearPoolzk
    /// @param withdrawData The data to be used for withdrawing, encoded as (uint256 value)
    function _computeWithdraw(address staker, bytes memory withdrawData) internal virtual override returns (uint256 stakePoints) {
        stakePoints = abi.decode(withdrawData, (uint256));
        STAKING_TOKEN.safeTransfer(staker, stakePoints);
    }

    /// @inheritdoc TokenRecoveryBase
    /// @dev Reverts with {InvalidRecoveryAmount} if recovering some STAKING_TOKEN in greater quatity than what is recoverable.
    function recoverERC20s(address[] calldata accounts, IERC20[] calldata tokens, uint256[] calldata amounts) public virtual override {
        uint256 stakingTokenRecoveryAmount;
        for (uint256 i; i < tokens.length; ++i) {
            if (tokens[i] == STAKING_TOKEN) {
                stakingTokenRecoveryAmount += amounts[i];
            }
        }
        if (stakingTokenRecoveryAmount != 0) {
            uint256 recoverable = STAKING_TOKEN.balanceOf(address(this)) - totalStaked;
            if (stakingTokenRecoveryAmount > recoverable) {
                revert InvalidRecoveryAmount(stakingTokenRecoveryAmount, recoverable);
            }
        }
        super.recoverERC20s(accounts, tokens, amounts);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.2.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.20;

import {IERC20} from "../IERC20.sol";
import {IERC1363} from "../../../interfaces/IERC1363.sol";

/**
 * @title SafeERC20
 * @dev Wrappers around ERC-20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    /**
     * @dev An operation with an ERC-20 token failed.
     */
    error SafeERC20FailedOperation(address token);

    /**
     * @dev Indicates a failed `decreaseAllowance` request.
     */
    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
    }

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     *
     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the "client"
     * smart contract uses ERC-7674 to set temporary allowances, then the "client" smart contract should avoid using
     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract
     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        forceApprove(token, spender, oldAllowance + value);
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
     * value, non-reverting calls are assumed to be successful.
     *
     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the "client"
     * smart contract uses ERC-7674 to set temporary allowances, then the "client" smart contract should avoid using
     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract
     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
        unchecked {
            uint256 currentAllowance = token.allowance(address(this), spender);
            if (currentAllowance < requestedDecrease) {
                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
            }
            forceApprove(token, spender, currentAllowance - requestedDecrease);
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
     * to be set to zero before setting it to a non-zero value, such as USDT.
     *
     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function
     * only sets the "standard" allowance. Any temporary allowance will remain active, in addition to the value being
     * set here.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));

        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
            _callOptionalReturn(token, approvalCall);
        }
    }

    /**
     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no
     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
     * targeting contracts.
     *
     * Reverts if the returned value is other than `true`.
     */
    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
        if (to.code.length == 0) {
            safeTransfer(token, to, value);
        } else if (!token.transferAndCall(to, value, data)) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target
     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
     * targeting contracts.
     *
     * Reverts if the returned value is other than `true`.
     */
    function transferFromAndCallRelaxed(
        IERC1363 token,
        address from,
        address to,
        uint256 value,
        bytes memory data
    ) internal {
        if (to.code.length == 0) {
            safeTransferFrom(token, from, to, value);
        } else if (!token.transferFromAndCall(from, to, value, data)) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no
     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
     * targeting contracts.
     *
     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.
     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}
     * once without retrying, and relies on the returned value to be true.
     *
     * Reverts if the returned value is other than `true`.
     */
    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
        if (to.code.length == 0) {
            forceApprove(token, to, value);
        } else if (!token.approveAndCall(to, value, data)) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     *
     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        uint256 returnSize;
        uint256 returnValue;
        assembly ("memory-safe") {
            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)
            // bubble errors
            if iszero(success) {
                let ptr := mload(0x40)
                returndatacopy(ptr, 0, returndatasize())
                revert(ptr, returndatasize())
            }
            returnSize := returndatasize()
            returnValue := mload(0)
        }

        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     *
     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        bool success;
        uint256 returnSize;
        uint256 returnValue;
        assembly ("memory-safe") {
            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)
            returnSize := returndatasize()
            returnValue := mload(0)
        }
        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.28;

interface ILinearPoolzk {
    function lastTimeRewardApplicable() external view returns (uint256);

    function rewardPerStakePoint() external view returns (uint256);

    function earned(address account) external view returns (uint256);

    function stake(bytes calldata stakeData) external payable;

    function withdraw(bytes calldata withdrawData) external;

    function claim() external;

    function addReward(uint256 reward, uint256 duration) external payable;
}

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

import {ContractOwnershipStorage} from "./libraries/ContractOwnershipStorage.sol";
import {ContractOwnershipBase} from "./base/ContractOwnershipBase.sol";
import {InterfaceDetection} from "./../introspection/InterfaceDetection.sol";

/// @title ERC173 Contract Ownership Standard (immutable version).
/// @dev See https://eips.ethereum.org/EIPS/eip-173
/// @dev This contract is to be used via inheritance in an immutable (non-proxied) implementation.
abstract contract ContractOwnership is ContractOwnershipBase, InterfaceDetection {
    using ContractOwnershipStorage for ContractOwnershipStorage.Layout;

    /// @notice Initializes the storage with an initial contract owner.
    /// @notice Marks the following ERC165 interface(s) as supported: ERC173.
    /// @dev Emits an {OwnershipTransferred} if `initialOwner` is not the zero address.
    /// @param initialOwner the initial contract owner.
    constructor(address initialOwner) {
        ContractOwnershipStorage.layout().constructorInit(initialOwner);
    }
}

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

import {AccessControlBase} from "./base/AccessControlBase.sol";
import {ContractOwnership} from "./ContractOwnership.sol";

/// @title Access control via roles management (immutable version).
/// @dev This contract is to be used via inheritance in an immutable (non-proxied) implementation.
abstract contract AccessControl is AccessControlBase, ContractOwnership {}

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

import {TokenRecoveryBase} from "./base/TokenRecoveryBase.sol";
import {ContractOwnership} from "./../access/ContractOwnership.sol";

/// @title Recovery mechanism for ETH/ERC20/ERC721 tokens accidentally sent to this contract (immutable version).
/// @dev This contract is to be used via inheritance in an immutable (non-proxied) implementation.
abstract contract TokenRecovery is TokenRecoveryBase, ContractOwnership {}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/ReentrancyGuard.sol)

pragma solidity ^0.8.20;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If EIP-1153 (transient storage) is available on the chain you're deploying at,
 * consider using {ReentrancyGuardTransient} instead.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant NOT_ENTERED = 1;
    uint256 private constant ENTERED = 2;

    uint256 private _status;

    /**
     * @dev Unauthorized reentrant call.
     */
    error ReentrancyGuardReentrantCall();

    constructor() {
        _status = NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be NOT_ENTERED
        if (_status == ENTERED) {
            revert ReentrancyGuardReentrantCall();
        }

        // Any calls to nonReentrant after this point will fail
        _status = ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = NOT_ENTERED;
    }

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == ENTERED;
    }
}

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

import {NotRoleHolder, NotTargetContractRoleHolder} from "./../errors/AccessControlErrors.sol";
import {TargetIsNotAContract} from "./../errors/Common.sol";
import {RoleGranted, RoleRevoked} from "./../events/AccessControlEvents.sol";
import {IAccessControl} from "./../interfaces/IAccessControl.sol";
import {Address} from "./../../utils/libraries/Address.sol";

library AccessControlStorage {
    using Address for address;
    using AccessControlStorage for AccessControlStorage.Layout;

    struct Layout {
        mapping(bytes32 => mapping(address => bool)) roles;
    }

    bytes32 internal constant LAYOUT_STORAGE_SLOT = bytes32(uint256(keccak256("animoca.core.access.AccessControl.storage")) - 1);

    /// @notice Grants a role to an account.
    /// @dev Note: Call to this function should be properly access controlled.
    /// @dev Emits a {RoleGranted} event if the account did not previously have the role.
    /// @param role The role to grant.
    /// @param account The account to grant the role to.
    /// @param operator The account requesting the role change.
    function grantRole(Layout storage s, bytes32 role, address account, address operator) internal {
        if (!s.hasRole(role, account)) {
            s.roles[role][account] = true;
            emit RoleGranted(role, account, operator);
        }
    }

    /// @notice Revokes a role from an account.
    /// @dev Note: Call to this function should be properly access controlled.
    /// @dev Emits a {RoleRevoked} event if the account previously had the role.
    /// @param role The role to revoke.
    /// @param account The account to revoke the role from.
    /// @param operator The account requesting the role change.
    function revokeRole(Layout storage s, bytes32 role, address account, address operator) internal {
        if (s.hasRole(role, account)) {
            s.roles[role][account] = false;
            emit RoleRevoked(role, account, operator);
        }
    }

    /// @notice Renounces a role by the sender.
    /// @dev Reverts with {NotRoleHolder} if `sender` does not have `role`.
    /// @dev Emits a {RoleRevoked} event.
    /// @param sender The message sender.
    /// @param role The role to renounce.
    function renounceRole(Layout storage s, address sender, bytes32 role) internal {
        s.enforceHasRole(role, sender);
        s.roles[role][sender] = false;
        emit RoleRevoked(role, sender, sender);
    }

    /// @notice Retrieves whether an account has a role.
    /// @param role The role.
    /// @param account The account.
    /// @return hasRole_ Whether `account` has `role`.
    function hasRole(Layout storage s, bytes32 role, address account) internal view returns (bool hasRole_) {
        return s.roles[role][account];
    }

    /// @notice Checks whether an account has a role in a target contract.
    /// @param targetContract The contract to check.
    /// @param role The role to check.
    /// @param account The account to check.
    /// @return hasTargetContractRole_ Whether `account` has `role` in `targetContract`.
    function hasTargetContractRole(address targetContract, bytes32 role, address account) internal view returns (bool hasTargetContractRole_) {
        if (!targetContract.hasBytecode()) revert TargetIsNotAContract(targetContract);
        return IAccessControl(targetContract).hasRole(role, account);
    }

    /// @notice Ensures that an account has a role.
    /// @dev Reverts with {NotRoleHolder} if `account` does not have `role`.
    /// @param role The role.
    /// @param account The account.
    function enforceHasRole(Layout storage s, bytes32 role, address account) internal view {
        if (!s.hasRole(role, account)) revert NotRoleHolder(role, account);
    }

    /// @notice Enforces that an account has a role in a target contract.
    /// @dev Reverts with {NotTargetContractRoleHolder} if the account does not have the role.
    /// @param targetContract The contract to check.
    /// @param role The role to check.
    /// @param account The account to check.
    function enforceHasTargetContractRole(address targetContract, bytes32 role, address account) internal view {
        if (!hasTargetContractRole(targetContract, role, account)) revert NotTargetContractRoleHolder(targetContract, role, account);
    }

    function layout() internal pure returns (Layout storage s) {
        bytes32 position = LAYOUT_STORAGE_SLOT;
        assembly {
            s.slot := position
        }
    }
}

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

import {IERC20Receiver} from "./interfaces/IERC20Receiver.sol";
import {InterfaceDetectionStorage} from "../../introspection/libraries/InterfaceDetectionStorage.sol";
import {InterfaceDetection} from "../../introspection/InterfaceDetection.sol";

/// @title ERC20 Fungible Token Standard, Receiver (immutable version).
/// @dev This contract is to be used via inheritance in an immutable (non-proxied) implementation.
abstract contract ERC20Receiver is IERC20Receiver, InterfaceDetection {
    using InterfaceDetectionStorage for InterfaceDetectionStorage.Layout;

    /// @notice Marks the following ERC165 interface(s) as supported: ERC20Receiver.
    constructor() {
        InterfaceDetectionStorage.layout().setSupportedInterface(type(IERC20Receiver).interfaceId, true);
    }
}

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

import {IERC20} from "@openzeppelin/contracts/interfaces/IERC20.sol";
import {IERC721} from "./../../token/ERC721/interfaces/IERC721.sol";
import {ITokenRecovery} from "./../interfaces/ITokenRecovery.sol";
import {ContractOwnershipStorage} from "./../../access/libraries/ContractOwnershipStorage.sol";
import {TokenRecoveryLibrary} from "./../libraries/TokenRecoveryLibrary.sol";
import {Context} from "@openzeppelin/contracts/utils/Context.sol";

/// @title Recovery mechanism for ETH/ERC20/ERC721 tokens accidentally sent to this contract (proxiable version).
/// @dev This contract is to be used via inheritance in a proxied implementation.
/// @dev Note: This contract requires ERC173 (Contract Ownership standard).
abstract contract TokenRecoveryBase is ITokenRecovery, Context {
    using ContractOwnershipStorage for ContractOwnershipStorage.Layout;

    /// @inheritdoc ITokenRecovery
    /// @dev Reverts with {NotContractOwner} if the sender is not the contract owner.
    /// @dev Reverts with {InconsistentArrayLengths} `accounts` and `amounts` do not have the same length.
    /// @dev Reverts if one of the ETH transfers fails for any reason.
    function recoverETH(address payable[] calldata accounts, uint256[] calldata amounts) public virtual {
        ContractOwnershipStorage.layout().enforceIsContractOwner(_msgSender());
        TokenRecoveryLibrary.recoverETH(accounts, amounts);
    }

    /// @inheritdoc ITokenRecovery
    /// @dev Reverts with {NotContractOwner} if the sender is not the contract owner.
    /// @dev Reverts with {InconsistentArrayLengths} if `accounts`, `tokens` and `amounts` do not have the same length.
    /// @dev Reverts if one of the ERC20 transfers fails for any reason.
    function recoverERC20s(address[] calldata accounts, IERC20[] calldata tokens, uint256[] calldata amounts) public virtual {
        ContractOwnershipStorage.layout().enforceIsContractOwner(_msgSender());
        TokenRecoveryLibrary.recoverERC20s(accounts, tokens, amounts);
    }

    /// @inheritdoc ITokenRecovery
    /// @dev Reverts with {NotContractOwner} if the sender is not the contract owner.
    /// @dev Reverts with {InconsistentArrayLengths} if `accounts`, `contracts` and `amounts` do not have the same length.
    /// @dev Reverts if one of the ERC721 transfers fails for any reason.
    function recoverERC721s(address[] calldata accounts, IERC721[] calldata contracts, uint256[] calldata tokenIds) public virtual {
        ContractOwnershipStorage.layout().enforceIsContractOwner(_msgSender());
        TokenRecoveryLibrary.recoverERC721s(accounts, contracts, tokenIds);
    }
}

// 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: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/IERC1363.sol)

pragma solidity ^0.8.20;

import {IERC20} from "./IERC20.sol";
import {IERC165} from "./IERC165.sol";

/**
 * @title IERC1363
 * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].
 *
 * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract
 * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.
 */
interface IERC1363 is IERC20, IERC165 {
    /*
     * Note: the ERC-165 identifier for this interface is 0xb0202a11.
     * 0xb0202a11 ===
     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^
     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^
     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^
     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^
     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^
     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))
     */

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferAndCall(address to, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @param data Additional data with no specified format, sent in call to `to`.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param from The address which you want to send tokens from.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param from The address which you want to send tokens from.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @param data Additional data with no specified format, sent in call to `to`.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
     * @param spender The address which will spend the funds.
     * @param value The amount of tokens to be spent.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function approveAndCall(address spender, uint256 value) external returns (bool);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
     * @param spender The address which will spend the funds.
     * @param value The amount of tokens to be spent.
     * @param data Additional data with no specified format, sent in call to `spender`.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
}

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

import {IERC165} from "./interfaces/IERC165.sol";
import {InterfaceDetectionStorage} from "./libraries/InterfaceDetectionStorage.sol";

/// @title ERC165 Interface Detection Standard (immutable or proxiable version).
/// @dev This contract is to be used via inheritance in an immutable (non-proxied) or proxied implementation.
abstract contract InterfaceDetection is IERC165 {
    using InterfaceDetectionStorage for InterfaceDetectionStorage.Layout;

    /// @inheritdoc IERC165
    function supportsInterface(bytes4 interfaceId) external view returns (bool) {
        return InterfaceDetectionStorage.layout().supportsInterface(interfaceId);
    }
}

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

/// @notice Thrown when the target contract is actually not a contract.
/// @param targetContract The contract that was checked
error TargetIsNotAContract(address targetContract);

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

/// @notice Thrown when an account does not have the required role.
/// @param role The role the caller is missing.
/// @param account The account that was checked.
error NotRoleHolder(bytes32 role, address account);

/// @notice Thrown when an account does not have the required role on a target contract.
/// @param targetContract The contract that was checked.
/// @param role The role that was checked.
/// @param account The account that was checked.
error NotTargetContractRoleHolder(address targetContract, bytes32 role, address account);

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

library Address {
    /// @notice Checks if the address is a deployed smart contract.
    /// @param addr The address to check.
    /// @return hasBytecode True if `addr` is a deployed smart contract, false otherwise.
    function hasBytecode(address addr) internal view returns (bool) {
        uint256 size;
        assembly {
            size := extcodesize(addr)
        }
        return size != 0;
    }
}

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

/// @notice Emitted when `role` is granted to `account`.
/// @param role The role that has been granted.
/// @param account The account that has been granted the role.
/// @param operator The account that granted the role.
event RoleGranted(bytes32 role, address account, address operator);

/// @notice Emitted when `role` is revoked from `account`.
/// @param role The role that has been revoked.
/// @param account The account that has been revoked the role.
/// @param operator The account that revoked the role.
event RoleRevoked(bytes32 role, address account, address operator);

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

import {NotContractOwner, NotTargetContractOwner} from "./../errors/ContractOwnershipErrors.sol";
import {TargetIsNotAContract} from "./../errors/Common.sol";
import {OwnershipTransferred} from "./../events/ERC173Events.sol";
import {IERC173} from "./../interfaces/IERC173.sol";
import {Address} from "./../../utils/libraries/Address.sol";
import {ProxyInitialization} from "./../../proxy/libraries/ProxyInitialization.sol";
import {InterfaceDetectionStorage} from "./../../introspection/libraries/InterfaceDetectionStorage.sol";

library ContractOwnershipStorage {
    using Address for address;
    using ContractOwnershipStorage for ContractOwnershipStorage.Layout;
    using InterfaceDetectionStorage for InterfaceDetectionStorage.Layout;

    struct Layout {
        address contractOwner;
    }

    bytes32 internal constant LAYOUT_STORAGE_SLOT = bytes32(uint256(keccak256("animoca.core.access.ContractOwnership.storage")) - 1);
    bytes32 internal constant PROXY_INIT_PHASE_SLOT = bytes32(uint256(keccak256("animoca.core.access.ContractOwnership.phase")) - 1);

    /// @notice Initializes the storage with an initial contract owner (immutable version).
    /// @notice Marks the following ERC165 interface(s) as supported: ERC173.
    /// @dev Note: This function should be called ONLY in the constructor of an immutable (non-proxied) contract.
    /// @dev Emits an {OwnershipTransferred} if `initialOwner` is not the zero address.
    /// @param initialOwner The initial contract owner.
    function constructorInit(Layout storage s, address initialOwner) internal {
        if (initialOwner != address(0)) {
            s.contractOwner = initialOwner;
            emit OwnershipTransferred(address(0), initialOwner);
        }
        InterfaceDetectionStorage.layout().setSupportedInterface(type(IERC173).interfaceId, true);
    }

    /// @notice Initializes the storage with an initial contract owner (proxied version).
    /// @notice Sets the proxy initialization phase to `1`.
    /// @notice Marks the following ERC165 interface(s) as supported: ERC173.
    /// @dev Note: This function should be called ONLY in the init function of a proxied contract.
    /// @dev Reverts with {InitializationPhaseAlreadyReached} if the proxy initialization phase is set to `1` or above.
    /// @dev Emits an {OwnershipTransferred} if `initialOwner` is not the zero address.
    /// @param initialOwner The initial contract owner.
    function proxyInit(Layout storage s, address initialOwner) internal {
        ProxyInitialization.setPhase(PROXY_INIT_PHASE_SLOT, 1);
        s.constructorInit(initialOwner);
    }

    /// @notice Sets the address of the new contract owner.
    /// @dev Reverts with {NotContractOwner} if `sender` is not the contract owner.
    /// @dev Emits an {OwnershipTransferred} event if `newOwner` is different from the current contract owner.
    /// @param newOwner The address of the new contract owner. Using the zero address means renouncing ownership.
    function transferOwnership(Layout storage s, address sender, address newOwner) internal {
        address previousOwner = s.contractOwner;
        if (sender != previousOwner) revert NotContractOwner(sender);
        if (previousOwner != newOwner) {
            s.contractOwner = newOwner;
            emit OwnershipTransferred(previousOwner, newOwner);
        }
    }

    /// @notice Gets the address of the contract owner.
    /// @return contractOwner The address of the contract owner.
    function owner(Layout storage s) internal view returns (address contractOwner) {
        return s.contractOwner;
    }

    /// @notice Checks whether an account is the owner of a target contract.
    /// @param targetContract The contract to check.
    /// @param account The account to check.
    /// @return isTargetContractOwner_ Whether `account` is the owner of `targetContract`.
    function isTargetContractOwner(address targetContract, address account) internal view returns (bool isTargetContractOwner_) {
        if (!targetContract.hasBytecode()) revert TargetIsNotAContract(targetContract);
        return IERC173(targetContract).owner() == account;
    }

    /// @notice Ensures that an account is the contract owner.
    /// @dev Reverts with {NotContractOwner} if `account` is not the contract owner.
    /// @param account The account.
    function enforceIsContractOwner(Layout storage s, address account) internal view {
        if (account != s.contractOwner) revert NotContractOwner(account);
    }

    /// @notice Enforces that an account is the owner of a target contract.
    /// @dev Reverts with {NotTheTargetContractOwner} if the account is not the owner.
    /// @param targetContract The contract to check.
    /// @param account The account to check.
    function enforceIsTargetContractOwner(address targetContract, address account) internal view {
        if (!isTargetContractOwner(targetContract, account)) revert NotTargetContractOwner(targetContract, account);
    }

    function layout() internal pure returns (Layout storage s) {
        bytes32 position = LAYOUT_STORAGE_SLOT;
        assembly {
            s.slot := position
        }
    }
}

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

/// @title Access control via roles management (functions)
interface IAccessControl {
    /// @notice Renounces a role by the sender.
    /// @dev Reverts if `sender` does not have `role`.
    /// @dev Emits a {RoleRevoked} event.
    /// @param role The role to renounce.
    function renounceRole(bytes32 role) external;

    /// @notice Retrieves whether an account has a role.
    /// @param role The role.
    /// @param account The account.
    /// @return hasRole_ Whether `account` has `role`.
    function hasRole(bytes32 role, address account) external view returns (bool hasRole_);
}

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

import {IERC173} from "./../interfaces/IERC173.sol";
import {ContractOwnershipStorage} from "./../libraries/ContractOwnershipStorage.sol";
import {Context} from "@openzeppelin/contracts/utils/Context.sol";

/// @title ERC173 Contract Ownership Standard (proxiable version).
/// @dev See https://eips.ethereum.org/EIPS/eip-173
/// @dev This contract is to be used via inheritance in a proxied implementation.
/// @dev Note: This contract requires ERC165 (Interface Detection Standard).
abstract contract ContractOwnershipBase is IERC173, Context {
    using ContractOwnershipStorage for ContractOwnershipStorage.Layout;

    /// @inheritdoc IERC173
    function owner() public view virtual returns (address) {
        return ContractOwnershipStorage.layout().owner();
    }

    /// @inheritdoc IERC173
    function transferOwnership(address newOwner) public virtual {
        ContractOwnershipStorage.layout().transferOwnership(_msgSender(), newOwner);
    }
}

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

import {IAccessControl} from "./../../access/interfaces/IAccessControl.sol";
import {AccessControlStorage} from "./../libraries/AccessControlStorage.sol";
import {ContractOwnershipStorage} from "./../libraries/ContractOwnershipStorage.sol";
import {Context} from "@openzeppelin/contracts/utils/Context.sol";

/// @title Access control via roles management (proxiable version).
/// @dev This contract is to be used via inheritance in a proxied implementation.
/// @dev Note: This contract requires ERC173 (Contract Ownership standard).
abstract contract AccessControlBase is IAccessControl, Context {
    using AccessControlStorage for AccessControlStorage.Layout;
    using ContractOwnershipStorage for ContractOwnershipStorage.Layout;

    /// @notice Grants a role to an account.
    /// @dev Reverts with {NotContractOwner} if the sender is not the contract owner.
    /// @dev Emits a {RoleGranted} event if the account did not previously have the role.
    /// @param role The role to grant.
    /// @param account The account to grant the role to.
    function grantRole(bytes32 role, address account) external virtual {
        address operator = _msgSender();
        ContractOwnershipStorage.layout().enforceIsContractOwner(operator);
        AccessControlStorage.layout().grantRole(role, account, operator);
    }

    /// @notice Revokes a role from an account.
    /// @dev Reverts with {NotContractOwner} if the sender is not the contract owner.
    /// @dev Emits a {RoleRevoked} event if the account previously had the role.
    /// @param role The role to revoke.
    /// @param account The account to revoke the role from.
    function revokeRole(bytes32 role, address account) external virtual {
        address operator = _msgSender();
        ContractOwnershipStorage.layout().enforceIsContractOwner(operator);
        AccessControlStorage.layout().revokeRole(role, account, operator);
    }

    /// @inheritdoc IAccessControl
    function renounceRole(bytes32 role) external virtual {
        AccessControlStorage.layout().renounceRole(_msgSender(), role);
    }

    /// @inheritdoc IAccessControl
    function hasRole(bytes32 role, address account) external view virtual returns (bool hasRole_) {
        return AccessControlStorage.layout().hasRole(role, account);
    }
}

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

import {IllegalInterfaceId} from "./../errors/InterfaceDetectionErrors.sol";
import {IERC165} from "./../interfaces/IERC165.sol";

library InterfaceDetectionStorage {
    struct Layout {
        mapping(bytes4 => bool) supportedInterfaces;
    }

    bytes32 internal constant LAYOUT_STORAGE_SLOT = bytes32(uint256(keccak256("animoca.core.introspection.InterfaceDetection.storage")) - 1);

    bytes4 internal constant ILLEGAL_INTERFACE_ID = 0xffffffff;

    /// @notice Sets or unsets an ERC165 interface.
    /// @dev Revertswith {IllegalInterfaceId} if `interfaceId` is `0xffffffff`.
    /// @param interfaceId the interface identifier.
    /// @param supported True to set the interface, false to unset it.
    function setSupportedInterface(Layout storage s, bytes4 interfaceId, bool supported) internal {
        if (interfaceId == ILLEGAL_INTERFACE_ID) revert IllegalInterfaceId();
        s.supportedInterfaces[interfaceId] = supported;
    }

    /// @notice Returns whether this contract implements a given interface.
    /// @dev Note: This function call must use less than 30 000 gas.
    /// @param interfaceId The interface identifier to test.
    /// @return supported True if the interface is supported, false if `interfaceId` is `0xffffffff` or if the interface is not supported.
    function supportsInterface(Layout storage s, bytes4 interfaceId) internal view returns (bool supported) {
        if (interfaceId == ILLEGAL_INTERFACE_ID) {
            return false;
        }
        if (interfaceId == type(IERC165).interfaceId) {
            return true;
        }
        return s.supportedInterfaces[interfaceId];
    }

    function layout() internal pure returns (Layout storage s) {
        bytes32 position = LAYOUT_STORAGE_SLOT;
        assembly {
            s.slot := position
        }
    }
}

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

import {IERC20} from "@openzeppelin/contracts/interfaces/IERC20.sol";
import {IERC721} from "./../../token/ERC721/interfaces/IERC721.sol";

/// @title Uniquely identified seals management.
interface ITokenRecovery {
    /// @notice Extract ETH tokens which were accidentally sent to the contract to a list of accounts.
    /// @dev Note: While contracts can generally prevent accidental ETH transfer by implementating a reverting
    ///  `receive()` function, this can still be bypassed in a `selfdestruct(address)` scenario.
    /// @dev Warning: this function should be overriden for contracts which are supposed to hold ETH tokens
    ///  so that the extraction is limited to only amounts sent accidentally.
    /// @param accounts the list of accounts to transfer the tokens to.
    /// @param amounts the list of token amounts to transfer.
    function recoverETH(address payable[] calldata accounts, uint256[] calldata amounts) external;

    /// @notice Extract ERC20 tokens which were accidentally sent to the contract to a list of accounts.
    /// @dev Warning: this function should be overriden for contracts which are supposed to hold ERC20 tokens
    ///  so that the extraction is limited to only amounts sent accidentally.
    /// @param accounts the list of accounts to transfer the tokens to.
    /// @param tokens the list of ERC20 token addresses.
    /// @param amounts the list of token amounts to transfer.
    function recoverERC20s(address[] calldata accounts, IERC20[] calldata tokens, uint256[] calldata amounts) external;

    /// @notice Extract ERC721 tokens which were accidentally sent to the contract to a list of accounts.
    /// @dev Warning: this function should be overriden for contracts which are supposed to hold ERC721 tokens
    ///  so that the extraction is limited to only tokens sent accidentally.
    /// @param accounts the list of accounts to transfer the tokens to.
    /// @param contracts the list of ERC721 contract addresses.
    /// @param tokenIds the list of token ids to transfer.
    function recoverERC721s(address[] calldata accounts, IERC721[] calldata contracts, uint256[] calldata tokenIds) external;
}

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

import {InconsistentArrayLengths} from "./../../CommonErrors.sol";
import {IERC20} from "@openzeppelin/contracts/interfaces/IERC20.sol";
import {IERC721} from "./../../token/ERC721/interfaces/IERC721.sol";
import {IERC165} from "./../../introspection/interfaces/IERC165.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {Address} from "@openzeppelin/contracts/utils/Address.sol";

library TokenRecoveryLibrary {
    using SafeERC20 for IERC20;
    using Address for address payable;

    /// @notice Thrown when trying to recover a token of the wrong contract type.
    /// @param tokenContract The token contract being recovered.
    error IncorrectTokenContractType(address tokenContract);

    /// @notice Extract ETH tokens which were accidentally sent to the contract to a list of accounts.
    /// @dev Note: While contracts can generally prevent accidental ETH transfer by implementating a reverting
    ///  `receive()` function, this can still be bypassed in a `selfdestruct(address)` scenario.
    /// @dev Warning: this function should be overriden for contracts which are supposed to hold ETH tokens
    ///  so that the extraction is limited to only amounts sent accidentally.
    /// @dev Reverts with {InconsistentArrayLengths} `accounts` and `amounts` do not have the same length.
    /// @dev Reverts if one of the ETH transfers fails for any reason.
    /// @param accounts the list of accounts to transfer the tokens to.
    /// @param amounts the list of token amounts to transfer.
    function recoverETH(address payable[] calldata accounts, uint256[] calldata amounts) internal {
        uint256 length = accounts.length;
        if (length != amounts.length) revert InconsistentArrayLengths();
        for (uint256 i; i < length; ++i) {
            accounts[i].sendValue(amounts[i]);
        }
    }

    /// @notice Extract ERC20 tokens which were accidentally sent to the contract to a list of accounts.
    /// @dev Warning: this function should be overriden for contracts which are supposed to hold ERC20 tokens
    ///  so that the extraction is limited to only amounts sent accidentally.
    /// @dev Reverts with {InconsistentArrayLengths} if `accounts`, `tokens` and `amounts` do not have the same length.
    /// @dev Reverts if one of the ERC20 transfers fails for any reason.
    /// @param accounts the list of accounts to transfer the tokens to.
    /// @param tokens the list of ERC20 token addresses.
    /// @param amounts the list of token amounts to transfer.
    function recoverERC20s(address[] calldata accounts, IERC20[] calldata tokens, uint256[] calldata amounts) internal {
        uint256 length = accounts.length;
        if (length != tokens.length || length != amounts.length) revert InconsistentArrayLengths();
        for (uint256 i; i < length; ++i) {
            tokens[i].safeTransfer(accounts[i], amounts[i]);
        }
    }

    /// @notice Extract ERC721 tokens which were accidentally sent to the contract to a list of accounts.
    /// @dev Warning: this function should be overriden for contracts which are supposed to hold ERC721 tokens
    ///  so that the extraction is limited to only tokens sent accidentally.
    /// @dev Reverts with {InconsistentArrayLengths} if `accounts`, `contracts` and `amounts` do not have the same length.
    /// @dev Reverts if one of the ERC721 transfers fails for any reason.
    /// @param accounts the list of accounts to transfer the tokens to.
    /// @param contracts the list of ERC721 contract addresses.
    /// @param tokenIds the list of token ids to transfer.
    function recoverERC721s(address[] calldata accounts, IERC721[] calldata contracts, uint256[] calldata tokenIds) internal {
        uint256 length = accounts.length;
        if (length != contracts.length || length != tokenIds.length) revert InconsistentArrayLengths();
        for (uint256 i; i < length; ++i) {
            IERC721 tokenContract = contracts[i];
            if (!IERC165(address(tokenContract)).supportsInterface(type(IERC721).interfaceId)) {
                revert IncorrectTokenContractType(address(tokenContract));
            }
            contracts[i].safeTransferFrom(address(this), accounts[i], tokenIds[i]);
        }
    }
}

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

/// @title ERC721 Non-Fungible Token Standard, basic interface (functions).
/// @dev See https://eips.ethereum.org/EIPS/eip-721
/// @dev This interface only contains the standard functions. See IERC721Events for the events.
/// @dev Note: The ERC-165 identifier for this interface is 0x80ac58cd.
interface IERC721 {
    /// @notice Sets or unsets an approval to transfer a single token on behalf of its owner.
    /// @dev Note: There can only be one approved address per token at a given time.
    /// @dev Note: A token approval gets reset when this token is transferred, including a self-transfer.
    /// @dev Reverts if `tokenId` does not exist.
    /// @dev Reverts if `to` is the token owner.
    /// @dev Reverts if the sender is not the token owner and has not been approved by the token owner.
    /// @dev Emits an {Approval} event.
    /// @param to The address to approve, or the zero address to remove any existing approval.
    /// @param tokenId The token identifier to give approval for.
    function approve(address to, uint256 tokenId) external;

    /// @notice Sets or unsets an approval to transfer all tokens on behalf of their owner.
    /// @dev Reverts if the sender is the same as `operator`.
    /// @dev Emits an {ApprovalForAll} event.
    /// @param operator The address to approve for all tokens.
    /// @param approved True to set an approval for all tokens, false to unset it.
    function setApprovalForAll(address operator, bool approved) external;

    /// @notice Unsafely transfers the ownership of a token to a recipient.
    /// @dev Note: Usage of this method is discouraged, use `safeTransferFrom` whenever possible.
    /// @dev Resets the token approval for `tokenId`.
    /// @dev Reverts if `to` is the zero address.
    /// @dev Reverts if `from` is not the owner of `tokenId`.
    /// @dev Reverts if the sender is not `from` and has not been approved by `from` for `tokenId`.
    /// @dev Emits a {Transfer} event.
    /// @param from The current token owner.
    /// @param to The recipient of the token transfer. Self-transfers are possible.
    /// @param tokenId The identifier of the token to transfer.
    function transferFrom(address from, address to, uint256 tokenId) external;

    /// @notice Safely transfers the ownership of a token to a recipient.
    /// @dev Resets the token approval for `tokenId`.
    /// @dev Reverts if `to` is the zero address.
    /// @dev Reverts if `from` is not the owner of `tokenId`.
    /// @dev Reverts if the sender is not `from` and has not been approved by `from` for `tokenId`.
    /// @dev Reverts if `to` is a contract and the call to {IERC721Receiver-onERC721Received} fails, reverts or is rejected.
    /// @dev Emits a {Transfer} event.
    /// @param from The current token owner.
    /// @param to The recipient of the token transfer.
    /// @param tokenId The identifier of the token to transfer.
    function safeTransferFrom(address from, address to, uint256 tokenId) external;

    /// @notice Safely transfers the ownership of a token to a recipient.
    /// @dev Resets the token approval for `tokenId`.
    /// @dev Reverts if `to` is the zero address.
    /// @dev Reverts if `from` is not the owner of `tokenId`.
    /// @dev Reverts if the sender is not `from` and has not been approved by `from` for `tokenId`.
    /// @dev Reverts if `to` is a contract and the call to {IERC721Receiver-onERC721Received} fails, reverts or is rejected.
    /// @dev Emits a {Transfer} event.
    /// @param from The current token owner.
    /// @param to The recipient of the token transfer.
    /// @param tokenId The identifier of the token to transfer.
    /// @param data Optional data to send along to a receiver contract.
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;

    /// @notice Gets the balance of an address.
    /// @dev Reverts if `owner` is the zero address.
    /// @param owner The address to query the balance of.
    /// @return balance The amount owned by the owner.
    function balanceOf(address owner) external view returns (uint256 balance);

    /// @notice Gets the owner of a token.
    /// @dev Reverts if `tokenId` does not exist.
    /// @param tokenId The token identifier to query the owner of.
    /// @return tokenOwner The owner of the token identifier.
    function ownerOf(uint256 tokenId) external view returns (address tokenOwner);

    /// @notice Gets the approved address for a token.
    /// @dev Reverts if `tokenId` does not exist.
    /// @param tokenId The token identifier to query the approval of.
    /// @return approved The approved address for the token identifier, or the zero address if no approval is set.
    function getApproved(uint256 tokenId) external view returns (address approved);

    /// @notice Gets whether an operator is approved for all tokens by an owner.
    /// @param owner The address which gives the approval for all tokens.
    /// @param operator The address which receives the approval for all tokens.
    /// @return approvedForAll Whether the operator is approved for all tokens by the owner.
    function isApprovedForAll(address owner, address operator) external view returns (bool approvedForAll);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC20.sol)

pragma solidity ^0.8.20;

import {IERC20} from "../token/ERC20/IERC20.sol";

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

/// @title ERC20 Token Standard, Tokens Receiver.
/// @notice Interface for supporting safe transfers from ERC20 contracts with the Safe Transfers extension.
/// @dev See https://eips.ethereum.org/EIPS/eip-20
/// @dev Note: the ERC-165 identifier for this interface is 0x4fc35859.
interface IERC20Receiver {
    /// @notice Handles the receipt of ERC20 tokens.
    /// @dev Note: this function is called by an {ERC20SafeTransfer} contract after a safe transfer.
    /// @param operator The initiator of the safe transfer.
    /// @param from The previous tokens owner.
    /// @param value The amount of tokens transferred.
    /// @param data Optional additional data with no specified format.
    /// @return magicValue `bytes4(keccak256("onERC20Received(address,address,uint256,bytes)"))` (`0x4fc35859`) to accept, any other value to refuse.
    function onERC20Received(address operator, address from, uint256 value, bytes calldata data) external returns (bytes4 magicValue);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC165.sol)

pragma solidity ^0.8.20;

import {IERC165} from "../utils/introspection/IERC165.sol";

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

/// @title ERC165 Interface Detection Standard.
/// @dev See https://eips.ethereum.org/EIPS/eip-165.
/// @dev Note: The ERC-165 identifier for this interface is 0x01ffc9a7.
interface IERC165 {
    /// @notice Returns whether this contract implements a given interface.
    /// @dev Note: This function call must use less than 30 000 gas.
    /// @param interfaceId the interface identifier to test.
    /// @return supported True if the interface is supported, false if `interfaceId` is `0xffffffff` or if the interface is not supported.
    function supportsInterface(bytes4 interfaceId) external view returns (bool supported);
}

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

import {InitializationPhaseAlreadyReached} from "./../errors/ProxyInitializationErrors.sol";
import {StorageSlot} from "@openzeppelin/contracts/utils/StorageSlot.sol";

/// @notice Multiple calls protection for storage-modifying proxy initialization functions.
library ProxyInitialization {
    /// @notice Sets the initialization phase during a storage-modifying proxy initialization function.
    /// @dev Reverts with {InitializationPhaseAlreadyReached} if `phase` has been reached already.
    /// @param storageSlot the storage slot where `phase` is stored.
    /// @param phase the initialization phase.
    function setPhase(bytes32 storageSlot, uint256 phase) internal {
        StorageSlot.Uint256Slot storage currentVersion = StorageSlot.getUint256Slot(storageSlot);
        uint256 currentPhase = currentVersion.value;
        if (currentPhase >= phase) revert InitializationPhaseAlreadyReached(currentPhase, phase);
        currentVersion.value = phase;
    }
}

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

/// @notice Thrown when an account is not the contract owner but is required to.
/// @param account The account that was checked.
error NotContractOwner(address account);

/// @notice Thrown when an account is not the pending contract owner but is required to.
/// @param account The account that was checked.
error NotPendingContractOwner(address account);

/// @notice Thrown when an account is not the target contract owner but is required to.
/// @param targetContract The contract that was checked.
/// @param account The account that was checked.
error NotTargetContractOwner(address targetContract, address account);

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

/// @title ERC-173 Contract Ownership Standard (functions)
/// @dev See https://eips.ethereum.org/EIPS/eip-173
/// @dev Note: the ERC-165 identifier for this interface is 0x7f5828d0
interface IERC173 {
    /// @notice Sets the address of the new contract owner.
    /// @dev Reverts if the sender is not the contract owner.
    /// @dev Emits an {OwnershipTransferred} event if `newOwner` is different from the current contract owner.
    /// @param newOwner The address of the new contract owner. Using the zero address means renouncing ownership.
    function transferOwnership(address newOwner) external;

    /// @notice Gets the address of the contract owner.
    /// @return contractOwner The address of the contract owner.
    function owner() external view returns (address contractOwner);
}

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

/// @notice Emitted when the contract ownership changes.
/// @param previousOwner the previous contract owner.
/// @param newOwner the new contract owner.
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

/// @notice Emitted when a new contract owner is pending.
/// @param pendingOwner the address of the new contract owner.
event OwnershipTransferPending(address indexed pendingOwner);

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

/// @notice Thrown when trying to transfer tokens without calldata to the contract.
error EtherReceptionDisabled();

/// @notice Thrown when the multiple related arrays have different lengths.
error InconsistentArrayLengths();

/// @notice Thrown when an ETH transfer has failed.
error TransferFailed();

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

/// @notice Thrown when setting the illegal interfaceId 0xffffffff.
error IllegalInterfaceId();

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.2.0) (utils/Address.sol)

pragma solidity ^0.8.20;

import {Errors} from "./Errors.sol";

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev There's no code at `target` (it is not a contract).
     */
    error AddressEmptyCode(address target);

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        if (address(this).balance < amount) {
            revert Errors.InsufficientBalance(address(this).balance, amount);
        }

        (bool success, bytes memory returndata) = recipient.call{value: amount}("");
        if (!success) {
            _revert(returndata);
        }
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason or custom error, it is bubbled
     * up by this function (like regular Solidity function calls). However, if
     * the call reverted with no returned reason, this function reverts with a
     * {Errors.FailedCall} error.
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        if (address(this).balance < value) {
            revert Errors.InsufficientBalance(address(this).balance, value);
        }
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
     * was not a contract or bubbling up the revert reason (falling back to {Errors.FailedCall}) in case
     * of an unsuccessful call.
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata
    ) internal view returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            // only check if target is a contract if the call was successful and the return data is empty
            // otherwise we already know that it was a contract
            if (returndata.length == 0 && target.code.length == 0) {
                revert AddressEmptyCode(target);
            }
            return returndata;
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
     * revert reason or with a default {Errors.FailedCall} error.
     */
    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            return returndata;
        }
    }

    /**
     * @dev Reverts with returndata if present. Otherwise reverts with {Errors.FailedCall}.
     */
    function _revert(bytes memory returndata) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            assembly ("memory-safe") {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert Errors.FailedCall();
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/IERC165.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC-165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[ERC].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/StorageSlot.sol)
// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.

pragma solidity ^0.8.20;

/**
 * @dev Library for reading and writing primitive types to specific storage slots.
 *
 * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
 * This library helps with reading and writing to such slots without the need for inline assembly.
 *
 * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
 *
 * Example usage to set ERC-1967 implementation slot:
 * ```solidity
 * contract ERC1967 {
 *     // Define the slot. Alternatively, use the SlotDerivation library to derive the slot.
 *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
 *
 *     function _getImplementation() internal view returns (address) {
 *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
 *     }
 *
 *     function _setImplementation(address newImplementation) internal {
 *         require(newImplementation.code.length > 0);
 *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
 *     }
 * }
 * ```
 *
 * TIP: Consider using this library along with {SlotDerivation}.
 */
library StorageSlot {
    struct AddressSlot {
        address value;
    }

    struct BooleanSlot {
        bool value;
    }

    struct Bytes32Slot {
        bytes32 value;
    }

    struct Uint256Slot {
        uint256 value;
    }

    struct Int256Slot {
        int256 value;
    }

    struct StringSlot {
        string value;
    }

    struct BytesSlot {
        bytes value;
    }

    /**
     * @dev Returns an `AddressSlot` with member `value` located at `slot`.
     */
    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
        assembly ("memory-safe") {
            r.slot := slot
        }
    }

    /**
     * @dev Returns a `BooleanSlot` with member `value` located at `slot`.
     */
    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
        assembly ("memory-safe") {
            r.slot := slot
        }
    }

    /**
     * @dev Returns a `Bytes32Slot` with member `value` located at `slot`.
     */
    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
        assembly ("memory-safe") {
            r.slot := slot
        }
    }

    /**
     * @dev Returns a `Uint256Slot` with member `value` located at `slot`.
     */
    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
        assembly ("memory-safe") {
            r.slot := slot
        }
    }

    /**
     * @dev Returns a `Int256Slot` with member `value` located at `slot`.
     */
    function getInt256Slot(bytes32 slot) internal pure returns (Int256Slot storage r) {
        assembly ("memory-safe") {
            r.slot := slot
        }
    }

    /**
     * @dev Returns a `StringSlot` with member `value` located at `slot`.
     */
    function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
        assembly ("memory-safe") {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `StringSlot` representation of the string storage pointer `store`.
     */
    function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
        assembly ("memory-safe") {
            r.slot := store.slot
        }
    }

    /**
     * @dev Returns a `BytesSlot` with member `value` located at `slot`.
     */
    function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
        assembly ("memory-safe") {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.
     */
    function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
        assembly ("memory-safe") {
            r.slot := store.slot
        }
    }
}

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

/// @notice Emitted when trying to set a phase value that has already been reached.
/// @param currentPhase The current phase.
/// @param newPhase The new phase trying to be set.
error InitializationPhaseAlreadyReached(uint256 currentPhase, uint256 newPhase);

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/Errors.sol)

pragma solidity ^0.8.20;

/**
 * @dev Collection of common custom errors used in multiple contracts
 *
 * IMPORTANT: Backwards compatibility is not guaranteed in future versions of the library.
 * It is recommended to avoid relying on the error API for critical functionality.
 *
 * _Available since v5.1._
 */
library Errors {
    /**
     * @dev The ETH balance of the account is not enough to perform the operation.
     */
    error InsufficientBalance(uint256 balance, uint256 needed);

    /**
     * @dev A call to an address target failed. The target may have reverted.
     */
    error FailedCall();

    /**
     * @dev The deployment failed.
     */
    error FailedDeployment();

    /**
     * @dev A necessary precompile is missing.
     */
    error MissingPrecompile(address);
}

{
  "optimizer": {
    "enabled": true,
    "mode": "3"
  },
  "evmVersion": "paris",
  "outputSelection": {
    "*": {
      "*": [
        "abi"
      ]
    }
  },
  "detectMissingLibraries": false,
  "forceEVMLA": false,
  "enableEraVMExtensions": false,
  "codegen": "yul",
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"claimContract","type":"address"},{"internalType":"contract IERC20","name":"stakingToken","type":"address"},{"internalType":"contract IPointsV2","name":"pointsContract","type":"address"},{"internalType":"bytes32","name":"depositReasonCode","type":"bytes32"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"FailedCall","type":"error"},{"inputs":[],"name":"IllegalInterfaceId","type":"error"},{"inputs":[],"name":"InconsistentArrayLengths","type":"error"},{"inputs":[{"internalType":"address","name":"tokenContract","type":"address"}],"name":"IncorrectTokenContractType","type":"error"},{"inputs":[{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"InsufficientBalance","type":"error"},{"inputs":[],"name":"InvalidDuration","type":"error"},{"inputs":[],"name":"InvalidPointsContract","type":"error"},{"inputs":[{"internalType":"uint256","name":"requested","type":"uint256"},{"internalType":"uint256","name":"recoverable","type":"uint256"}],"name":"InvalidRecoveryAmount","type":"error"},{"inputs":[],"name":"InvalidRewardAmount","type":"error"},{"inputs":[],"name":"InvalidStakeAmount","type":"error"},{"inputs":[],"name":"InvalidToken","type":"error"},{"inputs":[],"name":"InvalidWithdrawAmount","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"NotContractOwner","type":"error"},{"inputs":[{"internalType":"address","name":"staker","type":"address"},{"internalType":"uint256","name":"stake","type":"uint256"},{"internalType":"uint256","name":"withdraw","type":"uint256"}],"name":"NotEnoughStake","type":"error"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"NotRoleHolder","type":"error"},{"inputs":[],"name":"ReentrancyGuardReentrantCall","type":"error"},{"inputs":[{"internalType":"uint256","name":"currentRewardRate","type":"uint256"},{"internalType":"uint256","name":"newRewardRate","type":"uint256"}],"name":"RewardDilution","type":"error"},{"inputs":[{"internalType":"uint256","name":"reward","type":"uint256"},{"internalType":"uint256","name":"duration","type":"uint256"}],"name":"RewardTooSmallForDuration","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"staker","type":"address"},{"indexed":false,"internalType":"bytes","name":"claimData","type":"bytes"},{"indexed":false,"internalType":"uint256","name":"reward","type":"uint256"}],"name":"Claimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"rewarder","type":"address"},{"indexed":false,"internalType":"uint256","name":"reward","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"duration","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"dust","type":"uint256"}],"name":"RewardAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"address","name":"operator","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"address","name":"operator","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"staker","type":"address"},{"indexed":false,"internalType":"bytes","name":"stakeData","type":"bytes"},{"indexed":false,"internalType":"uint256","name":"stakePoints","type":"uint256"}],"name":"Staked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"staker","type":"address"},{"indexed":false,"internalType":"bytes","name":"withdrawData","type":"bytes"},{"indexed":false,"internalType":"uint256","name":"stakePoints","type":"uint256"}],"name":"Withdrawn","type":"event"},{"inputs":[],"name":"CLAIM_CONTRACT","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DEPOSIT_REASON_CODE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"POINTS_CONTRACT","outputs":[{"internalType":"contract IPointsV2","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"REWARDER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SCALING_FACTOR","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"STAKING_TOKEN","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"reward","type":"uint256"},{"internalType":"uint256","name":"duration","type":"uint256"}],"name":"addReward","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"distributionEnd","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"earned","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"hasRole_","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastTimeRewardApplicable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastUpdated","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"onERC20Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"accounts","type":"address[]"},{"internalType":"contract IERC20[]","name":"tokens","type":"address[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"name":"recoverERC20s","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"accounts","type":"address[]"},{"internalType":"contract IERC721[]","name":"contracts","type":"address[]"},{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"recoverERC721s","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable[]","name":"accounts","type":"address[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"name":"recoverETH","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rewardPerStakePoint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"staker","type":"address"}],"name":"rewardPerStakePointPaid","outputs":[{"internalType":"uint256","name":"paid","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardPerStakePointStored","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"staker","type":"address"}],"name":"rewards","outputs":[{"internalType":"uint256","name":"reward","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"stakeData","type":"bytes"}],"name":"stake","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"staker","type":"address"}],"name":"staked","outputs":[{"internalType":"uint256","name":"stakePoints","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalStaked","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"withdrawData","type":"bytes"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

9c4d535b0000000000000000000000000000000000000000000000000000000000000000010004636371f28cf4dcd73462f280e36df3d90e0bfa0ddf02fb728b87dc33ca00000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000080000000000000000000000000e747fdaadde2e739dd423bbf63dc3ef047078a540000000000000000000000002226444afcccf9e760c01649ef1f9e66985a4b350000000000000000000000002f65ffb50f16e3ee19a8d22606d9114d1ed66f2c5374616b696e6752657761726400000000000000000000000000000000000000

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

000000000000000000000000e747fdaadde2e739dd423bbf63dc3ef047078a540000000000000000000000002226444afcccf9e760c01649ef1f9e66985a4b350000000000000000000000002f65ffb50f16e3ee19a8d22606d9114d1ed66f2c5374616b696e6752657761726400000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : claimContract (address): 0xE747fDaaDDE2E739DD423bBf63DC3ef047078A54
Arg [1] : stakingToken (address): 0x2226444afcCCF9e760C01649eF1f9E66985A4b35
Arg [2] : pointsContract (address): 0x2f65ffB50f16e3Ee19A8D22606D9114D1ED66f2C
Arg [3] : depositReasonCode (bytes32): 0x5374616b696e6752657761726400000000000000000000000000000000000000

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 000000000000000000000000e747fdaadde2e739dd423bbf63dc3ef047078a54
Arg [1] : 0000000000000000000000002226444afcccf9e760c01649ef1f9e66985a4b35
Arg [2] : 0000000000000000000000002f65ffb50f16e3ee19a8d22606d9114d1ed66f2c
Arg [3] : 5374616b696e6752657761726400000000000000000000000000000000000000