Cryo Explorer Ethereum Mainnet

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

import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {Pausable} from "@openzeppelin/contracts/utils/Pausable.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";

contract StakingManager is ReentrancyGuard, Ownable, Pausable {
    using SafeERC20 for IERC20; // Wrappers around ERC20 operations that throw on failure

    // Digest
    string private constant DIGEST = "2025-01-30"; // Compile version

    // Main
    bool public isMainNetwork; // Set true if its the main network where the coin will be deployed
    IERC20 public saleToken; // Token to be staked and rewarded
    uint256 public saleTokenTotalMinted; // Total sale tokens minted;
    address public presaleContract; // Presale contract address
    address public admin; // Admin address

    // Sum
    uint256 public tokensStakedByPresale; // Total tokens staked by presale
    uint256 public tokensStakedByNetwork; // Total tokens staked by this network
    uint256 public tokensStakedTotal; // Total tokens staked in all networks
    uint256 public tokensStakedTotalLastUpdateTime; // Time the tokens staked total was updated

    // Pool
    uint256 public poolLastDayReward; // Pool last day the pool had their rewards calculated
    uint256 public poolAccumulatedRewardsPerShare; // Pool accumulated rewards per share times REWARDS PRECISION, it saves the total rewards generated in the pool until the last processment, per share means the value is relative to all coins stake

    // Claim
    uint256 public claimStartTime; // Users are allowed to claim after this time in epoch
    uint256 public claimLockDays; // To lock the tokens in contract for a definite time IN SECONDS, this is the min time needed to keep in stake before can claim again.

    // Stake
    uint256 public stakeStartTime; // At this time the stake will be started - 1 July 2024 15:00:00 - 1719846000
    uint256 public stakeEndTime; // At this time the stake will be stopped - 1 July 2025 15:00:00 - 1751382000.   --- DIFF 31536000
    uint256 public stakeRewardsTokensPerDay; // Number of reward tokens minted per day

    // Constants
    uint256 private constant REWARDS_PRECISION = 1e12; // A big number to perform mul and div operations
    uint256 private constant DAY_SECONDS = 86400; // Number of seconds of a day

    // Staking user for a pool
    struct PoolStaker {
        uint256 stakerAmount; // The amount of tokens the user has staked
        uint256 stakerStakedTime; // The time the tokens was staked
        uint256 stakerRewardsHarvested; // Total amount of tokens rewards the user harvested
        uint256 stakerRewardsDebt; // Total amount the user cant get as reward (relative to poolAccumulatedRewardsPerShare)
        uint256 stakerRewardsLocked; // Total amount of locked rewards
        bool stakerIsBlacklisted; // Mark if user is blacklisted
    }

    // Staker address => PoolStaker
    mapping(address => PoolStaker) public poolStakers; // Save data of all stakers
    mapping(address => bool) public imported;
    address[] private addressStakersPresale; // Save address of stakers that join in the presale
    bool public isImportDone;

    // Events
    event Deposit(address indexed user, uint256 amount);
    event Withdraw(address indexed user, uint256 amount);
    event HarvestRewards(address indexed user, uint256 amount);
    event TokensStakedTotalUpdated(uint256 amount);
    event TokensStakedTotalUpdated(uint256 amount, uint256 updateTime);
    event TokensStakedTotalLastUpdateTimeUpdated(uint256 updateTime);
    event AdminUpdated(address indexed pAdmin);
    event PresaleContractUpdated(address indexed pPresaleContract);
    event ClaimStartTimeUpdated(uint256 pClaimStartTime);
    event StakeEndTimeUpdated(uint256 pStakeEndTime);
    event StakeRewardsTokensPerDayUpdated(uint256 pStakeRewardsTokensPerDay);
    event PoolLastDayRewardUpdated(uint256 pPoolLastDayReward);
    event PoolAccumulatedRewardsPerShareUpdated(uint256 poolAccumulatedRewardsPerShare);

    // Modifiers
    modifier onlyPresale() {
        require(msg.sender == presaleContract, "This method is only for presale contract");
        _;
    }

    modifier onlyOwnerOrAdmin() {
        require(msg.sender == admin || msg.sender == owner(), "Only owner or admin");
        _;
    }

    /**
     * @dev Initializes the contract and sets initial parameters
     *
     * @param _isMainNetwork True if this is the network where the presale token will be deployed
     * @param _saleToken Address of the token
     * @param _presaleContract Address of the presale
     * @param _admin Address of admin
     * @param _stakeStartTime Time the stake will be started
     * @param _stakeEndTime Time the stake will be stopped
     * @param _stakeRewardsTokensPerDay Number of reward tokens minted per day
     * @param _claimStartTime Time where the claim will be available
     * @param _claimLockDays To lock the tokens in contract for a definite time IN DAYS, this is the min time needed to keep in stake before can claim again
     * @param _saleTokenTotalMinted Total of sale tokens minted
     */
    constructor(
        bool _isMainNetwork,
        address _saleToken,
        address _presaleContract,
        address _admin,
        uint256 _stakeStartTime,
        uint256 _stakeEndTime,
        uint256 _stakeRewardsTokensPerDay,
        uint256 _claimStartTime,
        uint256 _claimLockDays,
        uint256 _saleTokenTotalMinted
    ) Ownable(msg.sender) {
        require(_presaleContract != address(0), "Presale contract is required");
        require(_admin != address(0), "Admin address is required");
        require(_stakeStartTime < _stakeEndTime, "Presale end time must be greater than start time");
        require(_stakeEndTime > block.timestamp, "Presale end time must be in the future");
        require(_stakeRewardsTokensPerDay > 0, "Stake rewards per day should be bigger than ZERO");

        isMainNetwork = _isMainNetwork;
        if (_isMainNetwork) saleToken = IERC20(_saleToken);
        presaleContract = _presaleContract;
        admin = _admin;
        stakeStartTime = _stakeStartTime;
        stakeEndTime = _stakeEndTime;
        stakeRewardsTokensPerDay = _stakeRewardsTokensPerDay;
        claimStartTime = _claimStartTime;
        claimLockDays = _claimLockDays;
        poolLastDayReward = stakeStartTime; // Initialize
        tokensStakedTotalLastUpdateTime = stakeStartTime; // Initialize
        saleTokenTotalMinted = _saleTokenTotalMinted;
    }

    /**
     * @dev Deposit tokens to the pool from outside the presale
     *
     * This function allows users to deposit tokens they already have to the staking pool,
     * when the presale already finished.
     * It moves the deposited tokens to the staking pool.
     *
     * @param pAmount The amount of tokens to deposit
     *
     * Requirements:
     * - Contract must be on the main network
     * - Staking must have started
     * - Staking must not have ended
     * - Deposit amount cannot be zero
     * - User must not be blacklisted
     *
     * Effects:
     * - Updates the pool stakers' information
     * - Updates the current staker's information
     * - Updates the total tokens staked by the network
     * - Transfers the deposited tokens from the user to the contract
     *
     * Emits a Deposit event with the user's address and the amount deposited
     */
    function deposit(address pUserAddress, uint256 pAmount) external nonReentrant whenNotPaused {
        require(isMainNetwork, "This is not the main network");
        require(msg.sender == presaleContract || msg.sender == pUserAddress, "Only user or presale allowed");
        require(block.timestamp >= stakeStartTime, "Staking hasn't started");
        require(block.timestamp < stakeEndTime, "Staking has been ended");
        require(block.timestamp >= claimStartTime, "Claim is not available");
        require(pAmount > 0, "Deposit amount can't be zero");

        PoolStaker storage staker = poolStakers[pUserAddress];

        updatePoolRewards();

        // Update pool stakers
        harvestRewards(pUserAddress, false);

        // Update current staker
        staker.stakerAmount += pAmount;
        staker.stakerRewardsDebt = (staker.stakerAmount * poolAccumulatedRewardsPerShare) / REWARDS_PRECISION;
        staker.stakerStakedTime = block.timestamp;

        // Update pool
        tokensStakedByNetwork += pAmount;
        tokensStakedTotal += pAmount;

        // Deposit tokens
        emit Deposit(pUserAddress, pAmount);

        // Receive a deposit of coins to this address
        saleToken.safeTransferFrom(msg.sender, address(this), pAmount);
    }

    /**
     * @dev Deposit tokens to the pool by the presale contract
     *
     * Do not move the coins in the presale stage.
     * At the end of the presale, the total amount sold in all networks with the total supply of staking coins is moved here so it can be withdraw.
     * Do not move the coins in the presale stage
     *
     * @param pUserAddress The address of the user who is depositing tokens
     * @param pAmount The amount of tokens to deposit
     *
     * Requirements:
     * - Staking must have started
     * - Staking must not have ended
     * - Deposit amount cannot be zero
     * - User must not be blacklisted
     *
     * Effects:
     * - Updates the pool stakers' information
     * - Updates the current staker's information
     * - Updates the total tokens staked by the network
     *
     * Emits a Deposit event with the user's address and the amount deposited
     */
    function depositByPresale(address pUserAddress, uint256 pAmount) external nonReentrant whenNotPaused onlyPresale {
        require(block.timestamp >= stakeStartTime, "Staking hasn't started");
        require(block.timestamp < stakeEndTime, "Staking has been ended");
        require(block.timestamp < claimStartTime, "Claim is available");
        require(pAmount > 0, "Deposit amount can't be zero");

        PoolStaker storage staker = poolStakers[pUserAddress];

        //Add user if its his first interaction
        if (staker.stakerAmount == 0) addressStakersPresale.push(pUserAddress);

        // Update pool stakers
        harvestRewards(pUserAddress, false);

        // Update current staker
        staker.stakerAmount += pAmount;
        staker.stakerRewardsDebt = (staker.stakerAmount * poolAccumulatedRewardsPerShare) / REWARDS_PRECISION;
        staker.stakerStakedTime = block.timestamp;

        // Update pool
        tokensStakedByNetwork += pAmount;
        tokensStakedByPresale += pAmount;

        // Deposit tokens
        emit Deposit(pUserAddress, pAmount);
    }

    /**
     * @dev Withdraw all staked tokens from the pool
     *
     * Requirements:
     * - Contract must be on the main network
     * - Staking must have started
     * - Staking must not have ended
     * - Claim must have started
     * - User withdraw amount cannot be zero
     * - User claim lock time should have expired
     * - User must not be blacklisted
     *
     * Effects:
     * - Pool staker's information is deleted
     * - Total tokens staked by the network is updated
     * - Withdraw tokens are transferred back to the user
     *
     * Emits a Withdraw event with the user's address and the amount of the withdraw
     */
    function withdraw() external nonReentrant whenNotPaused {
        require(isMainNetwork, "This is not the main network");
        require(block.timestamp >= stakeStartTime, "Staking hasn't started");
        require(block.timestamp >= claimStartTime, "Claim is not available");

        PoolStaker memory staker = poolStakers[msg.sender];
        require(
            staker.stakerStakedTime + (claimLockDays * DAY_SECONDS) <= block.timestamp && claimStartTime + (claimLockDays * DAY_SECONDS) <= block.timestamp,
            "You are not allowed to withdraw before locked time"
        );
        require(staker.stakerAmount > 0, "Amount staked can't be zero");
        require(saleToken.balanceOf(address(this)) >= staker.stakerAmount, "Balance not enough");

        updatePoolRewards();

        // Pay rewards
        uint256 _rewardsToHarvest = harvestRewards(msg.sender, true);

        // Delete staker
        delete poolStakers[msg.sender];

        // Update pool
        tokensStakedByNetwork -= staker.stakerAmount;
        tokensStakedTotal -= staker.stakerAmount;

        // If there are rewards to harvest send it to the user
        if (_rewardsToHarvest > 0) {
            emit HarvestRewards(msg.sender, _rewardsToHarvest);
            saleToken.safeTransfer(msg.sender, _rewardsToHarvest);
        }

        // Withdraw tokens
        emit Withdraw(msg.sender, staker.stakerAmount);
        saleToken.safeTransfer(msg.sender, staker.stakerAmount);
    }

    /**
     * @dev Harvests the rewards for the user
     *
     * This function allows the user to harvest their accumulated rewards from staking in the pool.
     * It calculates the rewards that the user has earned since the last update,
     * records the amount as harvested rewards, updates the user's rewards debt, and optionally transfers the rewards to the user.
     *
     * Requirements:
     * - Contract must be on the main network
     * - Staking must have started
     * - Staking must not have ended
     * - Claim must have started
     * - User staked amount cannot be zero
     * - User claim lock time should have expired
     * - User must not be blacklisted
     *
     * Effects:
     * - Calculates and transfers the user's rewards
     * - Updates the user's harvested rewards, rewards debt, and locked rewards
     *
     * Emits a HarvestRewards event with the user's address and the amount of rewards harvested
     */
    function harvestRewards() external nonReentrant whenNotPaused {
        require(isMainNetwork, "This is not the main network");
        require(block.timestamp >= stakeStartTime, "Staking hasn't started");
        require(block.timestamp >= claimStartTime, "Claim is not available");

        PoolStaker memory staker = poolStakers[msg.sender];
        require(
            staker.stakerStakedTime + (claimLockDays * DAY_SECONDS) <= block.timestamp && claimStartTime + (claimLockDays * DAY_SECONDS) <= block.timestamp,
            "You are not allowed to harvest before locked time"
        );
        require(staker.stakerAmount > 0, "Amount staked can't be zero");

        updatePoolRewards();

        uint256 _rewardsToHarvest = harvestRewards(msg.sender, true);

        // If there are rewards to harvest send it to the user
        if (_rewardsToHarvest > 0) {
            emit HarvestRewards(msg.sender, _rewardsToHarvest);
            saleToken.safeTransfer(msg.sender, _rewardsToHarvest);
        }
    }

    function harvestRewards(address pUserAddress, bool pHarvestNow) private returns (uint256) {
        PoolStaker storage staker = poolStakers[pUserAddress];
        require(!staker.stakerIsBlacklisted, "This address is blacklisted");

        uint256 _rewardsDebtUpdate = (staker.stakerAmount * poolAccumulatedRewardsPerShare) / REWARDS_PRECISION;
        uint256 _rewardsToHarvest = _rewardsDebtUpdate - staker.stakerRewardsDebt;

        if (_rewardsToHarvest > 0) {
            staker.stakerRewardsHarvested += _rewardsToHarvest;
            staker.stakerRewardsDebt = _rewardsDebtUpdate;

            // If claim is available and harvest now flag is true
            if (block.timestamp >= claimStartTime && pHarvestNow) {
                if (staker.stakerRewardsLocked > 0) {
                    _rewardsToHarvest += staker.stakerRewardsLocked;
                    staker.stakerRewardsLocked = 0;
                }

                // Return the value of the rewards to harvest that will be sent to the user
                return _rewardsToHarvest;

                // Sum the rewards
            } else {
                staker.stakerRewardsLocked += _rewardsToHarvest;
            }
        }

        return 0;
    }

    /**
     * @dev Checks if the tokensStakedTotalLastUpdateTime has expired
     *
     * This function checks if the difference between the current block timestamp and the tokensStakedTotalLastUpdateTime
     * is greater than or equal to one day, indicating that the tokensStakedTotalLastUpdateTime has expired.
     *
     * @return A boolean value indicating whether the tokensStakedTotalLastUpdateTime has expired (true) or not (false)
     */
    function isTokensStakedTotalLastUpdateTimeExpired() private view returns (bool) {
        if (block.timestamp >= claimStartTime) return false; // If the claim is active
        if (tokensStakedTotalLastUpdateTime > block.timestamp) return false;
        return (block.timestamp - tokensStakedTotalLastUpdateTime) >= DAY_SECONDS;
    }

    /**
     * @dev Calculates the number of days that have passed since the last reward was processed in the pool.
     *
     * This function determines the number of days that have elapsed between the current timestamp and the
     * timestamp when the last reward was processed in the pool. If the tokensStakedTotalLastUpdateTime has expired,
     * the number of days passed is calculated up to the current block timestamp. Otherwise, it returns 0.
     *
     * @param pTimestamp The timestamp for which the number of days passed since the last reward is being calculated
     *
     * @return The number of days that have passed since the last reward was processed in the pool
     */
    function calcDaysPassedSinceLastReward(uint256 pTimestamp) private view returns (uint256) {
        if (isTokensStakedTotalLastUpdateTimeExpired()) return 0;
        if (poolLastDayReward > pTimestamp) return 0;
        return (pTimestamp - poolLastDayReward) / DAY_SECONDS;
    }

    /**
     * @dev Updates the pool rewards based on the current timestamp and the tokens staked in the pool
     *
     * If the tokensStakedTotal is zero, the function increments the poolLastDayReward by the number of days passed
     * since the last reward was processed.
     *
     * If tokensStakedTotalLastUpdateTime is not expired updates the poolAccumulatedRewardsPerShare by incrementing
     * the total of rewards that was generated until this moment in the pool based on the total of coins staked and
     * updates the poolLastDayReward checking if the stakeEndTime or adding the number of days that passed.
     *
     * Effects:
     * - Updates the pool accumulated rewards per share
     * - Updates the last day the pool had their rewards calculated
     *
     */
    function updatePoolRewards() private {
        if (tokensStakedTotal == 0) {
            poolLastDayReward += (calcDaysPassedSinceLastReward(block.timestamp) * DAY_SECONDS); // Increment with the days passed that didnt generate any reward
            return;
        }

        if (!isTokensStakedTotalLastUpdateTimeExpired()) {
            poolAccumulatedRewardsPerShare += getPoolAccumulatedRewardsPerShare(); // This increments the total of rewards that was generated until this moment in the pool based on the total of coins staked
            poolLastDayReward = block.timestamp > stakeEndTime ? stakeEndTime : poolLastDayReward + (calcDaysPassedSinceLastReward(block.timestamp) * DAY_SECONDS); // Update last day a reward was generated
        }
    }

    /**
     * @dev Calculates the rewards accumulated in the pool since the last update
     * by multiplying the number of blocks since the last update with the rewards tokens per block
     *
     * The REWARDS_PRECISION is needed to generate more precision on smaller numbers
     *
     * @return The accumulated rewards in the pool since the last update
     */
    function getPoolAccumulatedRewardsPerShare() private view returns (uint256) {
        uint256 _poolDaysSinceLastUpdate = block.timestamp > stakeEndTime ? calcDaysPassedSinceLastReward(stakeEndTime) : calcDaysPassedSinceLastReward(block.timestamp);
        uint256 _poolRewardsSinceLastUpdate = _poolDaysSinceLastUpdate * stakeRewardsTokensPerDay;
        return (_poolRewardsSinceLastUpdate * REWARDS_PRECISION) / tokensStakedTotal;
    }

    /**
     * @dev Calculates the rewards available for the user based on the amount staked,
     * accumulated rewards in the pool, and rewards debt.
     *
     * This function calculates the rewards available for the user by multiplying the
     * amount staked by the accumulated rewards per share, adjusting for the rewards debt
     * that the user already claimed. It also considers any rewards that are currently locked
     * and not available for withdraw.
     *
     * @param pUserAddress The address of the user for whom rewards are being calculated
     *
     * @return The total amount of rewards available for the user
     */
    function getRewards(address pUserAddress) external view returns (uint256) {
        if (tokensStakedTotal == 0) {
            return 0;
        }

        uint256 _accCalc = poolAccumulatedRewardsPerShare + getPoolAccumulatedRewardsPerShare();
        PoolStaker memory staker = poolStakers[pUserAddress];
        return ((staker.stakerAmount * _accCalc) / REWARDS_PRECISION) - staker.stakerRewardsDebt + staker.stakerRewardsLocked;
    }

    /**
     * @dev Get current total tokens staked details
     // Array of details 
     [0] -> TOTAL_TOKENS_STAKED_BY_PRESALE, 
     [1] -> TOTAL_TOKENS_STAKED_BY_NETWORK, 
     [2] -> TOTAL_TOKENS_STAKED_TOTAL, 
     [3] -> TOTAL_TOKENS_STAKED_TOTAL_LAST_UPDATE_TIME), 
     [4] -> CLAIM_START_TIME, 
     [5] -> STAKERS_LENGTH,
     [6] -> IS_IMPORT_DONE
     */
    function getTokensStakedDetails() external view returns (uint256[7] memory) {
        return [tokensStakedByPresale, tokensStakedByNetwork, tokensStakedTotal, tokensStakedTotalLastUpdateTime, claimStartTime, addressStakersPresale.length, isImportDone ? 1 : 0];
    }

    /**
     * @dev Set is main network on/off
     */
    function setIsMainNetwork(bool pIsMainNetwork) external onlyOwner {
        isMainNetwork = pIsMainNetwork;
    }

    /**
     * @dev Set sale token address
     */
    function setSaleToken(address pSaleToken) external onlyOwner {
        require((isMainNetwork && pSaleToken != address(0)) || !isMainNetwork, "Invalid address");
        saleToken = IERC20(pSaleToken);
    }

    /**
     * @dev Set sale token total minted
     */
    function setSaleTokenTotalMinted(uint256 pSaleTokenTotalMinted) external onlyOwner {
        saleTokenTotalMinted = pSaleTokenTotalMinted;
    }

    /**
     * @dev Set presale contract address
     */
    function setPresaleContract(address pPresaleContract) external onlyOwner {
        require(pPresaleContract != address(0), "Invalid address");
        presaleContract = pPresaleContract;
        emit PresaleContractUpdated(pPresaleContract);
    }

    /**
     * @dev Set admin address
     */
    function setAdmin(address pAdmin) external onlyOwner {
        require(pAdmin != address(0), "Invalid address");
        admin = pAdmin;
        emit AdminUpdated(pAdmin);
    }

    /**
     * @dev Set claim start time
     */
    function setClaimStartTime(uint256 pClaimStartTime) external onlyOwner {
        claimStartTime = pClaimStartTime;
        emit ClaimStartTimeUpdated(pClaimStartTime);
    }

    /**
     * @dev Set claim lock days
     */
    function setClaimLockDays(uint256 pClaimLockDays) external onlyOwner {
        claimLockDays = pClaimLockDays;
    }

    /**
     * @dev Set stake start time
     */
    function setStakeStartTime(uint256 pStakeStartTime) external onlyOwner {
        stakeStartTime = pStakeStartTime;
    }

    /**
     * @dev Set stake end time
     */
    function setStakeEndTime(uint256 pStakeEndTime) external onlyOwner {
        stakeEndTime = pStakeEndTime;
        emit StakeEndTimeUpdated(pStakeEndTime);
    }

    /**
     * @dev Set stake rewards tokens per day
     */
    function setStakeRewardsTokensPerDay(uint256 pStakeRewardsTokensPerDay) external onlyOwner {
        stakeRewardsTokensPerDay = pStakeRewardsTokensPerDay;
        emit StakeRewardsTokensPerDayUpdated(pStakeRewardsTokensPerDay);
    }

    /**
     * @dev Set tokens staked total
     */
    function setTokensStakedTotal(uint256 pAmount, uint256 pUpdateTime) external onlyOwnerOrAdmin {
        require(pUpdateTime >= tokensStakedTotalLastUpdateTime && pUpdateTime > stakeStartTime && pUpdateTime < stakeEndTime && pUpdateTime < claimStartTime, "Update time is invalid");
        require(pAmount <= saleTokenTotalMinted && pAmount >= tokensStakedTotal, "Invalid amount");
        uint256 tokensStakedTotalDiff = pAmount - tokensStakedTotal;
        tokensStakedTotal = pAmount;
        tokensStakedTotalLastUpdateTime = pUpdateTime; // Need to use a fixed time for everyday control.
        updatePoolRewards(); // Sincronize all networks pool rewards
        emit TokensStakedTotalUpdated(pAmount, pUpdateTime);
        if (isMainNetwork && tokensStakedTotalDiff > 0) {
            require(saleToken.balanceOf(presaleContract) >= tokensStakedTotalDiff, "Balance not enough");
            saleToken.safeTransferFrom(presaleContract, address(this), tokensStakedTotalDiff);
        }
    }

    /**
     * @dev Set tokens staked total
     */
    function setTokensStakedTotal(uint256 pAmount) external onlyOwner {
        tokensStakedTotal = pAmount;
        emit TokensStakedTotalUpdated(pAmount);
    }

    /**
     * @dev Set tokens staked total last update time
     */
    function setTokensStakedTotalLastUpdateTime(uint256 pUpdateTime) external onlyOwner {
        tokensStakedTotalLastUpdateTime = pUpdateTime;
        emit TokensStakedTotalLastUpdateTimeUpdated(pUpdateTime);
    }

    /**
     * @dev Set pool last day reward
     */
    function setPoolLastDayReward(uint256 pPoolLastDayReward) external onlyOwner {
        poolLastDayReward = pPoolLastDayReward;
        emit PoolLastDayRewardUpdated(pPoolLastDayReward);
    }

    /**
     * @dev Set pool accumulated rewards per share
     */
    function setPoolAccumulatedRewardsPerShare(uint256 pPoolAccumulatedRewardsPerShare) external onlyOwner {
        poolAccumulatedRewardsPerShare = pPoolAccumulatedRewardsPerShare;
        emit PoolAccumulatedRewardsPerShareUpdated(pPoolAccumulatedRewardsPerShare);
    }

    /**
     * @dev Pause the presale
     */
    function pause() external onlyOwner {
        _pause();
    }

    /**
     * @dev Unpause the presale
     */
    function unpause() external onlyOwner {
        _unpause();
    }

    /**
     * @dev Adds the specified users to the blacklist
     *
     * This function allows the contract owner to add the specified users to the blacklist, preventing them from participating in staking and claiming rewards.
     * Any user added to the blacklist will not be able to deposit, withdraw, or harvest rewards.
     *
     * @param pUsersList An array of addresses representing the users to be added to the blacklist
     *
     * Requirements:
     * - The function can only be called by the contract owner
     *
     * Effects:
     * - Updates the isBlacklisted flag for the specified users to true
     *
     */
    function usersBlacklistAdd(address[] calldata pUsersList) external onlyOwner {
        uint256 size = pUsersList.length;
        for (uint256 i = 0; i < size; i++) {
            PoolStaker storage staker = poolStakers[pUsersList[i]];
            staker.stakerIsBlacklisted = true;
        }
    }

    /**
     * @dev Removes the specified users from the blacklist
     *
     * This function allows the contract owner to remove the specified users from the blacklist, enabling them to participate in staking and claiming rewards again.
     * Any user removed from the blacklist will regain the ability to deposit, withdraw, and harvest rewards.
     *
     * @param pUsersList An array of addresses representing the users to be removed from the blacklist
     *
     * Requirements:
     * - The function can only be called by the contract owner
     *
     * Effects:
     * - Updates the isBlacklisted flag for the specified users to false
     */
    function usersBlacklistRemove(address[] calldata pUsersList) external onlyOwner {
        uint256 size = pUsersList.length;
        for (uint256 i = 0; i < size; i++) {
            PoolStaker storage staker = poolStakers[pUsersList[i]];
            staker.stakerIsBlacklisted = false;
        }
    }

    /**
     * @dev This function allows the contract owner or admin to retrieve the address of a staker from the list of stakers that joined during the presale
     *
     * @param pIndex The index of the staker's address in the array
     *
     * Requirements:
     * - Only the contract owner or admin can call this function
     *
     * @return The address of the staker at the specified index
     *
     */
    function getAddressStakersPresale(uint256 pIndex) external view returns (address) {
        return addressStakersPresale[pIndex];
    }

    /**
     * @dev Set imported value for a given address
     *
     * @param pAddresses address
     * @param pValues flag to indicate if address was imported or not
     */
    function setImported(address[] calldata pAddresses, bool[] calldata pValues) external onlyOwner {
        require(pAddresses.length == pValues.length, "Parameters length mismatch");

        uint256 size = pAddresses.length;
        for (uint256 i = 0; i < size; i++) {
            imported[pAddresses[i]] = pValues[i];
        }
    }

    /**
     * @dev Set is import done
     */
    function setIsImportDone(bool pIsImportDone) external onlyOwner {
        isImportDone = pIsImportDone;
    }

    /**
     * @dev Imports the staking data for multiple stakers into the pool
     *
     * This function allows the contract owner to import staking data for multiple stakers into the pool.
     * The function takes two arrays as inputs - one containing the addresses of the stakers and the
     * other containing the staking data for each staker. It then updates the staking information for
     * each staker in the pool based on the provided data.
     *
     * @param pStakersAddress An array of addresses representing the stakers for whom staking data is being imported
     * @param pAmount An array of PoolStaker structs containing the staking data for each respective staker
     * @param pStakedTime An array of PoolStaker structs containing the staking data for each respective staker
     * @param pRewardsHarvested An array of PoolStaker structs containing the staking data for each respective staker
     * @param pRewardsDebt An array of PoolStaker structs containing the staking data for each respective staker
     * @param pRewardsLocked An array of PoolStaker structs containing the staking data for each respective staker
     *
     * Requirements:
     * - The length of all arrays must be equal
     * - The function can only be called by the contract owner
     *
     * Effects:
     * - Updates the staking information for each staker in the pool based on the provided data
     */
    function poolStakersImport(
        address[] calldata pStakersAddress,
        uint256[] calldata pAmount,
        uint256[] calldata pStakedTime,
        uint256[] calldata pRewardsHarvested,
        uint256[] calldata pRewardsDebt,
        uint256[] calldata pRewardsLocked
    ) external onlyOwner {
        require(isMainNetwork, "This is not the main network");
        require(
            pStakersAddress.length == pAmount.length &&
                pStakersAddress.length == pStakedTime.length &&
                pStakersAddress.length == pRewardsHarvested.length &&
                pStakersAddress.length == pRewardsDebt.length &&
                pStakersAddress.length == pRewardsLocked.length,
            "Length mismatch"
        );

        uint256 size = pStakersAddress.length;
        for (uint256 i = 0; i < size; i++) {
            require(!imported[pStakersAddress[i]], "Staker already imported");

            PoolStaker storage staker = poolStakers[pStakersAddress[i]];
            staker.stakerAmount += pAmount[i];
            if (pStakedTime[i] > staker.stakerStakedTime) staker.stakerStakedTime = pStakedTime[i];
            staker.stakerRewardsHarvested += pRewardsHarvested[i];
            staker.stakerRewardsDebt += pRewardsDebt[i];
            staker.stakerRewardsLocked += pRewardsLocked[i];
            imported[pStakersAddress[i]] = true;

            tokensStakedByNetwork += pAmount[i];
        }

        isImportDone = true;
    }
}

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

pragma solidity ^0.8.20;

import {Context} from "../utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * The initial owner is set to the address provided by the deployer. This can
 * later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// 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) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.20;

import {IERC20} from "../IERC20.sol";
import {IERC1363} from "../../../interfaces/IERC1363.sol";
import {Address} from "../../../utils/Address.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
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Pausable.sol)

pragma solidity ^0.8.20;

import {Context} from "../utils/Context.sol";

/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    bool private _paused;

    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    /**
     * @dev The operation failed because the contract is paused.
     */
    error EnforcedPause();

    /**
     * @dev The operation failed because the contract is not paused.
     */
    error ExpectedPause();

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() {
        _paused = false;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        _requireNotPaused();
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        _requirePaused();
        _;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Throws if the contract is paused.
     */
    function _requireNotPaused() internal view virtual {
        if (paused()) {
            revert EnforcedPause();
        }
    }

    /**
     * @dev Throws if the contract is not paused.
     */
    function _requirePaused() internal view virtual {
        if (!paused()) {
            revert ExpectedPause();
        }
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}

// 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
// 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.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
// OpenZeppelin Contracts (last updated v5.1.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, ) = recipient.call{value: amount}("");
        if (!success) {
            revert Errors.FailedCall();
        }
    }

    /**
     * @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.0.0) (interfaces/IERC20.sol)

pragma solidity ^0.8.20;

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

// 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
// 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);
}

// 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);
}