{"address":"0x9924ec52902068d86bc7e8ebb646467f79cbad9b","latest":5070280,"price":{"usd":0.609665656554181,"btc":0,"change24h":0,"marketCap":180908842.9097615,"volume24h":0,"source":"onchain","venue":"On-chain pool WDAN/USDT on dannyswap"},"balance":"0","nonce":1,"codeSize":19593,"isContract":true,"contract":{"verified":true,"name":"MemeStaking","compiler":"v0.8.28+commit.7893614a","optimization":true,"runs":200,"license":"none","proxy":false,"implementation":null,"sourceCode":"{\"sources\":{\"contracts/MemeStaking.sol\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.20;\\n\\nimport \\\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\n\\ncontract ReentrancyGuardUpgradeable is Initializable {\\n    uint256 private constant _NOT_ENTERED = 1;\\n    uint256 private constant _ENTERED = 2;\\n\\n    uint256 private _status;\\n\\n    function __ReentrancyGuard_init() internal initializer {\\n        __ReentrancyGuard_init_unchained();\\n    }\\n\\n    function __ReentrancyGuard_init_unchained() internal initializer {\\n        _status = _NOT_ENTERED;\\n    }\\n\\n    modifier nonReentrant() {\\n        // On the first call to nonReentrant, _notEntered will be true\\n        require(_status != _ENTERED, \\\"ReentrancyGuard: reentrant call\\\");\\n\\n        // Any calls to nonReentrant after this point will fail\\n        _status = _ENTERED;\\n\\n        _;\\n\\n        // By storing the original value once again, a refund is triggered (see\\n        // https://eips.ethereum.org/EIPS/eip-2200)\\n        _status = _NOT_ENTERED;\\n    }\\n    uint256[49] private __gap;\\n}\\n\\n/// @custom:oz-upgrades-from none\\ncontract MemeStaking is\\n    Initializable,\\n    ReentrancyGuardUpgradeable,\\n    OwnableUpgradeable,\\n    UUPSUpgradeable\\n{\\n    using SafeERC20 for IERC20;\\n\\n    uint256 public totalStakedPrincipal;\\n    uint256 public totalusers;\\n    uint256 public totalrewardclaimed;\\n\\n    IERC20 public token;\\n    uint256 public constant BPS_DENOMINATOR = 10_000; // 10000 = 100.00%\\n    uint256 public constant YEAR = 365 days;\\n\\n    struct StakingPlan {\\n        uint256 apy; // basis points, e.g. 200 = 2.00% APY\\n        uint256 duration; // lock-up duration in seconds\\n        uint256 referral; // basis points paid to the direct referrer on stake, e.g. 200 = 2.00%\\n        uint256 claimtime; // minimum seconds between reward claims (e.g. 7 days)\\n        bool active;\\n    }\\n\\n    struct User {\\n        address useraddress;\\n        uint256 totalstaked; // lifetime amount staked\\n        uint256 totalclaimed; // lifetime staking rewards claimed\\n        uint256 totalwithdrwal; // lifetime principal withdrawn\\n        address referrer; // locked in on first stake, immutable after\\n        uint256 totalReferralEarned; // lifetime referral bonus auto-paid to this user's wallet\\n        uint256 historyCount; // number of stake entries\\n        uint256 referralCount; // number of referral log entries\\n        uint256[4] totalrefcountbylevel;\\n        uint256[4] totalrefrewardbylevel;\\n        uint256 totalrefcount;\\n        uint256 level;\\n        uint256 claimCount;\\n    }\\n\\n    struct UserHistory {\\n        uint256 index;\\n        uint256 planId;\\n        uint256 amount;\\n        uint256 apy;\\n        uint256 starttime;\\n        uint256 endtime;\\n        uint256 totalreward; // full reward owed over the whole duration\\n        uint256 totalclaimed; // reward paid out so far\\n        uint256 claimed; // timestamp of last claim (also accrual start)\\n        bool withdrawn; // whether principal has been withdrawn\\n    }\\n\\n    struct UserClaimHistory {\\n        uint256 index;\\n        uint256 txId;\\n        uint256 amount;\\n        uint256 totalclaimed;\\n        uint256 time;\\n    }\\n\\n    struct UserReferrals {\\n        uint256 index;\\n        address referredUser;\\n        uint256 level; // always 1 in this implementation\\n        uint256 amount; // referred user's stake amount\\n        uint256 apy; // referral bps used\\n        uint256 starttime;\\n        uint256 endtime;\\n        uint256 reward; // bonus auto-paid from this event\\n    }\\n\\n    mapping(uint256 => StakingPlan) public plans;\\n    uint256 public planCount;\\n\\n    mapping(address => User) public users;\\n    mapping(address => mapping(uint256 => UserHistory)) public userhistory;\\n    mapping(address => mapping(uint256 => UserClaimHistory))\\n        public userclaimhistory;\\n    mapping(address => mapping(uint256 => UserReferrals)) public userreferral;\\n    mapping(address => uint256[]) public activeorderids;\\n\\n    bool public depositPaused;\\n    bool public claimPaused;\\n    bool public withdrawPaused;\\n\\n    event PlanAdded(\\n        uint256 indexed planId,\\n        uint256 apy,\\n        uint256 duration,\\n        uint256 referral,\\n        uint256 claimtime\\n    );\\n    event PlanEdited(uint256 indexed planId);\\n    event PlanStatusChanged(uint256 indexed planId, bool active);\\n    event Staked(\\n        address indexed user,\\n        uint256 indexed planId,\\n        uint256 indexed historyIndex,\\n        uint256 amount,\\n        address referrer\\n    );\\n    event RewardClaimed(\\n        address indexed user,\\n        uint256 indexed historyIndex,\\n        uint256 amount\\n    );\\n    event Withdrawn(\\n        address indexed user,\\n        uint256 indexed historyIndex,\\n        uint256 amount\\n    );\\n    event ReferralRewardPaid(\\n        address indexed referrer,\\n        address indexed referredUser,\\n        uint256 indexed historyIndex,\\n        uint256 amount\\n    );\\n    event TokensRescued(\\n        address indexed tokenAddr,\\n        address indexed to,\\n        uint256 amount\\n    );\\n    event BNBRescued(address indexed to, uint256 amount);\\n    event DepositPaused();\\n    event DepositUnpaused();\\n    event ClaimPaused();\\n    event ClaimUnpaused();\\n    event WithdrawPaused();\\n    event WithdrawUnpaused();\\n\\n    modifier whenDepositNotPaused() {\\n        require(!depositPaused, \\\"Deposits are currently paused\\\");\\n        _;\\n    }\\n\\n    modifier whenClaimNotPaused() {\\n        require(!claimPaused, \\\"Claiming is currently paused\\\");\\n        _;\\n    }\\n\\n    modifier whenWithdrawNotPaused() {\\n        require(!withdrawPaused, \\\"Withdrawals are currently paused\\\");\\n        _;\\n    }\\n\\n    /// @custom:oz-upgrades-unsafe-allow constructor\\n    constructor() {\\n        _disableInitializers();\\n    }\\n\\n    /// @notice Replaces the constructor. Runs once, at proxy deployment time, via delegatecall.\\n    /// @param tokenAddress The staking/reward ERC20 token. Passed in instead of hardcoded so the\\n    ///        same implementation can be reused/tested without redeploying for a different token.\\n    function initialize(address tokenAddress) public initializer {\\n        __ReentrancyGuard_init();\\n        __Ownable_init(msg.sender);\\n\\n        require(tokenAddress != address(0), \\\"Token address cannot be zero\\\");\\n        token = IERC20(tokenAddress);\\n\\n        addPlan(1000, 45 days, 300, 7 days);\\n        addPlan(2000, 90 days, 400, 7 days);\\n        addPlan(4000, 180 days, 500, 7 days);\\n        addPlan(6000, 365 days, 600, 7 days);\\n    }\\n\\n    /// @dev Restricts who can authorize an upgrade to the implementation contract.\\n    ///      Required by UUPSUpgradeable — without this override, upgrades are unprotected.\\n    function _authorizeUpgrade(\\n        address newImplementation\\n    ) internal override onlyOwner {}\\n\\n    receive() external payable {}\\n\\n    function addPlan(\\n        uint256 apy,\\n        uint256 duration,\\n        uint256 referral,\\n        uint256 claimtime\\n    ) public onlyOwner returns (uint256 planId) {\\n        require(\\n            referral <=  BPS_DENOMINATOR,\\n            \\\"Referral percentage exceeds 100%\\\"\\n        );\\n\\n        planId = planCount++;\\n        plans[planId] = StakingPlan({\\n            apy: apy,\\n            duration: duration,\\n            referral: referral,\\n            claimtime: claimtime,\\n            active: true\\n        });\\n\\n        emit PlanAdded(planId, apy, duration, referral, claimtime);\\n    }\\n\\n    /// @notice Edits an existing plan. Changes only apply to stakes made *after* the edit —\\n    ///         already-open stakes keep the terms (apy, duration, etc.) they started with.\\n    function editPlan(\\n        uint256 planId,\\n        uint256 apy,\\n        uint256 duration,\\n        uint256 referral,\\n        uint256 claimtime\\n    ) external onlyOwner {\\n        require(planId < planCount, \\\"Plan does not exist\\\");\\n        require(\\n            referral <= BPS_DENOMINATOR,\\n            \\\"Referral percentage exceeds 100%\\\"\\n        );\\n\\n        StakingPlan storage plan = plans[planId];\\n        plan.apy = apy;\\n        plan.duration = duration;\\n        plan.referral = referral;\\n        plan.claimtime = claimtime;\\n\\n        emit PlanEdited(planId);\\n    }\\n\\n    function setPlanStatus(uint256 planId, bool active) external onlyOwner {\\n        require(planId < planCount, \\\"Plan does not exist\\\");\\n        plans[planId].active = active;\\n        emit PlanStatusChanged(planId, active);\\n    }\\n\\n    function stake(\\n        uint256 planId,\\n        uint256 amount,\\n        address referrer\\n    ) external nonReentrant whenDepositNotPaused {\\n        require(planId < planCount, \\\"Plan does not exist\\\");\\n        StakingPlan memory plan = plans[planId];\\n        require(plan.active, \\\"Plan is not active\\\");\\n        require(amount > 0, \\\"Amount must be greater than zero\\\");\\n\\n        address staker = _msgSender();\\n        User storage user = users[staker];\\n        user.useraddress = staker;\\n\\n        if (referrer != address(0)) {\\n            require(referrer != staker, \\\"Cannot refer yourself\\\");\\n\\n            User storage refUser = users[referrer];\\n            if (refUser.totalstaked > 0) {\\n                refUser.totalrefcountbylevel[refUser.level] += 1;\\n                refUser.totalrefcount += 1;\\n                user.referrer = referrer; // valid referrer, locked in\\n            }\\n        }\\n\\n        token.safeTransferFrom(staker, address(this), amount);\\n\\n        if (user.totalstaked == 0) {\\n            totalusers++;\\n        }\\n\\n        uint256 historyIndex = user.historyCount++;\\n        uint256 startTime = block.timestamp;\\n        uint256 endTime = startTime + plan.duration;\\n        uint256 totalReward = (amount * plan.apy * plan.duration) /\\n            (YEAR * BPS_DENOMINATOR);\\n\\n        userhistory[staker][historyIndex] = UserHistory({\\n            index: historyIndex,\\n            planId: planId,\\n            amount: amount,\\n            apy: plan.apy,\\n            starttime: startTime,\\n            endtime: endTime,\\n            totalreward: totalReward,\\n            totalclaimed: 0,\\n            claimed: startTime,\\n            withdrawn: false\\n        });\\n\\n        user.totalstaked += amount;\\n        totalStakedPrincipal += amount;\\n        activeorderids[msg.sender].push(historyIndex);\\n        user.level = planId;\\n\\n        emit Staked(staker, planId, historyIndex, amount, user.referrer);\\n\\n        // Single-level (direct) referral bonus — paid instantly to the referrer's wallet, no manual claim.\\n        address ref = user.referrer;\\n\\n        if (ref != address(0) && plan.referral > 0) {\\n            User storage refUser = users[referrer];\\n            StakingPlan memory refplan = plans[refUser.level];\\n            uint256 refReward = (amount * refplan.referral) / BPS_DENOMINATOR;\\n\\n            if (refReward > 0) {\\n                require(\\n                    token.balanceOf(address(this)) >= refReward,\\n                    \\\"Insufficient pool balance for referral reward\\\"\\n                );\\n                refUser.totalReferralEarned += refReward;\\n                refUser.totalrefrewardbylevel[refUser.level] += refReward;\\n\\n                uint256 refIndex = refUser.referralCount++;\\n                userreferral[ref][refIndex] = UserReferrals({\\n                    index: refIndex,\\n                    referredUser: staker,\\n                    level: refUser.level,\\n                    amount: amount,\\n                    apy: plan.referral,\\n                    starttime: startTime,\\n                    endtime: endTime,\\n                    reward: refReward\\n                });\\n\\n                token.safeTransfer(ref, refReward);\\n                emit ReferralRewardPaid(ref, staker, historyIndex, refReward);\\n            }\\n        }\\n    }\\n\\n    function _claimReward(\\n        address staker,\\n        uint256 historyIndex,\\n        bool checkClaimTime\\n    ) internal returns (uint256 payableAmt) {\\n        UserHistory storage h = userhistory[staker][historyIndex];\\n\\n        require(h.starttime != 0, \\\"Stake not found\\\");\\n        require(!h.withdrawn, \\\"Stake already withdrawn\\\");\\n        require(h.totalclaimed < h.totalreward, \\\"Nothing left to claim\\\");\\n\\n        StakingPlan memory plan = plans[h.planId];\\n\\n        // Normal claim must respect claim interval.\\n        // Withdrawal can bypass this check and settle everything accrued.\\n        if (checkClaimTime) {\\n            uint256 nextClaimAt = h.claimed + plan.claimtime;\\n            require(\\n                block.timestamp >= nextClaimAt,\\n                \\\"Next claim is not yet available\\\"\\n            );\\n        }\\n\\n        // Never accrue rewards beyond the stake end time.\\n        uint256 accrualEnd = block.timestamp < h.endtime\\n            ? block.timestamp\\n            : h.endtime;\\n\\n        require(accrualEnd > h.claimed, \\\"Nothing to claim yet\\\");\\n        uint256 elapsed = accrualEnd - h.claimed;\\n        payableAmt = (h.amount * h.apy * elapsed) / (YEAR * BPS_DENOMINATOR);\\n\\n        // Never pay more than remaining reward.\\n        uint256 remaining = h.totalreward - h.totalclaimed;\\n\\n        if (payableAmt > remaining) {\\n            payableAmt = remaining;\\n        }\\n\\n        require(payableAmt > 0, \\\"Nothing to claim\\\");\\n\\n        h.totalclaimed += payableAmt;\\n        h.claimed = accrualEnd;\\n\\n        users[staker].totalclaimed += payableAmt;\\n        totalrewardclaimed += payableAmt;\\n        uint256 claimIndex = users[staker].claimCount++;\\n\\n        userclaimhistory[staker][claimIndex] = UserClaimHistory({\\n            index: claimIndex,\\n            txId: historyIndex,\\n            amount: h.amount,\\n            totalclaimed: payableAmt,\\n            time: block.timestamp\\n        });\\n\\n        require(\\n            token.balanceOf(address(this)) >= payableAmt,\\n            \\\"Insufficient contract balance\\\"\\n        );\\n        token.safeTransfer(staker, payableAmt);\\n\\n        emit RewardClaimed(staker, historyIndex, payableAmt);\\n    }\\n\\n    function claimReward(\\n        uint256 historyIndex\\n    ) external nonReentrant whenClaimNotPaused {\\n        address staker = _msgSender();\\n\\n        _claimReward(\\n            staker,\\n            historyIndex,\\n            true // enforce normal claim interval\\n        );\\n    }\\n\\n    function claimAllReward() external nonReentrant whenClaimNotPaused {\\n        address staker = _msgSender();\\n        uint256[] memory ids = activeorderids[staker];\\n        uint256 totalPayable = 0;\\n\\n        for (uint256 i = 0; i < ids.length; i++) {\\n            totalPayable += _tryClaimReward(staker, ids[i]);\\n        }\\n\\n        require(totalPayable > 0, \\\"Nothing to claim\\\");\\n        require(\\n            token.balanceOf(address(this)) >= totalPayable,\\n            \\\"Insufficient contract balance\\\"\\n        );\\n        token.safeTransfer(staker, totalPayable);\\n    }\\n\\n    function withdraw(\\n        uint256 historyIndex\\n    ) external nonReentrant whenWithdrawNotPaused {\\n        address staker = _msgSender();\\n\\n        UserHistory storage h = userhistory[staker][historyIndex];\\n\\n        require(h.starttime != 0, \\\"Stake not found\\\");\\n        require(!h.withdrawn, \\\"Already withdrawn\\\");\\n        require(block.timestamp >= h.endtime, \\\"Stake is still locked\\\");\\n\\n        if (h.totalclaimed < h.totalreward) {\\n            _claimReward(staker, historyIndex, false);\\n        }\\n\\n        h.withdrawn = true;\\n        _removeFromActiveById(staker, historyIndex);\\n        User storage user = users[staker];\\n        user.totalwithdrwal += h.amount;\\n        totalStakedPrincipal -= h.amount;\\n\\n        require(\\n            token.balanceOf(address(this)) >= h.amount,\\n            \\\"Insufficient contract balance\\\"\\n        );\\n        token.safeTransfer(staker, h.amount);\\n        emit Withdrawn(staker, historyIndex, h.amount);\\n    }\\n\\n    function _calculatePendingReward(\\n        UserHistory storage h,\\n        bool onlyview\\n    ) internal view returns (uint256 payableAmt) {\\n        if (\\n            h.starttime == 0 || h.withdrawn || h.totalclaimed >= h.totalreward\\n        ) {\\n            return 0;\\n        }\\n\\n        StakingPlan memory plan = plans[h.planId];\\n\\n        // Respect claim interval — nothing shown as pending until it's actually claimable.\\n        uint256 nextClaimAt = h.claimed + plan.claimtime;\\n        if (block.timestamp < nextClaimAt && !onlyview) {\\n            return 0;\\n        }\\n\\n        // Never accrue rewards beyond the stake end time.\\n        uint256 accrualEnd = block.timestamp < h.endtime\\n            ? block.timestamp\\n            : h.endtime;\\n\\n        if (accrualEnd <= h.claimed) {\\n            return 0;\\n        }\\n\\n        uint256 elapsed = accrualEnd - h.claimed;\\n        payableAmt = (h.amount * h.apy * elapsed) / (YEAR * BPS_DENOMINATOR);\\n\\n        uint256 remaining = h.totalreward - h.totalclaimed;\\n        if (payableAmt > remaining) {\\n            payableAmt = remaining;\\n        }\\n\\n        return payableAmt;\\n    }\\n\\n    function _tryClaimReward(\\n        address staker,\\n        uint256 historyIndex\\n    ) internal returns (uint256 payableAmt) {\\n        UserHistory storage h = userhistory[staker][historyIndex];\\n\\n        if (\\n            h.starttime == 0 || h.withdrawn || h.totalclaimed >= h.totalreward\\n        ) {\\n            return 0;\\n        }\\n\\n        StakingPlan memory plan = plans[h.planId];\\n        uint256 nextClaimAt = h.claimed + plan.claimtime;\\n        if (block.timestamp < nextClaimAt) {\\n            return 0; // claim interval not reached yet — skip, don't revert\\n        }\\n\\n        uint256 accrualEnd = block.timestamp < h.endtime\\n            ? block.timestamp\\n            : h.endtime;\\n        if (accrualEnd <= h.claimed) {\\n            return 0;\\n        }\\n\\n        uint256 elapsed = accrualEnd - h.claimed;\\n        payableAmt = (h.amount * h.apy * elapsed) / (YEAR * BPS_DENOMINATOR);\\n\\n        uint256 remaining = h.totalreward - h.totalclaimed;\\n        if (payableAmt > remaining) {\\n            payableAmt = remaining;\\n        }\\n\\n        if (payableAmt == 0) {\\n            return 0;\\n        }\\n\\n        h.totalclaimed += payableAmt;\\n        h.claimed = accrualEnd;\\n\\n        users[staker].totalclaimed += payableAmt;\\n        totalrewardclaimed += payableAmt;\\n\\n        uint256 claimIndex = users[staker].claimCount++;\\n        userclaimhistory[staker][claimIndex] = UserClaimHistory({\\n            index: claimIndex,\\n            txId: historyIndex,\\n            amount: h.amount,\\n            totalclaimed: payableAmt,\\n            time: block.timestamp\\n        });\\n\\n        emit RewardClaimed(staker, historyIndex, payableAmt);\\n    }\\n\\n    function claimRewardByPlan(\\n        uint256 planId\\n    ) external nonReentrant whenClaimNotPaused {\\n        require(planId < planCount, \\\"Plan does not exist\\\");\\n\\n        address staker = _msgSender();\\n        uint256[] memory ids = activeorderids[staker];\\n        uint256 totalPayable = 0;\\n\\n        for (uint256 i = 0; i < ids.length; i++) {\\n            uint256 historyIndex = ids[i];\\n            if (userhistory[staker][historyIndex].planId != planId) {\\n                continue;\\n            }\\n            totalPayable += _tryClaimReward(staker, historyIndex);\\n        }\\n\\n        require(totalPayable > 0, \\\"Nothing to claim for this plan\\\");\\n        require(\\n            token.balanceOf(address(this)) >= totalPayable,\\n            \\\"Insufficient contract balance\\\"\\n        );\\n        token.safeTransfer(staker, totalPayable);\\n    }\\n\\n    function pendingReward(\\n        address staker,\\n        uint256 historyIndex,\\n        bool onlyview\\n    ) public view returns (uint256) {\\n        return\\n            _calculatePendingReward(\\n                userhistory[staker][historyIndex],\\n                onlyview\\n            );\\n    }\\n\\n    function getPendingRewardByPlans(\\n        address _user,\\n        bool onlyview\\n    )\\n        public\\n        view\\n        returns (uint256[] memory totalstaked, uint256[] memory pendingRewards)\\n    {\\n        pendingRewards = new uint256[](planCount);\\n        totalstaked = new uint256[](planCount);\\n        uint256[] memory orderIds = activeorderids[_user];\\n\\n        for (uint256 i = 0; i < orderIds.length; i++) {\\n            UserHistory storage h = userhistory[_user][orderIds[i]];\\n            totalstaked[h.planId] += h.amount;\\n            uint256 reward = _calculatePendingReward(h, onlyview);\\n\\n            if (reward > 0) {\\n                pendingRewards[h.planId] += reward;\\n            }\\n        }\\n    }\\n\\n    function getTotalPending(\\n        address _user,\\n        bool onlyview\\n    ) public view returns (uint256) {\\n        uint256[] memory orderIds = activeorderids[_user];\\n        uint256 total;\\n        for (uint256 i = 0; i < orderIds.length; i++) {\\n            UserHistory storage h = userhistory[_user][orderIds[i]];\\n            uint256 reward = _calculatePendingReward(h, onlyview);\\n            if (reward > 0) {\\n                total += reward;\\n            }\\n        }\\n\\n        return total;\\n    }\\n\\n    function withdrawDAN(\\n        address payable to,\\n        uint256 amount\\n    ) external onlyOwner {\\n        require(to != address(0), \\\"Cannot send to zero address\\\");\\n        require(address(this).balance >= amount, \\\"Insufficient BNB balance\\\");\\n        (bool success, ) = to.call{value: amount}(\\\"\\\");\\n        require(success, \\\" transfer failed\\\");\\n        emit BNBRescued(to, amount);\\n    }\\n\\n    function withdrawAnyToken(\\n        address tokenAddr,\\n        address to,\\n        uint256 amount\\n    ) external onlyOwner {\\n        require(tokenAddr != address(0), \\\"Token address cannot be zero\\\");\\n        require(to != address(0), \\\"Cannot send to zero address\\\");\\n        IERC20(tokenAddr).safeTransfer(to, amount);\\n        emit TokensRescued(tokenAddr, to, amount);\\n    }\\n\\n    // ---------------------------------------------------------------------\\n    // Views\\n    // ---------------------------------------------------------------------\\n\\n    function getPlan(\\n        uint256 planId\\n    ) external view returns (StakingPlan memory) {\\n        require(planId < planCount, \\\"Plan does not exist\\\");\\n        return plans[planId];\\n    }\\n\\n    function getUserHistory(\\n        address staker,\\n        uint256 historyIndex\\n    ) external view returns (UserHistory memory) {\\n        return userhistory[staker][historyIndex];\\n    }\\n\\n    function getUserReferral(\\n        address staker,\\n        uint256 referralIndex\\n    ) external view returns (UserReferrals memory) {\\n        return userreferral[staker][referralIndex];\\n    }\\n\\n    function getUserStakingHistory(\\n        address staker,\\n        uint256 page,\\n        uint256 limit\\n    )\\n        external\\n        view\\n        returns (\\n            UserHistory[] memory history,\\n            uint256 total,\\n            uint256 totalPages\\n        )\\n    {\\n        total = users[staker].historyCount;\\n\\n        if (limit == 0 || total == 0) {\\n            return (new UserHistory[](0), total, 0);\\n        }\\n\\n        totalPages = (total + limit - 1) / limit; // ceil(total / limit)\\n\\n        // page is 1-indexed; guard against page 0 or out-of-range page\\n        if (page == 0 || page > totalPages) {\\n            return (new UserHistory[](0), total, totalPages);\\n        }\\n\\n        uint256 offset = (page - 1) * limit;\\n        uint256 remaining = total - offset;\\n        uint256 size = remaining < limit ? remaining : limit;\\n\\n        history = new UserHistory[](size);\\n\\n        for (uint256 i = 0; i < size; i++) {\\n            uint256 idx = total - 1 - offset - i;\\n            history[i] = userhistory[staker][idx];\\n        }\\n    }\\n\\n    function getUserReferralHistory(\\n        address staker,\\n        uint256 page,\\n        uint256 limit\\n    )\\n        external\\n        view\\n        returns (\\n            UserReferrals[] memory history,\\n            uint256 total,\\n            uint256 totalPages\\n        )\\n    {\\n        total = users[staker].referralCount;\\n\\n        if (limit == 0 || total == 0) {\\n            return (new UserReferrals[](0), total, 0);\\n        }\\n\\n        totalPages = (total + limit - 1) / limit; // ceil(total / limit)\\n\\n        // page is 1-indexed; guard against page 0 or out-of-range page\\n        if (page == 0 || page > totalPages) {\\n            return (new UserReferrals[](0), total, totalPages);\\n        }\\n\\n        uint256 offset = (page - 1) * limit;\\n        uint256 remaining = total - offset;\\n        uint256 size = remaining < limit ? remaining : limit;\\n\\n        history = new UserReferrals[](size);\\n\\n        for (uint256 i = 0; i < size; i++) {\\n            uint256 idx = total - 1 - offset - i;\\n            history[i] = userreferral[staker][idx];\\n        }\\n    }\\n\\n    function getUserRewardHistory(\\n        address staker,\\n        uint256 page,\\n        uint256 limit\\n    )\\n        external\\n        view\\n        returns (\\n            UserClaimHistory[] memory history,\\n            uint256 total,\\n            uint256 totalPages\\n        )\\n    {\\n        total = users[staker].claimCount;\\n\\n        if (limit == 0 || total == 0) {\\n            return (new UserClaimHistory[](0), total, 0);\\n        }\\n\\n        totalPages = (total + limit - 1) / limit; // ceil(total / limit)\\n\\n        // page is 1-indexed; guard against page 0 or out-of-range page\\n        if (page == 0 || page > totalPages) {\\n            return (new UserClaimHistory[](0), total, totalPages);\\n        }\\n\\n        uint256 offset = (page - 1) * limit;\\n        uint256 remaining = total - offset;\\n        uint256 size = remaining < limit ? remaining : limit;\\n\\n        history = new UserClaimHistory[](size);\\n\\n        for (uint256 i = 0; i < size; i++) {\\n            uint256 idx = total - 1 - offset - i;\\n            history[i] = userclaimhistory[staker][idx];\\n        }\\n    }\\n\\n    function nextClaimIn(\\n        address staker,\\n        uint256 historyIndex\\n    ) external view returns (uint256) {\\n        UserHistory memory h = userhistory[staker][historyIndex];\\n        if (h.starttime == 0) return 0;\\n        StakingPlan memory plan = plans[h.planId];\\n        uint256 nextClaimAt = h.claimed + plan.claimtime;\\n        return\\n            block.timestamp >= nextClaimAt ? 0 : nextClaimAt - block.timestamp;\\n    }\\n\\n    function getEarliestClaimableOrder(\\n        address staker\\n    )\\n        external\\n        view\\n        returns (uint256 orderId, uint256 nextClaimAt, bool hasActiveOrder)\\n    {\\n        uint256[] memory ids = activeorderids[staker];\\n        uint256 len = ids.length;\\n\\n        if (len == 0) {\\n            return (0, 0, false);\\n        }\\n\\n        uint256 earliestTime = type(uint256).max;\\n        uint256 earliestId;\\n\\n        for (uint256 i = 0; i < len; i++) {\\n            uint256 historyIndex = ids[i];\\n            UserHistory storage h = userhistory[staker][historyIndex];\\n            StakingPlan memory plan = plans[h.planId];\\n\\n            uint256 claimAt = h.claimed + plan.claimtime;\\n\\n            if (claimAt < earliestTime) {\\n                earliestTime = claimAt;\\n                earliestId = historyIndex;\\n            }\\n        }\\n\\n        return (earliestId, earliestTime, true);\\n    }\\n\\n    function _removeActiveOrder(address _user, uint256 _index) internal {\\n        uint256[] storage activeIds = activeorderids[_user];\\n        uint256 lastIndex = activeIds.length - 1;\\n        if (_index != lastIndex) {\\n            activeIds[_index] = activeIds[lastIndex];\\n        }\\n        activeIds.pop();\\n    }\\n\\n    function _removeFromActiveById(address _user, uint256 _orderId) internal {\\n        uint256[] storage activeIds = activeorderids[_user];\\n        for (uint256 i = 0; i < activeIds.length; i++) {\\n            if (activeIds[i] == _orderId) {\\n                _removeActiveOrder(_user, i);\\n                break;\\n            }\\n        }\\n    }\\n\\n    function setToken(address tokenAddress) external onlyOwner {\\n        require(tokenAddress != address(0), \\\"Token address cannot be zero\\\");\\n        token = IERC20(tokenAddress);\\n    }\\n\\n    function pauseDeposit() external onlyOwner {\\n        require(!depositPaused, \\\"Deposits are already paused\\\");\\n        depositPaused = true;\\n        emit DepositPaused();\\n    }\\n\\n    function unpauseDeposit() external onlyOwner {\\n        require(depositPaused, \\\"Deposits are not paused\\\");\\n        depositPaused = false;\\n        emit DepositUnpaused();\\n    }\\n\\n    function pauseClaim() external onlyOwner {\\n        require(!claimPaused, \\\"Claiming is already paused\\\");\\n        claimPaused = true;\\n        emit ClaimPaused();\\n    }\\n\\n    function unpauseClaim() external onlyOwner {\\n        require(claimPaused, \\\"Claiming is not paused\\\");\\n        claimPaused = false;\\n        emit ClaimUnpaused();\\n    }\\n\\n    function pauseWithdraw() external onlyOwner {\\n        require(!withdrawPaused, \\\"Withdrawals are already paused\\\");\\n        withdrawPaused = true;\\n        emit WithdrawPaused();\\n    }\\n\\n    function unpauseWithdraw() external onlyOwner {\\n        require(withdrawPaused, \\\"Withdrawals are not paused\\\");\\n        withdrawPaused = false;\\n        emit WithdrawUnpaused();\\n    }\\n\\n    function getActivePlans()\\n        external\\n        view\\n        returns (uint256[] memory planIds, StakingPlan[] memory activePlans)\\n    {\\n        uint256 count = 0;\\n\\n        for (uint256 i = 0; i < planCount; i++) {\\n            if (plans[i].active) {\\n                count++;\\n            }\\n        }\\n\\n        planIds = new uint256[](count);\\n        activePlans = new StakingPlan[](count);\\n\\n        uint256 idx = 0;\\n        for (uint256 i = 0; i < planCount; i++) {\\n            if (plans[i].active) {\\n                planIds[idx] = i;\\n                activePlans[idx] = plans[i];\\n                idx++;\\n            }\\n        }\\n    }\\n\\n    function userReferralInfo(\\n        address _user\\n    ) public view returns (uint256[4] memory, uint256[4] memory) {\\n        return (\\n            users[_user].totalrefcountbylevel,\\n            users[_user].totalrefrewardbylevel\\n        );\\n    }\\n\\n    function getAllPlans() external view returns (StakingPlan[] memory) {\\n        StakingPlan[] memory allPlans = new StakingPlan[](planCount);\\n\\n        for (uint256 i = 0; i < planCount; i++) {\\n            allPlans[i] = plans[i];\\n        }\\n\\n        return allPlans;\\n    }\\n\\n    function getDailyReward(\\n        address user\\n    ) external view returns (uint256 totalDailyReward) {\\n        uint256[] memory orderIds = activeorderids[user];\\n\\n        for (uint256 i = 0; i < orderIds.length; i++) {\\n            UserHistory storage h = userhistory[user][orderIds[i]];\\n\\n            if (\\n                h.starttime == 0 ||\\n                h.withdrawn ||\\n                h.totalclaimed >= h.totalreward\\n            ) {\\n                continue;\\n            }\\n\\n            if (block.timestamp < h.starttime || block.timestamp >= h.endtime) {\\n                continue;\\n            }\\n\\n            uint256 dailyReward = (h.amount * h.apy) / BPS_DENOMINATOR / 365;\\n            totalDailyReward += dailyReward;\\n        }\\n    }\\n\\n    function getUserActiveOrderIds(\\n        address _user\\n    ) public view returns (uint256[] memory) {\\n        return activeorderids[_user];\\n    }\\n\\n    function setClaimTimeForAllPlans(uint256 newClaimTime) external onlyOwner {\\n        for (uint256 i = 0; i < planCount; i++) {\\n            plans[i].claimtime = newClaimTime;\\n            emit PlanEdited(i);\\n        }\\n    }\\n\\n    /// @dev Reserved storage slots for future variables. Reduce this number by 1 for every\\n    ///      new state variable you add in a later version — never insert/remove/reorder\\n    ///      existing state variables, only append new ones and shrink the gap to match.\\n    uint256[50] private __gap;\\n}\\n\",\"@openzeppelin/contracts/interfaces/IERC20.sol\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC20} from \\\"../token/ERC20/IERC20.sol\\\";\\n\",\"@openzeppelin/contracts/interfaces/IERC1967.sol\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1967.sol)\\n\\npragma solidity >=0.4.11;\\n\\n/**\\n * @dev ERC-1967: Proxy Storage Slots. This interface contains the events defined in the ERC.\\n */\\ninterface IERC1967 {\\n    /**\\n     * @dev Emitted when the implementation is upgraded.\\n     */\\n    event Upgraded(address indexed implementation);\\n\\n    /**\\n     * @dev Emitted when the admin account has changed.\\n     */\\n    event AdminChanged(address previousAdmin, address newAdmin);\\n\\n    /**\\n     * @dev Emitted when the beacon is changed.\\n     */\\n    event BeaconUpgraded(address indexed beacon);\\n}\\n\",\"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {ContextUpgradeable} from \\\"../utils/ContextUpgradeable.sol\\\";\\nimport {Initializable} from \\\"@openzeppelin/contracts/proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * The initial owner is set to the address provided by the deployer. This can\\n * later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {\\n    /// @custom:storage-location erc7201:openzeppelin.storage.Ownable\\n    struct OwnableStorage {\\n        address _owner;\\n    }\\n\\n    // keccak256(abi.encode(uint256(keccak256(\\\"openzeppelin.storage.Ownable\\\")) - 1)) & ~bytes32(uint256(0xff))\\n    bytes32 private constant OwnableStorageLocation = 0x9016d09d72d40fdae2fd8ceac6b6234c7706214fd39c1cd1e609a0528c199300;\\n\\n    function _getOwnableStorage() private pure returns (OwnableStorage storage $) {\\n        assembly {\\n            $.slot := OwnableStorageLocation\\n        }\\n    }\\n\\n    /**\\n     * @dev The caller account is not authorized to perform an operation.\\n     */\\n    error OwnableUnauthorizedAccount(address account);\\n\\n    /**\\n     * @dev The owner is not a valid owner account. (eg. `address(0)`)\\n     */\\n    error OwnableInvalidOwner(address owner);\\n\\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n    /**\\n     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.\\n     */\\n    function __Ownable_init(address initialOwner) internal onlyInitializing {\\n        __Ownable_init_unchained(initialOwner);\\n    }\\n\\n    function __Ownable_init_unchained(address initialOwner) internal onlyInitializing {\\n        if (initialOwner == address(0)) {\\n            revert OwnableInvalidOwner(address(0));\\n        }\\n        _transferOwnership(initialOwner);\\n    }\\n\\n    /**\\n     * @dev Throws if called by any account other than the owner.\\n     */\\n    modifier onlyOwner() {\\n        _checkOwner();\\n        _;\\n    }\\n\\n    /**\\n     * @dev Returns the address of the current owner.\\n     */\\n    function owner() public view virtual returns (address) {\\n        OwnableStorage storage $ = _getOwnableStorage();\\n        return $._owner;\\n    }\\n\\n    /**\\n     * @dev Throws if the sender is not the owner.\\n     */\\n    function _checkOwner() internal view virtual {\\n        if (owner() != _msgSender()) {\\n            revert OwnableUnauthorizedAccount(_msgSender());\\n        }\\n    }\\n\\n    /**\\n     * @dev Leaves the contract without owner. It will not be possible to call\\n     * `onlyOwner` functions. Can only be called by the current owner.\\n     *\\n     * NOTE: Renouncing ownership will leave the contract without an owner,\\n     * thereby disabling any functionality that is only available to the owner.\\n     */\\n    function renounceOwnership() public virtual onlyOwner {\\n        _transferOwnership(address(0));\\n    }\\n\\n    /**\\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n     * Can only be called by the current owner.\\n     */\\n    function transferOwnership(address newOwner) public virtual onlyOwner {\\n        if (newOwner == address(0)) {\\n            revert OwnableInvalidOwner(address(0));\\n        }\\n        _transferOwnership(newOwner);\\n    }\\n\\n    /**\\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n     * Internal function without access restriction.\\n     */\\n    function _transferOwnership(address newOwner) internal virtual {\\n        OwnableStorage storage $ = _getOwnableStorage();\\n        address oldOwner = $._owner;\\n        $._owner = newOwner;\\n        emit OwnershipTransferred(oldOwner, newOwner);\\n    }\\n}\\n\",\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.20;\\n\\nimport {Initializable} from \\\"@openzeppelin/contracts/proxy/utils/Initializable.sol\\\";\\n\",\"@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.22;\\n\\nimport {UUPSUpgradeable} from \\\"@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol\\\";\\n\",\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)\\n\\npragma solidity ^0.8.20;\\nimport {Initializable} from \\\"@openzeppelin/contracts/proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n    function __Context_init() internal onlyInitializing {\\n    }\\n\\n    function __Context_init_unchained() internal onlyInitializing {\\n    }\\n    function _msgSender() internal view virtual returns (address) {\\n        return msg.sender;\\n    }\\n\\n    function _msgData() internal view virtual returns (bytes calldata) {\\n        return msg.data;\\n    }\\n\\n    function _contextSuffixLength() internal view virtual returns (uint256) {\\n        return 0;\\n    }\\n}\\n\",\"@openzeppelin/contracts/interfaces/IERC1363.sol\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"./IERC20.sol\\\";\\nimport {IERC165} from \\\"./IERC165.sol\\\";\\n\\n/**\\n * @title IERC1363\\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\\n *\\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\\n */\\ninterface IERC1363 is IERC20, IERC165 {\\n    /*\\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\\n     * 0xb0202a11 ===\\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\\n     */\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @param data Additional data with no specified format, sent in call to `spender`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\\n}\\n\",\"@openzeppelin/contracts/interfaces/IERC165.sol\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC165} from \\\"../utils/introspection/IERC165.sol\\\";\\n\",\"@openzeppelin/contracts/interfaces/draft-IERC1822.sol\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/draft-IERC1822.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev ERC-1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified\\n * proxy whose upgrades are fully controlled by the current implementation.\\n */\\ninterface IERC1822Proxiable {\\n    /**\\n     * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation\\n     * address.\\n     *\\n     * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks\\n     * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this\\n     * function revert if invoked through a proxy.\\n     */\\n    function proxiableUUID() external view returns (bytes32);\\n}\\n\",\"@openzeppelin/contracts/proxy/ERC1967/ERC1967Utils.sol\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.6.0) (proxy/ERC1967/ERC1967Utils.sol)\\n\\npragma solidity ^0.8.21;\\n\\nimport {IBeacon} from \\\"../beacon/IBeacon.sol\\\";\\nimport {IERC1967} from \\\"../../interfaces/IERC1967.sol\\\";\\nimport {Address} from \\\"../../utils/Address.sol\\\";\\nimport {StorageSlot} from \\\"../../utils/StorageSlot.sol\\\";\\n\\n/**\\n * @dev This library provides getters and event emitting update functions for\\n * https://eips.ethereum.org/EIPS/eip-1967[ERC-1967] slots.\\n */\\nlibrary ERC1967Utils {\\n    /**\\n     * @dev Storage slot with the address of the current implementation.\\n     * This is the keccak-256 hash of \\\"eip1967.proxy.implementation\\\" subtracted by 1.\\n     */\\n    // solhint-disable-next-line private-vars-leading-underscore\\n    bytes32 internal constant IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n    /**\\n     * @dev The `implementation` of the proxy is invalid.\\n     */\\n    error ERC1967InvalidImplementation(address implementation);\\n\\n    /**\\n     * @dev The `admin` of the proxy is invalid.\\n     */\\n    error ERC1967InvalidAdmin(address admin);\\n\\n    /**\\n     * @dev The `beacon` of the proxy is invalid.\\n     */\\n    error ERC1967InvalidBeacon(address beacon);\\n\\n    /**\\n     * @dev An upgrade function sees `msg.value > 0` that may be lost.\\n     */\\n    error ERC1967NonPayable();\\n\\n    /**\\n     * @dev Returns the current implementation address.\\n     */\\n    function getImplementation() internal view returns (address) {\\n        return StorageSlot.getAddressSlot(IMPLEMENTATION_SLOT).value;\\n    }\\n\\n    /**\\n     * @dev Stores a new address in the ERC-1967 implementation slot.\\n     */\\n    function _setImplementation(address newImplementation) private {\\n        if (newImplementation.code.length == 0) {\\n            revert ERC1967InvalidImplementation(newImplementation);\\n        }\\n        StorageSlot.getAddressSlot(IMPLEMENTATION_SLOT).value = newImplementation;\\n    }\\n\\n    /**\\n     * @dev Performs implementation upgrade with additional setup call if data is nonempty.\\n     * This function is payable only if the setup call is performed, otherwise `msg.value` is rejected\\n     * to avoid stuck value in the contract.\\n     *\\n     * Emits an {IERC1967-Upgraded} event.\\n     */\\n    function upgradeToAndCall(address newImplementation, bytes memory data) internal {\\n        _setImplementation(newImplementation);\\n        emit IERC1967.Upgraded(newImplementation);\\n\\n        if (data.length > 0) {\\n            Address.functionDelegateCall(newImplementation, data);\\n        } else {\\n            _checkNonPayable();\\n        }\\n    }\\n\\n    /**\\n     * @dev Storage slot with the admin of the contract.\\n     * This is the keccak-256 hash of \\\"eip1967.proxy.admin\\\" subtracted by 1.\\n     */\\n    // solhint-disable-next-line private-vars-leading-underscore\\n    bytes32 internal constant ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;\\n\\n    /**\\n     * @dev Returns the current admin.\\n     *\\n     * TIP: To get this value clients can read directly from the storage slot shown below (specified by ERC-1967) using\\n     * the https://ethereum.org/developers/docs/apis/json-rpc/#eth_getstorageat[`eth_getStorageAt`] RPC call.\\n     * `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103`\\n     */\\n    function getAdmin() internal view returns (address) {\\n        return StorageSlot.getAddressSlot(ADMIN_SLOT).value;\\n    }\\n\\n    /**\\n     * @dev Stores a new address in the ERC-1967 admin slot.\\n     */\\n    function _setAdmin(address newAdmin) private {\\n        if (newAdmin == address(0)) {\\n            revert ERC1967InvalidAdmin(address(0));\\n        }\\n        StorageSlot.getAddressSlot(ADMIN_SLOT).value = newAdmin;\\n    }\\n\\n    /**\\n     * @dev Changes the admin of the proxy.\\n     *\\n     * Emits an {IERC1967-AdminChanged} event.\\n     */\\n    function changeAdmin(address newAdmin) internal {\\n        emit IERC1967.AdminChanged(getAdmin(), newAdmin);\\n        _setAdmin(newAdmin);\\n    }\\n\\n    /**\\n     * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n     * This is the keccak-256 hash of \\\"eip1967.proxy.beacon\\\" subtracted by 1.\\n     */\\n    // solhint-disable-next-line private-vars-leading-underscore\\n    bytes32 internal constant BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n    /**\\n     * @dev Returns the current beacon.\\n     */\\n    function getBeacon() internal view returns (address) {\\n        return StorageSlot.getAddressSlot(BEACON_SLOT).value;\\n    }\\n\\n    /**\\n     * @dev Stores a new beacon in the ERC-1967 beacon slot.\\n     */\\n    function _setBeacon(address newBeacon) private {\\n        if (newBeacon.code.length == 0) {\\n            revert ERC1967InvalidBeacon(newBeacon);\\n        }\\n\\n        StorageSlot.getAddressSlot(BEACON_SLOT).value = newBeacon;\\n\\n        address beaconImplementation = IBeacon(newBeacon).implementation();\\n        if (beaconImplementation.code.length == 0) {\\n            revert ERC1967InvalidImplementation(beaconImplementation);\\n        }\\n    }\\n\\n    /**\\n     * @dev Change the beacon and trigger a setup call if data is nonempty.\\n     * This function is payable only if the setup call is performed, otherwise `msg.value` is rejected\\n     * to avoid stuck value in the contract.\\n     *\\n     * Emits an {IERC1967-BeaconUpgraded} event.\\n     *\\n     * CAUTION: Invoking this function has no effect on an instance of {BeaconProxy} since v5, since\\n     * it uses an immutable beacon without looking at the value of the ERC-1967 beacon slot for\\n     * efficiency.\\n     */\\n    function upgradeBeaconToAndCall(address newBeacon, bytes memory data) internal {\\n        _setBeacon(newBeacon);\\n        emit IERC1967.BeaconUpgraded(newBeacon);\\n\\n        if (data.length > 0) {\\n            Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);\\n        } else {\\n            _checkNonPayable();\\n        }\\n    }\\n\\n    /**\\n     * @dev Reverts if `msg.value` is not zero. It can be used to avoid `msg.value` stuck in the contract\\n     * if an upgrade doesn't perform an initialization call.\\n     */\\n    function _checkNonPayable() private {\\n        if (msg.value > 0) {\\n            revert ERC1967NonPayable();\\n        }\\n    }\\n}\\n\",\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (proxy/beacon/IBeacon.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeacon {\\n    /**\\n     * @dev Must return an address that can be used as a delegate call target.\\n     *\\n     * {UpgradeableBeacon} will check that this address is a contract.\\n     */\\n    function implementation() external view returns (address);\\n}\\n\",\"@openzeppelin/contracts/proxy/utils/Initializable.sol\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (proxy/utils/Initializable.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\\n * reused. This mechanism prevents re-execution of each \\\"step\\\" but allows the creation of new initialization steps in\\n * case an upgrade adds a module that needs to be initialized.\\n *\\n * For example:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```solidity\\n * contract MyToken is ERC20Upgradeable {\\n *     function initialize() initializer public {\\n *         __ERC20_init(\\\"MyToken\\\", \\\"MTK\\\");\\n *     }\\n * }\\n *\\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\\n *     function initializeV2() reinitializer(2) public {\\n *         __ERC20Permit_init(\\\"MyToken\\\");\\n *     }\\n * }\\n * ```\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n *\\n * [CAUTION]\\n * ====\\n * Avoid leaving a contract uninitialized.\\n *\\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```\\n * /// @custom:oz-upgrades-unsafe-allow constructor\\n * constructor() {\\n *     _disableInitializers();\\n * }\\n * ```\\n * ====\\n */\\nabstract contract Initializable {\\n    /**\\n     * @dev Storage of the initializable contract.\\n     *\\n     * It's implemented on a custom ERC-7201 namespace to reduce the risk of storage collisions\\n     * when using with upgradeable contracts.\\n     *\\n     * @custom:storage-location erc7201:openzeppelin.storage.Initializable\\n     */\\n    struct InitializableStorage {\\n        /**\\n         * @dev Indicates that the contract has been initialized.\\n         */\\n        uint64 _initialized;\\n        /**\\n         * @dev Indicates that the contract is in the process of being initialized.\\n         */\\n        bool _initializing;\\n    }\\n\\n    // keccak256(abi.encode(uint256(keccak256(\\\"openzeppelin.storage.Initializable\\\")) - 1)) & ~bytes32(uint256(0xff))\\n    bytes32 private constant INITIALIZABLE_STORAGE = 0xf0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00;\\n\\n    /**\\n     * @dev The contract is already initialized.\\n     */\\n    error InvalidInitialization();\\n\\n    /**\\n     * @dev The contract is not initializing.\\n     */\\n    error NotInitializing();\\n\\n    /**\\n     * @dev Triggered when the contract has been initialized or reinitialized.\\n     */\\n    event Initialized(uint64 version);\\n\\n    /**\\n     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\\n     * `onlyInitializing` functions can be used to initialize parent contracts.\\n     *\\n     * Similar to `reinitializer(1)`, except that in the context of a constructor an `initializer` may be invoked any\\n     * number of times. This behavior in the constructor can be useful during testing and is not expected to be used in\\n     * production.\\n     *\\n     * Emits an {Initialized} event.\\n     */\\n    modifier initializer() {\\n        // solhint-disable-next-line var-name-mixedcase\\n        InitializableStorage storage $ = _getInitializableStorage();\\n\\n        // Cache values to avoid duplicated sloads\\n        bool isTopLevelCall = !$._initializing;\\n        uint64 initialized = $._initialized;\\n\\n        // Allowed calls:\\n        // - initialSetup: the contract is not in the initializing state and no previous version was\\n        //                 initialized\\n        // - construction: the contract is initialized at version 1 (no reinitialization) and the\\n        //                 current contract is just being deployed\\n        bool initialSetup = initialized == 0 && isTopLevelCall;\\n        bool construction = initialized == 1 && address(this).code.length == 0;\\n\\n        if (!initialSetup && !construction) {\\n            revert InvalidInitialization();\\n        }\\n        $._initialized = 1;\\n        if (isTopLevelCall) {\\n            $._initializing = true;\\n        }\\n        _;\\n        if (isTopLevelCall) {\\n            $._initializing = false;\\n            emit Initialized(1);\\n        }\\n    }\\n\\n    /**\\n     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\\n     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\\n     * used to initialize parent contracts.\\n     *\\n     * A reinitializer may be used after the original initialization step. This is essential to configure modules that\\n     * are added through upgrades and that require initialization.\\n     *\\n     * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`\\n     * cannot be nested. If one is invoked in the context of another, execution will revert.\\n     *\\n     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\\n     * a contract, executing them in the right order is up to the developer or operator.\\n     *\\n     * WARNING: Setting the version to 2**64 - 1 will prevent any future reinitialization.\\n     *\\n     * Emits an {Initialized} event.\\n     */\\n    modifier reinitializer(uint64 version) {\\n        // solhint-disable-next-line var-name-mixedcase\\n        InitializableStorage storage $ = _getInitializableStorage();\\n\\n        if ($._initializing || $._initialized >= version) {\\n            revert InvalidInitialization();\\n        }\\n        $._initialized = version;\\n        $._initializing = true;\\n        _;\\n        $._initializing = false;\\n        emit Initialized(version);\\n    }\\n\\n    /**\\n     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\\n     * {initializer} and {reinitializer} modifiers, directly or indirectly.\\n     */\\n    modifier onlyInitializing() {\\n        _checkInitializing();\\n        _;\\n    }\\n\\n    /**\\n     * @dev Reverts if the contract is not in an initializing state. See {onlyInitializing}.\\n     */\\n    function _checkInitializing() internal view virtual {\\n        if (!_isInitializing()) {\\n            revert NotInitializing();\\n        }\\n    }\\n\\n    /**\\n     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\\n     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\\n     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\\n     * through proxies.\\n     *\\n     * Emits an {Initialized} event the first time it is successfully executed.\\n     */\\n    function _disableInitializers() internal virtual {\\n        // solhint-disable-next-line var-name-mixedcase\\n        InitializableStorage storage $ = _getInitializableStorage();\\n\\n        if ($._initializing) {\\n            revert InvalidInitialization();\\n        }\\n        if ($._initialized != type(uint64).max) {\\n            $._initialized = type(uint64).max;\\n            emit Initialized(type(uint64).max);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the highest version that has been initialized. See {reinitializer}.\\n     */\\n    function _getInitializedVersion() internal view returns (uint64) {\\n        return _getInitializableStorage()._initialized;\\n    }\\n\\n    /**\\n     * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.\\n     */\\n    function _isInitializing() internal view returns (bool) {\\n        return _getInitializableStorage()._initializing;\\n    }\\n\\n    /**\\n     * @dev Pointer to storage slot. Allows integrators to override it with a custom storage location.\\n     *\\n     * NOTE: Consider following the ERC-7201 formula to derive storage locations.\\n     */\\n    function _initializableStorageSlot() internal pure virtual returns (bytes32) {\\n        return INITIALIZABLE_STORAGE;\\n    }\\n\\n    /**\\n     * @dev Returns a pointer to the storage namespace.\\n     */\\n    // solhint-disable-next-line var-name-mixedcase\\n    function _getInitializableStorage() private pure returns (InitializableStorage storage $) {\\n        bytes32 slot = _initializableStorageSlot();\\n        assembly {\\n            $.slot := slot\\n        }\\n    }\\n}\\n\",\"@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.5.0) (proxy/utils/UUPSUpgradeable.sol)\\n\\npragma solidity ^0.8.22;\\n\\nimport {IERC1822Proxiable} from \\\"../../interfaces/draft-IERC1822.sol\\\";\\nimport {ERC1967Utils} from \\\"../ERC1967/ERC1967Utils.sol\\\";\\n\\n/**\\n * @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an\\n * {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy.\\n *\\n * A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is\\n * reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing\\n * `UUPSUpgradeable` with a custom implementation of upgrades.\\n *\\n * The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism.\\n *\\n * @custom:stateless\\n */\\nabstract contract UUPSUpgradeable is IERC1822Proxiable {\\n    /// @custom:oz-upgrades-unsafe-allow state-variable-immutable\\n    address private immutable __self = address(this);\\n\\n    /**\\n     * @dev The version of the upgrade interface of the contract. If this getter is missing, both `upgradeTo(address)`\\n     * and `upgradeToAndCall(address,bytes)` are present, and `upgradeTo` must be used if no function should be called,\\n     * while `upgradeToAndCall` will invoke the `receive` function if the second argument is the empty byte string.\\n     * If the getter returns `\\\"5.0.0\\\"`, only `upgradeToAndCall(address,bytes)` is present, and the second argument must\\n     * be the empty byte string if no function should be called, making it impossible to invoke the `receive` function\\n     * during an upgrade.\\n     */\\n    string public constant UPGRADE_INTERFACE_VERSION = \\\"5.0.0\\\";\\n\\n    /**\\n     * @dev The call is from an unauthorized context.\\n     */\\n    error UUPSUnauthorizedCallContext();\\n\\n    /**\\n     * @dev The storage `slot` is unsupported as a UUID.\\n     */\\n    error UUPSUnsupportedProxiableUUID(bytes32 slot);\\n\\n    /**\\n     * @dev Check that the execution is being performed through a delegatecall call and that the execution context is\\n     * a proxy contract with an implementation (as defined in ERC-1967) pointing to self. This should only be the case\\n     * for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a\\n     * function through ERC-1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to\\n     * fail.\\n     */\\n    modifier onlyProxy() {\\n        _checkProxy();\\n        _;\\n    }\\n\\n    /**\\n     * @dev Check that the execution is not being performed through a delegate call. This allows a function to be\\n     * callable on the implementing contract but not through proxies.\\n     */\\n    modifier notDelegated() {\\n        _checkNotDelegated();\\n        _;\\n    }\\n\\n    /**\\n     * @dev Implementation of the ERC-1822 {proxiableUUID} function. This returns the storage slot used by the\\n     * implementation. It is used to validate the implementation's compatibility when performing an upgrade.\\n     *\\n     * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks\\n     * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this\\n     * function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier.\\n     */\\n    function proxiableUUID() external view notDelegated returns (bytes32) {\\n        return ERC1967Utils.IMPLEMENTATION_SLOT;\\n    }\\n\\n    /**\\n     * @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call\\n     * encoded in `data`.\\n     *\\n     * Calls {_authorizeUpgrade}.\\n     *\\n     * Emits an {Upgraded} event.\\n     *\\n     * @custom:oz-upgrades-unsafe-allow-reachable delegatecall\\n     */\\n    function upgradeToAndCall(address newImplementation, bytes memory data) public payable virtual onlyProxy {\\n        _authorizeUpgrade(newImplementation);\\n        _upgradeToAndCallUUPS(newImplementation, data);\\n    }\\n\\n    /**\\n     * @dev Reverts if the execution is not performed via delegatecall or the execution\\n     * context is not of a proxy with an ERC-1967 compliant implementation pointing to self.\\n     */\\n    function _checkProxy() internal view virtual {\\n        if (\\n            address(this) == __self || // Must be called through delegatecall\\n            ERC1967Utils.getImplementation() != __self // Must be called through an active proxy\\n        ) {\\n            revert UUPSUnauthorizedCallContext();\\n        }\\n    }\\n\\n    /**\\n     * @dev Reverts if the execution is performed via delegatecall.\\n     * See {notDelegated}.\\n     */\\n    function _checkNotDelegated() internal view virtual {\\n        if (address(this) != __self) {\\n            // Must not be called through delegatecall\\n            revert UUPSUnauthorizedCallContext();\\n        }\\n    }\\n\\n    /**\\n     * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by\\n     * {upgradeToAndCall}.\\n     *\\n     * Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}.\\n     *\\n     * ```solidity\\n     * function _authorizeUpgrade(address) internal onlyOwner {}\\n     * ```\\n     */\\n    function _authorizeUpgrade(address newImplementation) internal virtual;\\n\\n    /**\\n     * @dev Performs an implementation upgrade with a security check for UUPS proxies, and additional setup call.\\n     *\\n     * As a security check, {proxiableUUID} is invoked in the new implementation, and the return value\\n     * is expected to be the implementation slot in ERC-1967.\\n     *\\n     * Emits an {IERC1967-Upgraded} event.\\n     */\\n    function _upgradeToAndCallUUPS(address newImplementation, bytes memory data) private {\\n        try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {\\n            if (slot != ERC1967Utils.IMPLEMENTATION_SLOT) {\\n                revert UUPSUnsupportedProxiableUUID(slot);\\n            }\\n            ERC1967Utils.upgradeToAndCall(newImplementation, data);\\n        } catch {\\n            // The implementation is not UUPS\\n            revert ERC1967Utils.ERC1967InvalidImplementation(newImplementation);\\n        }\\n    }\\n}\\n\",\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-20 standard as defined in the ERC.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the value of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the value of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n     * allowance mechanism. `value` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.5.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC1363} from \\\"../../../interfaces/IERC1363.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n    /**\\n     * @dev An operation with an ERC-20 token failed.\\n     */\\n    error SafeERC20FailedOperation(address token);\\n\\n    /**\\n     * @dev Indicates a failed `decreaseAllowance` request.\\n     */\\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        if (!_safeTransfer(token, to, value, true)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n        if (!_safeTransferFrom(token, from, to, value, true)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\\n        return _safeTransfer(token, to, value, false);\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\\n        return _safeTransferFrom(token, from, to, value, false);\\n    }\\n\\n    /**\\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 oldAllowance = token.allowance(address(this), spender);\\n        forceApprove(token, spender, oldAllowance + value);\\n    }\\n\\n    /**\\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n     * value, non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n        unchecked {\\n            uint256 currentAllowance = token.allowance(address(this), spender);\\n            if (currentAllowance < requestedDecrease) {\\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n            }\\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\\n        }\\n    }\\n\\n    /**\\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n     * to be set to zero before setting it to a non-zero value, such as USDT.\\n     *\\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\\n     * only sets the \\\"standard\\\" allowance. Any temporary allowance will remain active, in addition to the value being\\n     * set here.\\n     */\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        if (!_safeApprove(token, spender, value, false)) {\\n            if (!_safeApprove(token, spender, 0, true)) revert SafeERC20FailedOperation(address(token));\\n            if (!_safeApprove(token, spender, value, true)) revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that relies on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            safeTransfer(token, to, value);\\n        } else if (!token.transferAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that relies on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferFromAndCallRelaxed(\\n        IERC1363 token,\\n        address from,\\n        address to,\\n        uint256 value,\\n        bytes memory data\\n    ) internal {\\n        if (to.code.length == 0) {\\n            safeTransferFrom(token, from, to, value);\\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\\n     * Oppositely, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\\n     * once without retrying, and relies on the returned value to be true.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            forceApprove(token, to, value);\\n        } else if (!token.approveAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity `token.transfer(to, value)` call, relaxing the requirement on the return value: the\\n     * return value is optional (but if data is returned, it must not be false).\\n     *\\n     * @param token The token targeted by the call.\\n     * @param to The recipient of the tokens\\n     * @param value The amount of token to transfer\\n     * @param bubble Behavior switch if the transfer call reverts: bubble the revert reason or return a false boolean.\\n     */\\n    function _safeTransfer(IERC20 token, address to, uint256 value, bool bubble) private returns (bool success) {\\n        bytes4 selector = IERC20.transfer.selector;\\n\\n        assembly (\\\"memory-safe\\\") {\\n            let fmp := mload(0x40)\\n            mstore(0x00, selector)\\n            mstore(0x04, and(to, shr(96, not(0))))\\n            mstore(0x24, value)\\n            success := call(gas(), token, 0, 0x00, 0x44, 0x00, 0x20)\\n            // if call success and return is true, all is good.\\n            // otherwise (not success or return is not true), we need to perform further checks\\n            if iszero(and(success, eq(mload(0x00), 1))) {\\n                // if the call was a failure and bubble is enabled, bubble the error\\n                if and(iszero(success), bubble) {\\n                    returndatacopy(fmp, 0x00, returndatasize())\\n                    revert(fmp, returndatasize())\\n                }\\n                // if the return value is not true, then the call is only successful if:\\n                // - the token address has code\\n                // - the returndata is empty\\n                success := and(success, and(iszero(returndatasize()), gt(extcodesize(token), 0)))\\n            }\\n            mstore(0x40, fmp)\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity `token.transferFrom(from, to, value)` call, relaxing the requirement on the return\\n     * value: the return value is optional (but if data is returned, it must not be false).\\n     *\\n     * @param token The token targeted by the call.\\n     * @param from The sender of the tokens\\n     * @param to The recipient of the tokens\\n     * @param value The amount of token to transfer\\n     * @param bubble Behavior switch if the transfer call reverts: bubble the revert reason or return a false boolean.\\n     */\\n    function _safeTransferFrom(\\n        IERC20 token,\\n        address from,\\n        address to,\\n        uint256 value,\\n        bool bubble\\n    ) private returns (bool success) {\\n        bytes4 selector = IERC20.transferFrom.selector;\\n\\n        assembly (\\\"memory-safe\\\") {\\n            let fmp := mload(0x40)\\n            mstore(0x00, selector)\\n            mstore(0x04, and(from, shr(96, not(0))))\\n            mstore(0x24, and(to, shr(96, not(0))))\\n            mstore(0x44, value)\\n            success := call(gas(), token, 0, 0x00, 0x64, 0x00, 0x20)\\n            // if call success and return is true, all is good.\\n            // otherwise (not success or return is not true), we need to perform further checks\\n            if iszero(and(success, eq(mload(0x00), 1))) {\\n                // if the call was a failure and bubble is enabled, bubble the error\\n                if and(iszero(success), bubble) {\\n                    returndatacopy(fmp, 0x00, returndatasize())\\n                    revert(fmp, returndatasize())\\n                }\\n                // if the return value is not true, then the call is only successful if:\\n                // - the token address has code\\n                // - the returndata is empty\\n                success := and(success, and(iszero(returndatasize()), gt(extcodesize(token), 0)))\\n            }\\n            mstore(0x40, fmp)\\n            mstore(0x60, 0)\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity `token.approve(spender, value)` call, relaxing the requirement on the return value:\\n     * the return value is optional (but if data is returned, it must not be false).\\n     *\\n     * @param token The token targeted by the call.\\n     * @param spender The spender of the tokens\\n     * @param value The amount of token to transfer\\n     * @param bubble Behavior switch if the transfer call reverts: bubble the revert reason or return a false boolean.\\n     */\\n    function _safeApprove(IERC20 token, address spender, uint256 value, bool bubble) private returns (bool success) {\\n        bytes4 selector = IERC20.approve.selector;\\n\\n        assembly (\\\"memory-safe\\\") {\\n            let fmp := mload(0x40)\\n            mstore(0x00, selector)\\n            mstore(0x04, and(spender, shr(96, not(0))))\\n            mstore(0x24, value)\\n            success := call(gas(), token, 0, 0x00, 0x44, 0x00, 0x20)\\n            // if call success and return is true, all is good.\\n            // otherwise (not success or return is not true), we need to perform further checks\\n            if iszero(and(success, eq(mload(0x00), 1))) {\\n                // if the call was a failure and bubble is enabled, bubble the error\\n                if and(iszero(success), bubble) {\\n                    returndatacopy(fmp, 0x00, returndatasize())\\n                    revert(fmp, returndatasize())\\n                }\\n                // if the return value is not true, then the call is only successful if:\\n                // - the token address has code\\n                // - the returndata is empty\\n                success := and(success, and(iszero(returndatasize()), gt(extcodesize(token), 0)))\\n            }\\n            mstore(0x40, fmp)\\n        }\\n    }\\n}\\n\",\"@openzeppelin/contracts/utils/Address.sol\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.5.0) (utils/Address.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {Errors} from \\\"./Errors.sol\\\";\\nimport {LowLevelCall} from \\\"./LowLevelCall.sol\\\";\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n    /**\\n     * @dev There's no code at `target` (it is not a contract).\\n     */\\n    error AddressEmptyCode(address target);\\n\\n    /**\\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n     * `recipient`, forwarding all available gas and reverting on errors.\\n     *\\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n     * imposed by `transfer`, making them unable to receive funds via\\n     * `transfer`. {sendValue} removes this limitation.\\n     *\\n     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n     *\\n     * IMPORTANT: because control is transferred to `recipient`, care must be\\n     * taken to not create reentrancy vulnerabilities. Consider using\\n     * {ReentrancyGuard} or the\\n     * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n     */\\n    function sendValue(address payable recipient, uint256 amount) internal {\\n        if (address(this).balance < amount) {\\n            revert Errors.InsufficientBalance(address(this).balance, amount);\\n        }\\n        if (LowLevelCall.callNoReturn(recipient, amount, \\\"\\\")) {\\n            // call successful, nothing to do\\n            return;\\n        } else if (LowLevelCall.returnDataSize() > 0) {\\n            LowLevelCall.bubbleRevert();\\n        } else {\\n            revert Errors.FailedCall();\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs a Solidity function call using a low level `call`. A\\n     * plain `call` is an unsafe replacement for a function call: use this\\n     * function instead.\\n     *\\n     * If `target` reverts with a revert reason or custom error, it is bubbled\\n     * up by this function (like regular Solidity function calls). However, if\\n     * the call reverted with no returned reason, this function reverts with a\\n     * {Errors.FailedCall} error.\\n     *\\n     * Returns the raw returned data. To convert to the expected return value,\\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n     *\\n     * Requirements:\\n     *\\n     * - `target` must be a contract.\\n     * - calling `target` with `data` must not revert.\\n     */\\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n        return functionCallWithValue(target, data, 0);\\n    }\\n\\n    /**\\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n     * but also transferring `value` wei to `target`.\\n     *\\n     * Requirements:\\n     *\\n     * - the calling contract must have an ETH balance of at least `value`.\\n     * - the called Solidity function must be `payable`.\\n     */\\n    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n        if (address(this).balance < value) {\\n            revert Errors.InsufficientBalance(address(this).balance, value);\\n        }\\n        bool success = LowLevelCall.callNoReturn(target, value, data);\\n        if (success && (LowLevelCall.returnDataSize() > 0 || target.code.length > 0)) {\\n            return LowLevelCall.returnData();\\n        } else if (success) {\\n            revert AddressEmptyCode(target);\\n        } else if (LowLevelCall.returnDataSize() > 0) {\\n            LowLevelCall.bubbleRevert();\\n        } else {\\n            revert Errors.FailedCall();\\n        }\\n    }\\n\\n    /**\\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n     * but performing a static call.\\n     */\\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n        bool success = LowLevelCall.staticcallNoReturn(target, data);\\n        if (success && (LowLevelCall.returnDataSize() > 0 || target.code.length > 0)) {\\n            return LowLevelCall.returnData();\\n        } else if (success) {\\n            revert AddressEmptyCode(target);\\n        } else if (LowLevelCall.returnDataSize() > 0) {\\n            LowLevelCall.bubbleRevert();\\n        } else {\\n            revert Errors.FailedCall();\\n        }\\n    }\\n\\n    /**\\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n     * but performing a delegate call.\\n     */\\n    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n        bool success = LowLevelCall.delegatecallNoReturn(target, data);\\n        if (success && (LowLevelCall.returnDataSize() > 0 || target.code.length > 0)) {\\n            return LowLevelCall.returnData();\\n        } else if (success) {\\n            revert AddressEmptyCode(target);\\n        } else if (LowLevelCall.returnDataSize() > 0) {\\n            LowLevelCall.bubbleRevert();\\n        } else {\\n            revert Errors.FailedCall();\\n        }\\n    }\\n\\n    /**\\n     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target\\n     * was not a contract or bubbling up the revert reason (falling back to {Errors.FailedCall}) in case\\n     * of an unsuccessful call.\\n     *\\n     * NOTE: This function is DEPRECATED and may be removed in the next major release.\\n     */\\n    function verifyCallResultFromTarget(\\n        address target,\\n        bool success,\\n        bytes memory returndata\\n    ) internal view returns (bytes memory) {\\n        // only check if target is a contract if the call was successful and the return data is empty\\n        // otherwise we already know that it was a contract\\n        if (success && (returndata.length > 0 || target.code.length > 0)) {\\n            return returndata;\\n        } else if (success) {\\n            revert AddressEmptyCode(target);\\n        } else if (returndata.length > 0) {\\n            LowLevelCall.bubbleRevert(returndata);\\n        } else {\\n            revert Errors.FailedCall();\\n        }\\n    }\\n\\n    /**\\n     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the\\n     * revert reason or with a default {Errors.FailedCall} error.\\n     */\\n    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {\\n        if (success) {\\n            return returndata;\\n        } else if (returndata.length > 0) {\\n            LowLevelCall.bubbleRevert(returndata);\\n        } else {\\n            revert Errors.FailedCall();\\n        }\\n    }\\n}\\n\",\"@openzeppelin/contracts/utils/Errors.sol\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Errors.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Collection of common custom errors used in multiple contracts\\n *\\n * IMPORTANT: Backwards compatibility is not guaranteed in future versions of the library.\\n * It is recommended to avoid relying on the error API for critical functionality.\\n *\\n * _Available since v5.1._\\n */\\nlibrary Errors {\\n    /**\\n     * @dev The ETH balance of the account is not enough to perform the operation.\\n     */\\n    error InsufficientBalance(uint256 balance, uint256 needed);\\n\\n    /**\\n     * @dev A call to an address target failed. The target may have reverted.\\n     */\\n    error FailedCall();\\n\\n    /**\\n     * @dev The deployment failed.\\n     */\\n    error FailedDeployment();\\n\\n    /**\\n     * @dev A necessary precompile is missing.\\n     */\\n    error MissingPrecompile(address);\\n}\\n\",\"@openzeppelin/contracts/utils/LowLevelCall.sol\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.6.0) (utils/LowLevelCall.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Library of low level call functions that implement different calling strategies to deal with the return data.\\n *\\n * WARNING: Using this library requires an advanced understanding of Solidity and how the EVM works. It is recommended\\n * to use the {Address} library instead.\\n */\\nlibrary LowLevelCall {\\n    /// @dev Performs a Solidity function call using a low level `call` and ignoring the return data.\\n    function callNoReturn(address target, bytes memory data) internal returns (bool success) {\\n        return callNoReturn(target, 0, data);\\n    }\\n\\n    /// @dev Same as {callNoReturn-address-bytes}, but allows specifying the value to be sent in the call.\\n    function callNoReturn(address target, uint256 value, bytes memory data) internal returns (bool success) {\\n        assembly (\\\"memory-safe\\\") {\\n            success := call(gas(), target, value, add(data, 0x20), mload(data), 0x00, 0x00)\\n        }\\n    }\\n\\n    /// @dev Performs a Solidity function call using a low level `call` and returns the first 64 bytes of the result\\n    /// in the scratch space of memory. Useful for functions that return a tuple with two single-word values.\\n    ///\\n    /// WARNING: Do not assume that the results are zero if `success` is false. Memory can be already allocated\\n    /// and this function doesn't zero it out.\\n    function callReturn64Bytes(\\n        address target,\\n        bytes memory data\\n    ) internal returns (bool success, bytes32 result1, bytes32 result2) {\\n        return callReturn64Bytes(target, 0, data);\\n    }\\n\\n    /// @dev Same as {callReturn64Bytes-address-bytes}, but allows specifying the value to be sent in the call.\\n    function callReturn64Bytes(\\n        address target,\\n        uint256 value,\\n        bytes memory data\\n    ) internal returns (bool success, bytes32 result1, bytes32 result2) {\\n        assembly (\\\"memory-safe\\\") {\\n            success := call(gas(), target, value, add(data, 0x20), mload(data), 0x00, 0x40)\\n            result1 := mload(0x00)\\n            result2 := mload(0x20)\\n        }\\n    }\\n\\n    /// @dev Performs a Solidity function call using a low level `staticcall` and ignoring the return data.\\n    function staticcallNoReturn(address target, bytes memory data) internal view returns (bool success) {\\n        assembly (\\\"memory-safe\\\") {\\n            success := staticcall(gas(), target, add(data, 0x20), mload(data), 0x00, 0x00)\\n        }\\n    }\\n\\n    /// @dev Performs a Solidity function call using a low level `staticcall` and returns the first 64 bytes of the result\\n    /// in the scratch space of memory. Useful for functions that return a tuple with two single-word values.\\n    ///\\n    /// WARNING: Do not assume that the results are zero if `success` is false. Memory can be already allocated\\n    /// and this function doesn't zero it out.\\n    function staticcallReturn64Bytes(\\n        address target,\\n        bytes memory data\\n    ) internal view returns (bool success, bytes32 result1, bytes32 result2) {\\n        assembly (\\\"memory-safe\\\") {\\n            success := staticcall(gas(), target, add(data, 0x20), mload(data), 0x00, 0x40)\\n            result1 := mload(0x00)\\n            result2 := mload(0x20)\\n        }\\n    }\\n\\n    /// @dev Performs a Solidity function call using a low level `delegatecall` and ignoring the return data.\\n    function delegatecallNoReturn(address target, bytes memory data) internal returns (bool success) {\\n        assembly (\\\"memory-safe\\\") {\\n            success := delegatecall(gas(), target, add(data, 0x20), mload(data), 0x00, 0x00)\\n        }\\n    }\\n\\n    /// @dev Performs a Solidity function call using a low level `delegatecall` and returns the first 64 bytes of the result\\n    /// in the scratch space of memory. Useful for functions that return a tuple with two single-word values.\\n    ///\\n    /// WARNING: Do not assume that the results are zero if `success` is false. Memory can be already allocated\\n    /// and this function doesn't zero it out.\\n    function delegatecallReturn64Bytes(\\n        address target,\\n        bytes memory data\\n    ) internal returns (bool success, bytes32 result1, bytes32 result2) {\\n        assembly (\\\"memory-safe\\\") {\\n            success := delegatecall(gas(), target, add(data, 0x20), mload(data), 0x00, 0x40)\\n            result1 := mload(0x00)\\n            result2 := mload(0x20)\\n        }\\n    }\\n\\n    /// @dev Returns the size of the return data buffer.\\n    function returnDataSize() internal pure returns (uint256 size) {\\n        assembly (\\\"memory-safe\\\") {\\n            size := returndatasize()\\n        }\\n    }\\n\\n    /// @dev Returns a buffer containing the return data from the last call.\\n    function returnData() internal pure returns (bytes memory result) {\\n        assembly (\\\"memory-safe\\\") {\\n            result := mload(0x40)\\n            mstore(result, returndatasize())\\n            returndatacopy(add(result, 0x20), 0x00, returndatasize())\\n            mstore(0x40, add(result, add(0x20, returndatasize())))\\n        }\\n    }\\n\\n    /// @dev Revert with the return data from the last call.\\n    function bubbleRevert() internal pure {\\n        assembly (\\\"memory-safe\\\") {\\n            let fmp := mload(0x40)\\n            returndatacopy(fmp, 0x00, returndatasize())\\n            revert(fmp, returndatasize())\\n        }\\n    }\\n\\n    function bubbleRevert(bytes memory returndata) internal pure {\\n        assembly (\\\"memory-safe\\\") {\\n            revert(add(returndata, 0x20), mload(returndata))\\n        }\\n    }\\n}\\n\",\"@openzeppelin/contracts/utils/StorageSlot.sol\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/StorageSlot.sol)\\n// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Library for reading and writing primitive types to specific storage slots.\\n *\\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\\n * This library helps with reading and writing to such slots without the need for inline assembly.\\n *\\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\\n *\\n * Example usage to set ERC-1967 implementation slot:\\n * ```solidity\\n * contract ERC1967 {\\n *     // Define the slot. Alternatively, use the SlotDerivation library to derive the slot.\\n *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n *\\n *     function _getImplementation() internal view returns (address) {\\n *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\\n *     }\\n *\\n *     function _setImplementation(address newImplementation) internal {\\n *         require(newImplementation.code.length > 0);\\n *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\\n *     }\\n * }\\n * ```\\n *\\n * TIP: Consider using this library along with {SlotDerivation}.\\n */\\nlibrary StorageSlot {\\n    struct AddressSlot {\\n        address value;\\n    }\\n\\n    struct BooleanSlot {\\n        bool value;\\n    }\\n\\n    struct Bytes32Slot {\\n        bytes32 value;\\n    }\\n\\n    struct Uint256Slot {\\n        uint256 value;\\n    }\\n\\n    struct Int256Slot {\\n        int256 value;\\n    }\\n\\n    struct StringSlot {\\n        string value;\\n    }\\n\\n    struct BytesSlot {\\n        bytes value;\\n    }\\n\\n    /**\\n     * @dev Returns an `AddressSlot` with member `value` located at `slot`.\\n     */\\n    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\\n        assembly (\\\"memory-safe\\\") {\\n            r.slot := slot\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns a `BooleanSlot` with member `value` located at `slot`.\\n     */\\n    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\\n        assembly (\\\"memory-safe\\\") {\\n            r.slot := slot\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns a `Bytes32Slot` with member `value` located at `slot`.\\n     */\\n    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\\n        assembly (\\\"memory-safe\\\") {\\n            r.slot := slot\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns a `Uint256Slot` with member `value` located at `slot`.\\n     */\\n    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\\n        assembly (\\\"memory-safe\\\") {\\n            r.slot := slot\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns a `Int256Slot` with member `value` located at `slot`.\\n     */\\n    function getInt256Slot(bytes32 slot) internal pure returns (Int256Slot storage r) {\\n        assembly (\\\"memory-safe\\\") {\\n            r.slot := slot\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns a `StringSlot` with member `value` located at `slot`.\\n     */\\n    function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {\\n        assembly (\\\"memory-safe\\\") {\\n            r.slot := slot\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns an `StringSlot` representation of the string storage pointer `store`.\\n     */\\n    function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {\\n        assembly (\\\"memory-safe\\\") {\\n            r.slot := store.slot\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns a `BytesSlot` with member `value` located at `slot`.\\n     */\\n    function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {\\n        assembly (\\\"memory-safe\\\") {\\n            r.slot := slot\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.\\n     */\\n    function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {\\n        assembly (\\\"memory-safe\\\") {\\n            r.slot := store.slot\\n        }\\n    }\\n}\\n\",\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\"}}","abi":"[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"AddressEmptyCode\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"ERC1967InvalidImplementation\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ERC1967NonPayable\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FailedCall\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidInitialization\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotInitializing\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"OwnableInvalidOwner\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"OwnableUnauthorizedAccount\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"UUPSUnauthorizedCallContext\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"slot\",\"type\":\"bytes32\"}],\"name\":\"UUPSUnsupportedProxiableUUID\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"BNBRescued\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"ClaimPaused\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"ClaimUnpaused\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"DepositPaused\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"DepositUnpaused\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"version\",\"type\":\"uint64\"}],\"name\":\"Initialized\",\"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\":\"uint256\",\"name\":\"planId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"apy\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"duration\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"referral\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"claimtime\",\"type\":\"uint256\"}],\"name\":\"PlanAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"planId\",\"type\":\"uint256\"}],\"name\":\"PlanEdited\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"planId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"active\",\"type\":\"bool\"}],\"name\":\"PlanStatusChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"referrer\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"referredUser\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"historyIndex\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"ReferralRewardPaid\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"user\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"historyIndex\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"RewardClaimed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"user\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"planId\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"historyIndex\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"referrer\",\"type\":\"address\"}],\"name\":\"Staked\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenAddr\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"TokensRescued\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"WithdrawPaused\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"WithdrawUnpaused\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"user\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"historyIndex\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Withdrawn\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"BPS_DENOMINATOR\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"UPGRADE_INTERFACE_VERSION\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"YEAR\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"activeorderids\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"apy\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"duration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"referral\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"claimtime\",\"type\":\"uint256\"}],\"name\":\"addPlan\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"planId\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"claimAllReward\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"claimPaused\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"historyIndex\",\"type\":\"uint256\"}],\"name\":\"claimReward\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"planId\",\"type\":\"uint256\"}],\"name\":\"claimRewardByPlan\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"depositPaused\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"planId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"apy\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"duration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"referral\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"claimtime\",\"type\":\"uint256\"}],\"name\":\"editPlan\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getActivePlans\",\"outputs\":[{\"internalType\":\"uint256[]\",\"name\":\"planIds\",\"type\":\"uint256[]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"apy\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"duration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"referral\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"claimtime\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"active\",\"type\":\"bool\"}],\"internalType\":\"struct MemeStaking.StakingPlan[]\",\"name\":\"activePlans\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getAllPlans\",\"outputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"apy\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"duration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"referral\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"claimtime\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"active\",\"type\":\"bool\"}],\"internalType\":\"struct MemeStaking.StakingPlan[]\",\"name\":\"\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"user\",\"type\":\"address\"}],\"name\":\"getDailyReward\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"totalDailyReward\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"staker\",\"type\":\"address\"}],\"name\":\"getEarliestClaimableOrder\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"orderId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nextClaimAt\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"hasActiveOrder\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_user\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"onlyview\",\"type\":\"bool\"}],\"name\":\"getPendingRewardByPlans\",\"outputs\":[{\"internalType\":\"uint256[]\",\"name\":\"totalstaked\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256[]\",\"name\":\"pendingRewards\",\"type\":\"uint256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"planId\",\"type\":\"uint256\"}],\"name\":\"getPlan\",\"outputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"apy\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"duration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"referral\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"claimtime\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"active\",\"type\":\"bool\"}],\"internalType\":\"struct MemeStaking.StakingPlan\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_user\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"onlyview\",\"type\":\"bool\"}],\"name\":\"getTotalPending\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_user\",\"type\":\"address\"}],\"name\":\"getUserActiveOrderIds\",\"outputs\":[{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"staker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"historyIndex\",\"type\":\"uint256\"}],\"name\":\"getUserHistory\",\"outputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"planId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"apy\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"starttime\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"endtime\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"totalreward\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"totalclaimed\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"claimed\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"withdrawn\",\"type\":\"bool\"}],\"internalType\":\"struct MemeStaking.UserHistory\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"staker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"referralIndex\",\"type\":\"uint256\"}],\"name\":\"getUserReferral\",\"outputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"referredUser\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"level\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"apy\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"starttime\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"endtime\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"reward\",\"type\":\"uint256\"}],\"internalType\":\"struct MemeStaking.UserReferrals\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"staker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"page\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"limit\",\"type\":\"uint256\"}],\"name\":\"getUserReferralHistory\",\"outputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"referredUser\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"level\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"apy\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"starttime\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"endtime\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"reward\",\"type\":\"uint256\"}],\"internalType\":\"struct MemeStaking.UserReferrals[]\",\"name\":\"history\",\"type\":\"tuple[]\"},{\"internalType\":\"uint256\",\"name\":\"total\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"totalPages\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"staker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"page\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"limit\",\"type\":\"uint256\"}],\"name\":\"getUserRewardHistory\",\"outputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"txId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"totalclaimed\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"time\",\"type\":\"uint256\"}],\"internalType\":\"struct MemeStaking.UserClaimHistory[]\",\"name\":\"history\",\"type\":\"tuple[]\"},{\"internalType\":\"uint256\",\"name\":\"total\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"totalPages\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"staker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"page\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"limit\",\"type\":\"uint256\"}],\"name\":\"getUserStakingHistory\",\"outputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"planId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"apy\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"starttime\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"endtime\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"totalreward\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"totalclaimed\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"claimed\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"withdrawn\",\"type\":\"bool\"}],\"internalType\":\"struct MemeStaking.UserHistory[]\",\"name\":\"history\",\"type\":\"tuple[]\"},{\"internalType\":\"uint256\",\"name\":\"total\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"totalPages\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenAddress\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"staker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"historyIndex\",\"type\":\"uint256\"}],\"name\":\"nextClaimIn\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pauseClaim\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pauseDeposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pauseWithdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"staker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"historyIndex\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"onlyview\",\"type\":\"bool\"}],\"name\":\"pendingReward\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"planCount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"plans\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"apy\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"duration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"referral\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"claimtime\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"active\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"newClaimTime\",\"type\":\"uint256\"}],\"name\":\"setClaimTimeForAllPlans\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"planId\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"active\",\"type\":\"bool\"}],\"name\":\"setPlanStatus\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenAddress\",\"type\":\"address\"}],\"name\":\"setToken\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"planId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"referrer\",\"type\":\"address\"}],\"name\":\"stake\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"token\",\"outputs\":[{\"internalType\":\"contract IERC20\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalStakedPrincipal\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalrewardclaimed\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalusers\",\"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\":[],\"name\":\"unpauseClaim\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"unpauseDeposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"unpauseWithdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_user\",\"type\":\"address\"}],\"name\":\"userReferralInfo\",\"outputs\":[{\"internalType\":\"uint256[4]\",\"name\":\"\",\"type\":\"uint256[4]\"},{\"internalType\":\"uint256[4]\",\"name\":\"\",\"type\":\"uint256[4]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"userclaimhistory\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"txId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"totalclaimed\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"time\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"userhistory\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"planId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"apy\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"starttime\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"endtime\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"totalreward\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"totalclaimed\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"claimed\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"withdrawn\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"userreferral\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"referredUser\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"level\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"apy\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"starttime\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"endtime\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"reward\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"users\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"useraddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"totalstaked\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"totalclaimed\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"totalwithdrwal\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"referrer\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"totalReferralEarned\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"historyCount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"referralCount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"totalrefcount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"level\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"claimCount\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"historyIndex\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenAddr\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdrawAnyToken\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address payable\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdrawDAN\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"withdrawPaused\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}]"},"tokens":[],"summary":{"isContract":true,"isVerified":true,"name":null,"ensName":null,"creator":"0x0fe5509cff9256f9434ec7c14d0e3389dac6ab93","creationTx":null,"publicTags":[],"hasTokens":false,"hasLogs":true,"validatedBlocks":false},"firstLast":{"last":{"hash":"0x0dbe92042c7c21a20aa479e95229bde64031fa7c8a9bd62eb73c3b3e7a95d9f1","timestamp":1788089620,"blockNumber":4927132},"first":{"hash":"0x0dbe92042c7c21a20aa479e95229bde64031fa7c8a9bd62eb73c3b3e7a95d9f1","timestamp":1788089620,"blockNumber":4927132},"fundedBy":null,"complete":true},"tab":"txs","page":1,"offset":25,"scan":{"available":true,"source":"blockscout","ok":true,"message":"OK"},"rows":[{"hash":"0x0dbe92042c7c21a20aa479e95229bde64031fa7c8a9bd62eb73c3b3e7a95d9f1","blockNumber":"4927132","timeStamp":"1788089620","from":"0x0fe5509cff9256f9434ec7c14d0e3389dac6ab93","to":"","contractAddress":"0x9924ec52902068d86bc7e8ebb646467f79cbad9b","value":"0","gas":"4344843","gasUsed":"4309474","gasPrice":"5200000000000","isError":"0","txreceipt_status":"1","input":"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","methodId":"0x60a08060","functionName":""}],"nextCursor":null}