{"address":"0xad5cb06f30b57218d0612fa99e128a19fdd022de","latest":5070252,"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":12360,"isContract":true,"contract":{"verified":true,"name":"StakeHub","compiler":"v0.8.28+commit.7893614a","optimization":true,"runs":200,"license":"none","proxy":false,"implementation":null,"sourceCode":"{\"sources\":{\"contracts/StakeHub.sol\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.28;\\n\\nimport \\\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.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\\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\\ninterface IERC20 {\\n    function totalSupply() external view returns (uint256);\\n    function balanceOf(address account) external view returns (uint256);\\n    function mint(address to, uint256 amount) external;\\n    function transfer(address to, uint256 value) external returns (bool);\\n    function burn(address from, uint256 amount) external;\\n}\\n\\ncontract StakeHub is\\n    Initializable,\\n    ReentrancyGuardUpgradeable,\\n    OwnableUpgradeable,\\n    UUPSUpgradeable\\n{\\n    // ============ CONSTANTS ============\\n    uint256 public constant PRECISION = 1e18;\\n    uint256 public constant YEAR = 365 days;\\n    uint256 public constant APY_DIVISOR = 100;\\n\\n    // ============ STATE VARIABLES ============\\n    uint256 public MINIMUM_STAKE;\\n    uint256 public MINIMUM_LOCK;\\n    uint256 public APY_PERCENTAGE;\\n    uint256 public CLAIM_COOLDOWN;\\n    uint256 public BLOCK_CLAIM_COOLDOWN;\\n    uint256 public TOTAL_USERS;\\n\\n    uint256 public totalStaked;\\n    uint256 public accRewardPerShare;\\n    uint256 public apyReserve;\\n    uint256 public totalusers;\\n\\n    IERC20 public stToken;\\n    address public validatorFeeCollector;\\n    address public treasurywallet;\\n    uint256 public treasuryfees;\\n\\n    bool public isStakePaused;\\n    bool public isUnstakePaused;\\n    bool public isClaimPaused;\\n    bool public isBlockClaimPaused;\\n\\n    struct User {\\n        uint256 stDan;\\n        uint256 rewardDebt;\\n        uint256 pending; // block rewards\\n        uint256 apyPending; // APY rewards (separate tracking)\\n        uint256 principal;\\n        uint256 stakeTime;\\n        uint256 lastClaimTime;\\n        uint256 totalapyclaimed;\\n        uint256 totalblockclaimed;\\n        uint256 lastBlockClaimTime;\\n    }\\n\\n    mapping(address => User) public users;\\n\\n    // ============ EVENTS ============\\n    event Staked(\\n        address indexed user,\\n        uint256 amount,\\n        uint256 stDan,\\n        uint256 time\\n    );\\n    event Unstaked(\\n        address indexed user,\\n        uint256 amount,\\n        uint256 stDan,\\n        uint256 time\\n    );\\n    event Claimed(\\n        address indexed user,\\n        uint256 blockReward,\\n        uint256 apyReward,\\n        uint256 time\\n    );\\n    event RewardsDeposited(\\n        uint256 totalAmount,\\n        uint256 distributedToStakers,\\n        uint256 treasuryAmount,\\n        uint256 time\\n    );\\n    event APYFunded(uint256 amount, uint256 time);\\n    event ERC20Withdrawn(\\n        address indexed token,\\n        address indexed to,\\n        uint256 amount,\\n        uint256 time\\n    );\\n    event DANWithdrawn(address indexed to, uint256 amount, uint256 time);\\n    event StakingTokenUpdated(address indexed newToken, uint256 time);\\n\\n\\n    // ============ INITIALIZER ============\\n    function initialize(\\n        address _stDan,\\n        address _validatorFeeCollector\\n    ) public initializer {\\n        require(_stDan != address(0), \\\"invalid staking token address\\\");\\n\\n        __ReentrancyGuard_init();\\n        __Ownable_init(msg.sender);\\n\\n        stToken = IERC20(_stDan);\\n        validatorFeeCollector = _validatorFeeCollector;\\n\\n        // Initialize state variables with default values\\n        MINIMUM_STAKE = 1000000 ether;\\n        MINIMUM_LOCK = 7 days;\\n        APY_PERCENTAGE = 600; // 6%\\n        CLAIM_COOLDOWN = 7 days;\\n        BLOCK_CLAIM_COOLDOWN = 7 days;\\n        TOTAL_USERS = 100;\\n        treasuryfees = 1000; //10%\\n        treasurywallet = 0x3435d20738487C21F24063A4851ff2c6Ba20218b;\\n    }\\n\\n    modifier onlyValidatorFeeCollector() {\\n        require(\\n            msg.sender == validatorFeeCollector,\\n            \\\"caller is not validator fee collector\\\"\\n        );\\n        _;\\n    }\\n\\n    modifier onlyWhenStakeNotPaused() {\\n        require(!isStakePaused, \\\"Staking is paused\\\");\\n        _;\\n    }\\n\\n    modifier onlyWhenUnstakeNotPaused() {\\n        require(!isUnstakePaused, \\\"Unstaking is paused\\\");\\n        _;\\n    }\\n\\n    modifier onlyWhenClaimNotPaused() {\\n        require(!isClaimPaused, \\\"Claiming is paused\\\");\\n        _;\\n    }\\n\\n    modifier onlyWhenBlockClaimNotPaused() {\\n        require(!isBlockClaimPaused, \\\"Claiming is paused\\\");\\n        _;\\n    }\\n\\n    // ============ UPGRADE AUTHORIZATION ============\\n    function _authorizeUpgrade(\\n        address newImplementation\\n    ) internal override onlyOwner {}\\n\\n    // ============ INTERNAL FUNCTIONS ============\\n\\n    function _update(address userAddr, bool _isapy, bool _isblock) internal {\\n        User storage u = users[userAddr];\\n\\n        // ===== block Rewards (can always be claimed) =====\\n        if (u.stDan > 0 && _isblock ) {\\n            uint256 accumulated = (u.stDan * accRewardPerShare) / PRECISION;\\n            uint256 pendingReward = accumulated > u.rewardDebt\\n                ? accumulated - u.rewardDebt\\n                : 0;\\n\\n            if (pendingReward > 0) {\\n                u.pending += pendingReward;\\n                u.lastBlockClaimTime = block.timestamp;\\n            }\\n\\n            u.rewardDebt = (u.stDan * accRewardPerShare) / PRECISION;\\n        }\\n\\n        // ===== APY Rewards (accumulates but requires reserve to claim) =====\\n        if (u.principal > 0 && u.lastClaimTime > 0 && _isapy) {\\n            uint256 timeElapsed = block.timestamp - u.lastClaimTime;\\n            uint256 apyReward = (u.principal * APY_PERCENTAGE * timeElapsed) /\\n                (100 * APY_DIVISOR * YEAR);\\n\\n            // Always accumulate APY - don't lose it\\n            if (apyReward > 0) {\\n                u.apyPending += apyReward;\\n                u.lastClaimTime = block.timestamp;\\n            }\\n            \\n        }\\n    }\\n\\n    // ============ STAKING FUNCTIONS ============\\n\\n    function stake() external payable nonReentrant onlyWhenStakeNotPaused {\\n        require(\\n            msg.value >= MINIMUM_STAKE,\\n            \\\"stake amount must be at least minimum stake\\\"\\n        );\\n        require(\\n            totalusers + 1 <= TOTAL_USERS,\\n            \\\"DanStakeHub:Maximum number of stakers limit reached\\\"\\n        );\\n\\n        User storage u = users[msg.sender];\\n        require(\\n            u.stDan == 0,\\n            \\\"User already staked, can not create more stakes!\\\"\\n        );\\n\\n        _update(msg.sender , true , true);\\n\\n        uint256 stDan;\\n        uint256 supply = stToken.totalSupply();\\n\\n        if (supply == 0) {\\n            stDan = msg.value;\\n        } else {\\n            stDan = (msg.value * supply) / totalStaked;\\n        }\\n\\n        u.stDan += stDan;\\n        u.principal += msg.value;\\n        totalStaked += msg.value;\\n\\n        if (u.stakeTime == 0) {\\n            u.stakeTime = block.timestamp;\\n        }\\n\\n        if (u.lastClaimTime == 0) {\\n            u.lastClaimTime = block.timestamp;\\n        }\\n\\n        stToken.mint(msg.sender, stDan);\\n\\n        u.rewardDebt = (u.stDan * accRewardPerShare) / PRECISION;\\n        totalusers += 1;\\n\\n        emit Staked(msg.sender, msg.value, stDan, block.timestamp);\\n    }\\n\\n    function claimApyReward() external nonReentrant onlyWhenClaimNotPaused {\\n        User storage u = users[msg.sender];\\n\\n        require(\\n            block.timestamp >= u.lastClaimTime + CLAIM_COOLDOWN,\\n            \\\"claim cooldown period has not elapsed\\\"\\n        );\\n\\n        _update(msg.sender , true , false);\\n\\n        uint256 apyReward = u.apyPending;\\n        \\n\\n        require(apyReward > 0, \\\"no pending rewards available to claim\\\");\\n\\n        // block rewards can always be claimed (from validator fees)\\n        // APY rewards require sufficient reserve funding\\n        if (apyReward > 0) {\\n            require(\\n                apyReward <= apyReserve,\\n                \\\"insufficient APY reserve - wait for admin to fund rewards\\\"\\n            );\\n            apyReserve -= apyReward;\\n        }\\n\\n        require(\\n            address(this).balance >= apyReward,\\n            \\\"insufficient contract balance for rewards\\\"\\n        );\\n\\n        \\n        u.apyPending = 0;\\n        u.totalapyclaimed += apyReward;\\n        \\n\\n        (bool ok, ) = msg.sender.call{value: apyReward}(\\\"\\\");\\n        require(ok, \\\"reward transfer failed\\\");\\n\\n        emit Claimed(msg.sender, 0 , apyReward, block.timestamp);\\n    }\\n\\n\\n    function claimBlockReward() external nonReentrant onlyWhenBlockClaimNotPaused {\\n        User storage u = users[msg.sender];\\n\\n        require(block.timestamp >= u.lastBlockClaimTime + BLOCK_CLAIM_COOLDOWN,\\\"claim cooldown period has not elapsed\\\");\\n\\n        _update(msg.sender , false , true);\\n        \\n        uint256 blockReward = u.pending;\\n        \\n\\n        require(blockReward > 0, \\\"no pending rewards available to claim\\\");\\n\\n        require(\\n            address(this).balance >= blockReward,\\n            \\\"insufficient contract balance for rewards\\\"\\n        );\\n\\n        u.pending = 0;\\n        u.totalblockclaimed += blockReward;\\n\\n        (bool ok, ) = msg.sender.call{value: blockReward}(\\\"\\\");\\n        require(ok, \\\"reward transfer failed\\\");\\n\\n        emit Claimed(msg.sender, blockReward, 0, block.timestamp);\\n    }\\n\\n    function unstake() external nonReentrant onlyWhenUnstakeNotPaused {\\n        User storage u = users[msg.sender];\\n        uint256 stDanAmount = u.stDan;\\n\\n        require(stDanAmount > 0, \\\"unstake amount must be greater than zero\\\");\\n        require(\\n            block.timestamp >= u.stakeTime + MINIMUM_LOCK,\\n            \\\"minimum lock period has not elapsed\\\"\\n        );\\n\\n        // Accumulate any remaining rewards before removing stake\\n        _update(msg.sender , true , true);\\n\\n        uint256 danAmount = u.principal;\\n\\n        // Update state before external call\\n        u.stDan = 0;\\n        totalStaked -= danAmount;\\n\\n        stToken.burn(msg.sender, stDanAmount);\\n\\n        totalusers -= 1;\\n\\n        u.principal = 0;\\n        u.rewardDebt = 0;\\n        \\n\\n        (bool ok, ) = msg.sender.call{value: danAmount}(\\\"\\\");\\n        require(ok, \\\"unstaking transfer failed\\\");\\n\\n        emit Unstaked(msg.sender, danAmount, stDanAmount, block.timestamp);\\n    }\\n\\n    // ============ REWARD DISTRIBUTION FUNCTIONS ============\\n\\n    function validatorFeeDistribution() external payable nonReentrant onlyValidatorFeeCollector {\\n        require(msg.value > 0, \\\"fee amount must be greater than zero\\\");\\n        require(\\n            stToken.totalSupply() > 0,\\n            \\\"no stakers available for fee distribution\\\"\\n        );\\n        require(treasurywallet != address(0), \\\"invalid treasury wallet\\\");\\n\\n        uint256 totalAmount = msg.value;\\n        uint256 treasuryAmount = (totalAmount * treasuryfees) / (APY_DIVISOR * 100);\\n\\n        // Remaining amount distributed to stakers\\n        uint256 distributedAmount = totalAmount - treasuryAmount;\\n\\n        // Send treasury fee to admin wallet\\n        if (treasuryAmount > 0) {\\n            (bool success, ) = payable(treasurywallet).call{\\n                value: treasuryAmount\\n            }(\\\"\\\");\\n            require(success, \\\"treasury transfer failed\\\");\\n        }\\n\\n        // Distribute remaining amount to stakers\\n        accRewardPerShare +=\\n            (distributedAmount * PRECISION) /\\n            stToken.totalSupply();\\n\\n        emit RewardsDeposited(\\n            totalAmount,\\n            distributedAmount,\\n            treasuryAmount,\\n            block.timestamp\\n        );\\n    }\\n\\n    function fundAPY() public payable {\\n        require(msg.value > 0, \\\"APY fund amount must be greater than zero\\\");\\n        apyReserve += msg.value;\\n        emit APYFunded(msg.value, block.timestamp);\\n    }\\n\\n    // ============ VIEW FUNCTIONS ============\\n\\n    function pendingRewards(address userAddr) external view returns (uint256 blockreward, uint256 apyReward, uint256 total, bool canclaim, bool canblockclaim){\\n        User memory u = users[userAddr];\\n        // block rewards\\n        uint256 accumulated = (u.stDan * accRewardPerShare) / PRECISION;\\n        uint256 pendingblock = accumulated > u.rewardDebt ? accumulated - u.rewardDebt : 0;\\n        blockreward = u.pending + pendingblock;\\n\\n        // APY rewards\\n        apyReward = u.apyPending;\\n        if (u.principal > 0 && u.lastClaimTime > 0) {\\n            uint256 timeElapsed = block.timestamp - u.lastClaimTime;\\n            apyReward += (u.principal * APY_PERCENTAGE * timeElapsed) / (100 * APY_DIVISOR * YEAR);\\n        }\\n\\n        total = blockreward + apyReward;\\n        canclaim = apyReward > 0 && block.timestamp >= u.lastClaimTime + CLAIM_COOLDOWN;\\n        canblockclaim = blockreward > 0 && block.timestamp >= u.lastClaimTime + BLOCK_CLAIM_COOLDOWN;\\n    }\\n\\n    // ============ ADMIN FUNCTIONS ============\\n\\n    function setMinimumStake(uint256 _new) external onlyOwner {\\n        MINIMUM_STAKE = _new;\\n    }\\n\\n    function setMinimumLock(uint256 _new) external onlyOwner {\\n        MINIMUM_LOCK = _new;\\n    }\\n\\n    function setTotalUsersLimit(uint256 _totalusers) external onlyOwner {\\n        TOTAL_USERS = _totalusers;\\n    }\\n\\n    function setAPY(uint256 _new) external onlyOwner {\\n        APY_PERCENTAGE = _new;\\n    }\\n\\n    function setStakepaused(bool _stakepaused) external onlyOwner {\\n        isStakePaused = _stakepaused;\\n    }\\n\\n    function setUnstakepaused(bool _unstakepaused) external onlyOwner {\\n        isUnstakePaused = _unstakepaused;\\n    }\\n\\n    function setClaimpaused(bool _claimpaused) external onlyOwner {\\n        isClaimPaused = _claimpaused;\\n    }\\n\\n    function setBlockClaimpaused(bool _blockclaimpaused) external onlyOwner {\\n        isBlockClaimPaused = _blockclaimpaused;\\n    }\\n\\n    function setClaimCooldown(uint256 _new) external onlyOwner {\\n        CLAIM_COOLDOWN = _new;\\n    }\\n\\n    function setBlockClaimCooldown(uint256 _blocknew) external onlyOwner {\\n        BLOCK_CLAIM_COOLDOWN = _blocknew;\\n    }\\n\\n    function setTreasurywallet(address _newwallet) external onlyOwner {\\n        treasurywallet = _newwallet;\\n    }\\n\\n    function setTreasuryfeesPer(uint256 _feesper) external onlyOwner {\\n        treasuryfees = _feesper;\\n    }\\n\\n    function setStakingToken(address _sttoken) external onlyOwner {\\n        require(_sttoken != address(0), \\\"invalid staking token address\\\");\\n        stToken = IERC20(_sttoken);\\n        emit StakingTokenUpdated(_sttoken, block.timestamp);\\n    }\\n\\n    function withdrawDAN(address to, uint256 amount) external onlyOwner {\\n        require(to != address(0), \\\"recipient address cannot be zero\\\");\\n        require(amount > 0, \\\"withdrawal amount must be greater than zero\\\");\\n\\n        (bool ok, ) = to.call{value: amount}(\\\"\\\");\\n        require(ok, \\\"DAN withdrawal transfer failed\\\");\\n\\n        emit DANWithdrawn(to, amount, block.timestamp);\\n    }\\n\\n    function withdrawERC20(\\n        address token,\\n        address to,\\n        uint256 amount\\n    ) external onlyOwner {\\n        require(token != address(0), \\\"invalid token address\\\");\\n        require(to != address(0), \\\"recipient address cannot be zero\\\");\\n        require(amount > 0, \\\"withdrawal amount must be greater than zero\\\");\\n\\n        bool success = IERC20(token).transfer(to, amount);\\n        require(success, \\\"ERC20 withdrawal transfer failed\\\");\\n\\n        emit ERC20Withdrawn(token, to, amount, block.timestamp);\\n    }\\n\\n    function setValidatorFeeCollector(\\n        address _validatorFeesAddress\\n    ) external onlyOwner {\\n        require(\\n            _validatorFeesAddress != address(0),\\n            \\\"invalid validator fee collector address\\\"\\n        );\\n        validatorFeeCollector = _validatorFeesAddress;\\n    }\\n\\n    receive() external payable {\\n        if (msg.value > 0) {\\n            fundAPY();\\n        }\\n    }\\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/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/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/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\"}}","abi":"[{\"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\":[],\"name\":\"UUPSUnauthorizedCallContext\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"slot\",\"type\":\"bytes32\"}],\"name\":\"UUPSUnsupportedProxiableUUID\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"time\",\"type\":\"uint256\"}],\"name\":\"APYFunded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"user\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"blockReward\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"apyReward\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"time\",\"type\":\"uint256\"}],\"name\":\"Claimed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"time\",\"type\":\"uint256\"}],\"name\":\"DANWithdrawn\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"time\",\"type\":\"uint256\"}],\"name\":\"ERC20Withdrawn\",\"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\":false,\"internalType\":\"uint256\",\"name\":\"totalAmount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"distributedToStakers\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"treasuryAmount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"time\",\"type\":\"uint256\"}],\"name\":\"RewardsDeposited\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"user\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"stDan\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"time\",\"type\":\"uint256\"}],\"name\":\"Staked\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newToken\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"time\",\"type\":\"uint256\"}],\"name\":\"StakingTokenUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"user\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"stDan\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"time\",\"type\":\"uint256\"}],\"name\":\"Unstaked\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"APY_DIVISOR\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"APY_PERCENTAGE\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"BLOCK_CLAIM_COOLDOWN\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"CLAIM_COOLDOWN\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"MINIMUM_LOCK\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"MINIMUM_STAKE\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"PRECISION\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"TOTAL_USERS\",\"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\":[],\"name\":\"accRewardPerShare\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"apyReserve\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"claimApyReward\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"claimBlockReward\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"fundAPY\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_stDan\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_validatorFeeCollector\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"isBlockClaimPaused\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"isClaimPaused\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"isStakePaused\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"isUnstakePaused\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"userAddr\",\"type\":\"address\"}],\"name\":\"pendingRewards\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"blockreward\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"apyReward\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"total\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"canclaim\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"canblockclaim\",\"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\":\"_new\",\"type\":\"uint256\"}],\"name\":\"setAPY\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_blocknew\",\"type\":\"uint256\"}],\"name\":\"setBlockClaimCooldown\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"_blockclaimpaused\",\"type\":\"bool\"}],\"name\":\"setBlockClaimpaused\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_new\",\"type\":\"uint256\"}],\"name\":\"setClaimCooldown\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"_claimpaused\",\"type\":\"bool\"}],\"name\":\"setClaimpaused\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_new\",\"type\":\"uint256\"}],\"name\":\"setMinimumLock\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_new\",\"type\":\"uint256\"}],\"name\":\"setMinimumStake\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"_stakepaused\",\"type\":\"bool\"}],\"name\":\"setStakepaused\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_sttoken\",\"type\":\"address\"}],\"name\":\"setStakingToken\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_totalusers\",\"type\":\"uint256\"}],\"name\":\"setTotalUsersLimit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_feesper\",\"type\":\"uint256\"}],\"name\":\"setTreasuryfeesPer\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_newwallet\",\"type\":\"address\"}],\"name\":\"setTreasurywallet\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"_unstakepaused\",\"type\":\"bool\"}],\"name\":\"setUnstakepaused\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_validatorFeesAddress\",\"type\":\"address\"}],\"name\":\"setValidatorFeeCollector\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"stToken\",\"outputs\":[{\"internalType\":\"contract IERC20\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"stake\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalStaked\",\"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\":\"treasuryfees\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"treasurywallet\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"unstake\",\"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\":\"\",\"type\":\"address\"}],\"name\":\"users\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"stDan\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"rewardDebt\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"pending\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"apyPending\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"principal\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"stakeTime\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"lastClaimTime\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"totalapyclaimed\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"totalblockclaimed\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"lastBlockClaimTime\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"validatorFeeCollector\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"validatorFeeDistribution\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdrawDAN\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdrawERC20\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}]"},"tokens":[],"summary":{"isContract":true,"isVerified":true,"name":null,"ensName":null,"creator":"0xad5292d3d35f57cc0d7876cfd7b583dc99637b0d","creationTx":null,"publicTags":[],"hasTokens":false,"hasLogs":false,"validatedBlocks":false},"firstLast":{"last":{"hash":"0x5bd9936b5aff9469d58f0c45ffd1f417bd06efb7319c0eaab327ba789306b94c","timestamp":1779202291,"blockNumber":485781},"first":{"hash":"0x5bd9936b5aff9469d58f0c45ffd1f417bd06efb7319c0eaab327ba789306b94c","timestamp":1779202291,"blockNumber":485781},"fundedBy":null,"complete":true},"tab":"txs","page":1,"offset":25,"scan":{"available":true,"source":"blockscout","ok":true,"message":"OK"},"rows":[{"hash":"0x5bd9936b5aff9469d58f0c45ffd1f417bd06efb7319c0eaab327ba789306b94c","blockNumber":"485781","timeStamp":"1779202291","from":"0xad5292d3d35f57cc0d7876cfd7b583dc99637b0d","to":"","contractAddress":"0xad5cb06f30b57218d0612fa99e128a19fdd022de","value":"0","gas":"2744050","gasUsed":"2721285","gasPrice":"4600000000000","isError":"0","txreceipt_status":"1","input":"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","methodId":"0x60a06040","functionName":""}],"nextCursor":null}