Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

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

/**
 *Submitted for verification at monadscan.com on 2025-11-28
*/

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

// node_modules/@openzeppelin/contracts/utils/Errors.sol

// OpenZeppelin Contracts (last updated v5.1.0) (utils/Errors.sol)

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

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

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

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

// node_modules/@openzeppelin/contracts/proxy/beacon/IBeacon.sol

// OpenZeppelin Contracts (last updated v5.4.0) (proxy/beacon/IBeacon.sol)

/**
 * @dev This is the interface that {BeaconProxy} expects of its beacon.
 */
interface IBeacon {
    /**
     * @dev Must return an address that can be used as a delegate call target.
     *
     * {UpgradeableBeacon} will check that this address is a contract.
     */
    function implementation() external view returns (address);
}

// node_modules/@openzeppelin/contracts/utils/introspection/IERC165.sol

// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)

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

// node_modules/@openzeppelin/contracts/interfaces/IERC1967.sol

// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1967.sol)

/**
 * @dev ERC-1967: Proxy Storage Slots. This interface contains the events defined in the ERC.
 */
interface IERC1967 {
    /**
     * @dev Emitted when the implementation is upgraded.
     */
    event Upgraded(address indexed implementation);

    /**
     * @dev Emitted when the admin account has changed.
     */
    event AdminChanged(address previousAdmin, address newAdmin);

    /**
     * @dev Emitted when the beacon is changed.
     */
    event BeaconUpgraded(address indexed beacon);
}

// node_modules/@openzeppelin/contracts/token/ERC20/IERC20.sol

// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)

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

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

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

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

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

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

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

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

// node_modules/@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol

// OpenZeppelin Contracts (last updated v5.3.0) (proxy/utils/Initializable.sol)

/**
 * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
 * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
 * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
 * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
 *
 * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
 * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
 * case an upgrade adds a module that needs to be initialized.
 *
 * For example:
 *
 * [.hljs-theme-light.nopadding]
 * ```solidity
 * contract MyToken is ERC20Upgradeable {
 *     function initialize() initializer public {
 *         __ERC20_init("MyToken", "MTK");
 *     }
 * }
 *
 * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
 *     function initializeV2() reinitializer(2) public {
 *         __ERC20Permit_init("MyToken");
 *     }
 * }
 * ```
 *
 * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
 * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
 *
 * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
 * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
 *
 * [CAUTION]
 * ====
 * Avoid leaving a contract uninitialized.
 *
 * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
 * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
 * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
 *
 * [.hljs-theme-light.nopadding]
 * ```
 * /// @custom:oz-upgrades-unsafe-allow constructor
 * constructor() {
 *     _disableInitializers();
 * }
 * ```
 * ====
 */
abstract contract Initializable {
    /**
     * @dev Storage of the initializable contract.
     *
     * It's implemented on a custom ERC-7201 namespace to reduce the risk of storage collisions
     * when using with upgradeable contracts.
     *
     * @custom:storage-location erc7201:openzeppelin.storage.Initializable
     */
    struct InitializableStorage {
        /**
         * @dev Indicates that the contract has been initialized.
         */
        uint64 _initialized;
        /**
         * @dev Indicates that the contract is in the process of being initialized.
         */
        bool _initializing;
    }

    // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Initializable")) - 1)) & ~bytes32(uint256(0xff))
    bytes32 private constant INITIALIZABLE_STORAGE = 0xf0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00;

    /**
     * @dev The contract is already initialized.
     */
    error InvalidInitialization();

    /**
     * @dev The contract is not initializing.
     */
    error NotInitializing();

    /**
     * @dev Triggered when the contract has been initialized or reinitialized.
     */
    event Initialized(uint64 version);

    /**
     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
     * `onlyInitializing` functions can be used to initialize parent contracts.
     *
     * Similar to `reinitializer(1)`, except that in the context of a constructor an `initializer` may be invoked any
     * number of times. This behavior in the constructor can be useful during testing and is not expected to be used in
     * production.
     *
     * Emits an {Initialized} event.
     */
    modifier initializer() {
        // solhint-disable-next-line var-name-mixedcase
        InitializableStorage storage $ = _getInitializableStorage();

        // Cache values to avoid duplicated sloads
        bool isTopLevelCall = !$._initializing;
        uint64 initialized = $._initialized;

        // Allowed calls:
        // - initialSetup: the contract is not in the initializing state and no previous version was
        //                 initialized
        // - construction: the contract is initialized at version 1 (no reinitialization) and the
        //                 current contract is just being deployed
        bool initialSetup = initialized == 0 && isTopLevelCall;
        bool construction = initialized == 1 && address(this).code.length == 0;

        if (!initialSetup && !construction) {
            revert InvalidInitialization();
        }
        $._initialized = 1;
        if (isTopLevelCall) {
            $._initializing = true;
        }
        _;
        if (isTopLevelCall) {
            $._initializing = false;
            emit Initialized(1);
        }
    }

    /**
     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
     * used to initialize parent contracts.
     *
     * A reinitializer may be used after the original initialization step. This is essential to configure modules that
     * are added through upgrades and that require initialization.
     *
     * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
     * cannot be nested. If one is invoked in the context of another, execution will revert.
     *
     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
     * a contract, executing them in the right order is up to the developer or operator.
     *
     * WARNING: Setting the version to 2**64 - 1 will prevent any future reinitialization.
     *
     * Emits an {Initialized} event.
     */
    modifier reinitializer(uint64 version) {
        // solhint-disable-next-line var-name-mixedcase
        InitializableStorage storage $ = _getInitializableStorage();

        if ($._initializing || $._initialized >= version) {
            revert InvalidInitialization();
        }
        $._initialized = version;
        $._initializing = true;
        _;
        $._initializing = false;
        emit Initialized(version);
    }

    /**
     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
     * {initializer} and {reinitializer} modifiers, directly or indirectly.
     */
    modifier onlyInitializing() {
        _checkInitializing();
        _;
    }

    /**
     * @dev Reverts if the contract is not in an initializing state. See {onlyInitializing}.
     */
    function _checkInitializing() internal view virtual {
        if (!_isInitializing()) {
            revert NotInitializing();
        }
    }

    /**
     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called
     * through proxies.
     *
     * Emits an {Initialized} event the first time it is successfully executed.
     */
    function _disableInitializers() internal virtual {
        // solhint-disable-next-line var-name-mixedcase
        InitializableStorage storage $ = _getInitializableStorage();

        if ($._initializing) {
            revert InvalidInitialization();
        }
        if ($._initialized != type(uint64).max) {
            $._initialized = type(uint64).max;
            emit Initialized(type(uint64).max);
        }
    }

    /**
     * @dev Returns the highest version that has been initialized. See {reinitializer}.
     */
    function _getInitializedVersion() internal view returns (uint64) {
        return _getInitializableStorage()._initialized;
    }

    /**
     * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
     */
    function _isInitializing() internal view returns (bool) {
        return _getInitializableStorage()._initializing;
    }

    /**
     * @dev Pointer to storage slot. Allows integrators to override it with a custom storage location.
     *
     * NOTE: Consider following the ERC-7201 formula to derive storage locations.
     */
    function _initializableStorageSlot() internal pure virtual returns (bytes32) {
        return INITIALIZABLE_STORAGE;
    }

    /**
     * @dev Returns a pointer to the storage namespace.
     */
    // solhint-disable-next-line var-name-mixedcase
    function _getInitializableStorage() private pure returns (InitializableStorage storage $) {
        bytes32 slot = _initializableStorageSlot();
        assembly {
            $.slot := slot
        }
    }
}

// node_modules/@openzeppelin/contracts/utils/StorageSlot.sol

// OpenZeppelin Contracts (last updated v5.1.0) (utils/StorageSlot.sol)
// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.

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

    struct BooleanSlot {
        bool value;
    }

    struct Bytes32Slot {
        bytes32 value;
    }

    struct Uint256Slot {
        uint256 value;
    }

    struct Int256Slot {
        int256 value;
    }

    struct StringSlot {
        string value;
    }

    struct BytesSlot {
        bytes value;
    }

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

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

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

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

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

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

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

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

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

// node_modules/@openzeppelin/contracts/interfaces/draft-IERC1822.sol

// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/draft-IERC1822.sol)

/**
 * @dev ERC-1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified
 * proxy whose upgrades are fully controlled by the current implementation.
 */
interface IERC1822Proxiable {
    /**
     * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation
     * address.
     *
     * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
     * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
     * function revert if invoked through a proxy.
     */
    function proxiableUUID() external view returns (bytes32);
}

// node_modules/@openzeppelin/contracts/utils/Address.sol

// OpenZeppelin Contracts (last updated v5.4.0) (utils/Address.sol)

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

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

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

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

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

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

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

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

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

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

// node_modules/@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol

// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

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

    function __Context_init_unchained() internal onlyInitializing {
    }
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

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

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

// node_modules/@openzeppelin/contracts/interfaces/IERC165.sol

// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)

// node_modules/@openzeppelin/contracts/interfaces/IERC20.sol

// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)

// node_modules/@openzeppelin/contracts-upgradeable/utils/ReentrancyGuardUpgradeable.sol

// OpenZeppelin Contracts (last updated v5.1.0) (utils/ReentrancyGuard.sol)

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

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

    /// @custom:storage-location erc7201:openzeppelin.storage.ReentrancyGuard
    struct ReentrancyGuardStorage {
        uint256 _status;
    }

    // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.ReentrancyGuard")) - 1)) & ~bytes32(uint256(0xff))
    bytes32 private constant ReentrancyGuardStorageLocation = 0x9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00;

    function _getReentrancyGuardStorage() private pure returns (ReentrancyGuardStorage storage $) {
        assembly {
            $.slot := ReentrancyGuardStorageLocation
        }
    }

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

    function __ReentrancyGuard_init() internal onlyInitializing {
        __ReentrancyGuard_init_unchained();
    }

    function __ReentrancyGuard_init_unchained() internal onlyInitializing {
        ReentrancyGuardStorage storage $ = _getReentrancyGuardStorage();
        $._status = NOT_ENTERED;
    }

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

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

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

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

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

// node_modules/@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol

// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

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

    // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Ownable")) - 1)) & ~bytes32(uint256(0xff))
    bytes32 private constant OwnableStorageLocation = 0x9016d09d72d40fdae2fd8ceac6b6234c7706214fd39c1cd1e609a0528c199300;

    function _getOwnableStorage() private pure returns (OwnableStorage storage $) {
        assembly {
            $.slot := OwnableStorageLocation
        }
    }

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

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

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

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    function __Ownable_init(address initialOwner) internal onlyInitializing {
        __Ownable_init_unchained(initialOwner);
    }

    function __Ownable_init_unchained(address initialOwner) internal onlyInitializing {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

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

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

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

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

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

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

// node_modules/@openzeppelin/contracts-upgradeable/utils/PausableUpgradeable.sol

// OpenZeppelin Contracts (last updated v5.3.0) (utils/Pausable.sol)

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

    // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Pausable")) - 1)) & ~bytes32(uint256(0xff))
    bytes32 private constant PausableStorageLocation = 0xcd5ed15c6e187e77e9aee88184c21f4f2182ab5827cb3b7e07fbedcd63f03300;

    function _getPausableStorage() private pure returns (PausableStorage storage $) {
        assembly {
            $.slot := PausableStorageLocation
        }
    }

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

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

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

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

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

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

    function __Pausable_init() internal onlyInitializing {
    }

    function __Pausable_init_unchained() internal onlyInitializing {
    }
    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        PausableStorage storage $ = _getPausableStorage();
        return $._paused;
    }

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

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

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

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

// node_modules/@openzeppelin/contracts/interfaces/IERC1363.sol

// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)

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

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

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

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

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

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

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

// node_modules/@openzeppelin/contracts/proxy/ERC1967/ERC1967Utils.sol

// OpenZeppelin Contracts (last updated v5.4.0) (proxy/ERC1967/ERC1967Utils.sol)

/**
 * @dev This library provides getters and event emitting update functions for
 * https://eips.ethereum.org/EIPS/eip-1967[ERC-1967] slots.
 */
library ERC1967Utils {
    /**
     * @dev Storage slot with the address of the current implementation.
     * This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1.
     */
    // solhint-disable-next-line private-vars-leading-underscore
    bytes32 internal constant IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;

    /**
     * @dev The `implementation` of the proxy is invalid.
     */
    error ERC1967InvalidImplementation(address implementation);

    /**
     * @dev The `admin` of the proxy is invalid.
     */
    error ERC1967InvalidAdmin(address admin);

    /**
     * @dev The `beacon` of the proxy is invalid.
     */
    error ERC1967InvalidBeacon(address beacon);

    /**
     * @dev An upgrade function sees `msg.value > 0` that may be lost.
     */
    error ERC1967NonPayable();

    /**
     * @dev Returns the current implementation address.
     */
    function getImplementation() internal view returns (address) {
        return StorageSlot.getAddressSlot(IMPLEMENTATION_SLOT).value;
    }

    /**
     * @dev Stores a new address in the ERC-1967 implementation slot.
     */
    function _setImplementation(address newImplementation) private {
        if (newImplementation.code.length == 0) {
            revert ERC1967InvalidImplementation(newImplementation);
        }
        StorageSlot.getAddressSlot(IMPLEMENTATION_SLOT).value = newImplementation;
    }

    /**
     * @dev Performs implementation upgrade with additional setup call if data is nonempty.
     * This function is payable only if the setup call is performed, otherwise `msg.value` is rejected
     * to avoid stuck value in the contract.
     *
     * Emits an {IERC1967-Upgraded} event.
     */
    function upgradeToAndCall(address newImplementation, bytes memory data) internal {
        _setImplementation(newImplementation);
        emit IERC1967.Upgraded(newImplementation);

        if (data.length > 0) {
            Address.functionDelegateCall(newImplementation, data);
        } else {
            _checkNonPayable();
        }
    }

    /**
     * @dev Storage slot with the admin of the contract.
     * This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1.
     */
    // solhint-disable-next-line private-vars-leading-underscore
    bytes32 internal constant ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;

    /**
     * @dev Returns the current admin.
     *
     * TIP: To get this value clients can read directly from the storage slot shown below (specified by ERC-1967) using
     * the https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.
     * `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103`
     */
    function getAdmin() internal view returns (address) {
        return StorageSlot.getAddressSlot(ADMIN_SLOT).value;
    }

    /**
     * @dev Stores a new address in the ERC-1967 admin slot.
     */
    function _setAdmin(address newAdmin) private {
        if (newAdmin == address(0)) {
            revert ERC1967InvalidAdmin(address(0));
        }
        StorageSlot.getAddressSlot(ADMIN_SLOT).value = newAdmin;
    }

    /**
     * @dev Changes the admin of the proxy.
     *
     * Emits an {IERC1967-AdminChanged} event.
     */
    function changeAdmin(address newAdmin) internal {
        emit IERC1967.AdminChanged(getAdmin(), newAdmin);
        _setAdmin(newAdmin);
    }

    /**
     * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.
     * This is the keccak-256 hash of "eip1967.proxy.beacon" subtracted by 1.
     */
    // solhint-disable-next-line private-vars-leading-underscore
    bytes32 internal constant BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;

    /**
     * @dev Returns the current beacon.
     */
    function getBeacon() internal view returns (address) {
        return StorageSlot.getAddressSlot(BEACON_SLOT).value;
    }

    /**
     * @dev Stores a new beacon in the ERC-1967 beacon slot.
     */
    function _setBeacon(address newBeacon) private {
        if (newBeacon.code.length == 0) {
            revert ERC1967InvalidBeacon(newBeacon);
        }

        StorageSlot.getAddressSlot(BEACON_SLOT).value = newBeacon;

        address beaconImplementation = IBeacon(newBeacon).implementation();
        if (beaconImplementation.code.length == 0) {
            revert ERC1967InvalidImplementation(beaconImplementation);
        }
    }

    /**
     * @dev Change the beacon and trigger a setup call if data is nonempty.
     * This function is payable only if the setup call is performed, otherwise `msg.value` is rejected
     * to avoid stuck value in the contract.
     *
     * Emits an {IERC1967-BeaconUpgraded} event.
     *
     * CAUTION: Invoking this function has no effect on an instance of {BeaconProxy} since v5, since
     * it uses an immutable beacon without looking at the value of the ERC-1967 beacon slot for
     * efficiency.
     */
    function upgradeBeaconToAndCall(address newBeacon, bytes memory data) internal {
        _setBeacon(newBeacon);
        emit IERC1967.BeaconUpgraded(newBeacon);

        if (data.length > 0) {
            Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);
        } else {
            _checkNonPayable();
        }
    }

    /**
     * @dev Reverts if `msg.value` is not zero. It can be used to avoid `msg.value` stuck in the contract
     * if an upgrade doesn't perform an initialization call.
     */
    function _checkNonPayable() private {
        if (msg.value > 0) {
            revert ERC1967NonPayable();
        }
    }
}

// node_modules/@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol

// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)

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

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

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

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

    /**
     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.
     */
    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {
        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));
    }

    /**
     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.
     */
    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {
        return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value)));
    }

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

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

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

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

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

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

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

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

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

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

// node_modules/@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol

// OpenZeppelin Contracts (last updated v5.3.0) (proxy/utils/UUPSUpgradeable.sol)

/**
 * @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an
 * {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy.
 *
 * A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is
 * reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing
 * `UUPSUpgradeable` with a custom implementation of upgrades.
 *
 * The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism.
 */
abstract contract UUPSUpgradeable is Initializable, IERC1822Proxiable {
    /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
    address private immutable __self = address(this);

    /**
     * @dev The version of the upgrade interface of the contract. If this getter is missing, both `upgradeTo(address)`
     * and `upgradeToAndCall(address,bytes)` are present, and `upgradeTo` must be used if no function should be called,
     * while `upgradeToAndCall` will invoke the `receive` function if the second argument is the empty byte string.
     * If the getter returns `"5.0.0"`, only `upgradeToAndCall(address,bytes)` is present, and the second argument must
     * be the empty byte string if no function should be called, making it impossible to invoke the `receive` function
     * during an upgrade.
     */
    string public constant UPGRADE_INTERFACE_VERSION = "5.0.0";

    /**
     * @dev The call is from an unauthorized context.
     */
    error UUPSUnauthorizedCallContext();

    /**
     * @dev The storage `slot` is unsupported as a UUID.
     */
    error UUPSUnsupportedProxiableUUID(bytes32 slot);

    /**
     * @dev Check that the execution is being performed through a delegatecall call and that the execution context is
     * a proxy contract with an implementation (as defined in ERC-1967) pointing to self. This should only be the case
     * for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a
     * function through ERC-1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to
     * fail.
     */
    modifier onlyProxy() {
        _checkProxy();
        _;
    }

    /**
     * @dev Check that the execution is not being performed through a delegate call. This allows a function to be
     * callable on the implementing contract but not through proxies.
     */
    modifier notDelegated() {
        _checkNotDelegated();
        _;
    }

    function __UUPSUpgradeable_init() internal onlyInitializing {
    }

    function __UUPSUpgradeable_init_unchained() internal onlyInitializing {
    }
    /**
     * @dev Implementation of the ERC-1822 {proxiableUUID} function. This returns the storage slot used by the
     * implementation. It is used to validate the implementation's compatibility when performing an upgrade.
     *
     * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
     * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
     * function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier.
     */
    function proxiableUUID() external view virtual notDelegated returns (bytes32) {
        return ERC1967Utils.IMPLEMENTATION_SLOT;
    }

    /**
     * @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call
     * encoded in `data`.
     *
     * Calls {_authorizeUpgrade}.
     *
     * Emits an {Upgraded} event.
     *
     * @custom:oz-upgrades-unsafe-allow-reachable delegatecall
     */
    function upgradeToAndCall(address newImplementation, bytes memory data) public payable virtual onlyProxy {
        _authorizeUpgrade(newImplementation);
        _upgradeToAndCallUUPS(newImplementation, data);
    }

    /**
     * @dev Reverts if the execution is not performed via delegatecall or the execution
     * context is not of a proxy with an ERC-1967 compliant implementation pointing to self.
     */
    function _checkProxy() internal view virtual {
        if (
            address(this) == __self || // Must be called through delegatecall
            ERC1967Utils.getImplementation() != __self // Must be called through an active proxy
        ) {
            revert UUPSUnauthorizedCallContext();
        }
    }

    /**
     * @dev Reverts if the execution is performed via delegatecall.
     * See {notDelegated}.
     */
    function _checkNotDelegated() internal view virtual {
        if (address(this) != __self) {
            // Must not be called through delegatecall
            revert UUPSUnauthorizedCallContext();
        }
    }

    /**
     * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by
     * {upgradeToAndCall}.
     *
     * Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}.
     *
     * ```solidity
     * function _authorizeUpgrade(address) internal onlyOwner {}
     * ```
     */
    function _authorizeUpgrade(address newImplementation) internal virtual;

    /**
     * @dev Performs an implementation upgrade with a security check for UUPS proxies, and additional setup call.
     *
     * As a security check, {proxiableUUID} is invoked in the new implementation, and the return value
     * is expected to be the implementation slot in ERC-1967.
     *
     * Emits an {IERC1967-Upgraded} event.
     */
    function _upgradeToAndCallUUPS(address newImplementation, bytes memory data) private {
        try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {
            if (slot != ERC1967Utils.IMPLEMENTATION_SLOT) {
                revert UUPSUnsupportedProxiableUUID(slot);
            }
            ERC1967Utils.upgradeToAndCall(newImplementation, data);
        } catch {
            // The implementation is not UUPS
            revert ERC1967Utils.ERC1967InvalidImplementation(newImplementation);
        }
    }
}

// contracts/StakingVaultUpgradeable.sol

/// @title StakingVaultUpgradeable - UUPS Upgradeable Staking Contract
/// @notice 3-day unstake delay, 20% burn for emergency withdraw, 100k minimum stake
contract StakingVaultUpgradeable is 
    Initializable, 
    OwnableUpgradeable, 
    ReentrancyGuardUpgradeable, 
    PausableUpgradeable,
    UUPSUpgradeable 
{
    using SafeERC20 for IERC20;

    address public stakingToken;
    
    uint256 public totalStaked;
    uint256 public rewardPerTokenStored;
    uint256 public pendingRewards;
    
    struct UserInfo {
        uint256 stakedAmount;
        uint256 rewardPerTokenPaid;
        uint256 rewards;
        uint256 unstakeRequestTime;
        uint256 unstakeRequestAmount;
    }
    
    mapping(address => UserInfo) public userInfo;
    address[] public stakers;
    mapping(address => bool) public isStaker;
    
    uint256 public constant MIN_STAKE = 100_000 * 1e18;
    uint256 public constant UNSTAKE_DELAY = 3 days;
    uint256 public constant EARLY_PENALTY = 20;
    address public constant DEAD = 0x000000000000000000000000000000000000dEaD;
    
    event Staked(address indexed user, uint256 amount);
    event UnstakeRequested(address indexed user, uint256 amount, uint256 unlockTime);
    event UnstakeCancelled(address indexed user);
    event Unstaked(address indexed user, uint256 amount);
    event RewardsClaimed(address indexed user, uint256 amount);
    event RewardsReceived(uint256 amount);
    event EmergencyWithdraw(address indexed user, uint256 received, uint256 burned);

    /// @custom:oz-upgrades-unsafe-allow constructor
    constructor() {
        _disableInitializers();
    }

    function initialize() public initializer {
        __Ownable_init(msg.sender);
        __ReentrancyGuard_init();
        __Pausable_init();
        __UUPSUpgradeable_init();
    }

    function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}

    function setStakingToken(address _token) external onlyOwner {
        require(stakingToken == address(0), "Already set");
        stakingToken = _token;
    }

    function pause() external onlyOwner { _pause(); }
    function unpause() external onlyOwner { _unpause(); }

    function emergencyWithdrawTokens(address _token, address _to) external onlyOwner {
        IERC20(_token).safeTransfer(_to, IERC20(_token).balanceOf(address(this)));
    }

    function emergencyWithdrawMON(address _to) external onlyOwner {
        (bool s,) = _to.call{value: address(this).balance}("");
        require(s);
    }

    receive() external payable {
        if (msg.value > 0) {
            pendingRewards += msg.value;
            _updateRewards();
            emit RewardsReceived(msg.value);
        }
    }

    function _updateRewards() internal {
        if (totalStaked > 0 && pendingRewards > 0) {
            rewardPerTokenStored += (pendingRewards * 1e18) / totalStaked;
            pendingRewards = 0;
        }
    }

    function earned(address _user) public view returns (uint256) {
        UserInfo storage u = userInfo[_user];
        if (u.stakedAmount == 0) return u.rewards;
        
        uint256 rpt = rewardPerTokenStored;
        if (totalStaked > 0 && pendingRewards > 0) {
            rpt += (pendingRewards * 1e18) / totalStaked;
        }
        return u.rewards + (u.stakedAmount * (rpt - u.rewardPerTokenPaid)) / 1e18;
    }

    modifier updateReward(address _user) {
        _updateRewards();
        if (_user != address(0)) {
            userInfo[_user].rewards = earned(_user);
            userInfo[_user].rewardPerTokenPaid = rewardPerTokenStored;
        }
        _;
    }

    function stake(uint256 _amount) external nonReentrant whenNotPaused updateReward(msg.sender) {
        require(stakingToken != address(0), "Token not set");
        require(_amount >= MIN_STAKE, "Min 100k tokens");
        
        IERC20(stakingToken).safeTransferFrom(msg.sender, address(this), _amount);
        
        userInfo[msg.sender].stakedAmount += _amount;
        totalStaked += _amount;
        
        if (!isStaker[msg.sender]) {
            isStaker[msg.sender] = true;
            stakers.push(msg.sender);
        }
        
        emit Staked(msg.sender, _amount);
    }

    function requestUnstake(uint256 _amount) external nonReentrant whenNotPaused updateReward(msg.sender) {
        require(_amount > 0, "Zero amount");
        require(userInfo[msg.sender].stakedAmount >= _amount, "Not enough");
        require(userInfo[msg.sender].unstakeRequestTime == 0, "Pending request");
        
        userInfo[msg.sender].unstakeRequestTime = block.timestamp;
        userInfo[msg.sender].unstakeRequestAmount = _amount;
        
        emit UnstakeRequested(msg.sender, _amount, block.timestamp + UNSTAKE_DELAY);
    }

    function cancelUnstakeRequest() external nonReentrant {
        require(userInfo[msg.sender].unstakeRequestTime > 0, "No request");
        userInfo[msg.sender].unstakeRequestTime = 0;
        userInfo[msg.sender].unstakeRequestAmount = 0;
        emit UnstakeCancelled(msg.sender);
    }

    function completeUnstake() external nonReentrant whenNotPaused updateReward(msg.sender) {
        UserInfo storage u = userInfo[msg.sender];
        require(u.unstakeRequestTime > 0, "No request");
        require(block.timestamp >= u.unstakeRequestTime + UNSTAKE_DELAY, "Wait 3 days");
        
        uint256 amount = u.unstakeRequestAmount;
        require(u.stakedAmount >= amount, "Not enough");
        
        u.unstakeRequestTime = 0;
        u.unstakeRequestAmount = 0;
        u.stakedAmount -= amount;
        totalStaked -= amount;
        
        IERC20(stakingToken).safeTransfer(msg.sender, amount);
        emit Unstaked(msg.sender, amount);
    }

    function claimRewards() external nonReentrant updateReward(msg.sender) {
        uint256 reward = userInfo[msg.sender].rewards;
        require(reward > 0, "No rewards");
        
        userInfo[msg.sender].rewards = 0;
        (bool s,) = msg.sender.call{value: reward}("");
        require(s, "Failed");
        
        emit RewardsClaimed(msg.sender, reward);
    }

    function emergencyUnstake() external nonReentrant {
        uint256 amount = userInfo[msg.sender].stakedAmount;
        require(amount > 0, "Nothing staked");
        
        userInfo[msg.sender].stakedAmount = 0;
        userInfo[msg.sender].rewards = 0;
        userInfo[msg.sender].rewardPerTokenPaid = rewardPerTokenStored;
        userInfo[msg.sender].unstakeRequestTime = 0;
        userInfo[msg.sender].unstakeRequestAmount = 0;
        totalStaked -= amount;
        
        uint256 burn = (amount * EARLY_PENALTY) / 100;
        uint256 receive_ = amount - burn;
        
        IERC20(stakingToken).safeTransfer(DEAD, burn);
        IERC20(stakingToken).safeTransfer(msg.sender, receive_);
        
        emit EmergencyWithdraw(msg.sender, receive_, burn);
    }

    function getUserInfo(address _user) external view returns (
        uint256 stakedAmount,
        uint256 pendingReward,
        uint256 unstakeRequestTime,
        uint256 unstakeRequestAmount,
        bool canComplete,
        uint256 timeLeft
    ) {
        UserInfo storage u = userInfo[_user];
        stakedAmount = u.stakedAmount;
        pendingReward = earned(_user);
        unstakeRequestTime = u.unstakeRequestTime;
        unstakeRequestAmount = u.unstakeRequestAmount;
        
        if (u.unstakeRequestTime > 0) {
            uint256 unlock = u.unstakeRequestTime + UNSTAKE_DELAY;
            canComplete = block.timestamp >= unlock;
            timeLeft = block.timestamp >= unlock ? 0 : unlock - block.timestamp;
        }
    }

    function getStakerCount() external view returns (uint256) { return stakers.length; }
    function getRewardBalance() external view returns (uint256) { return address(this).balance; }
    
    function getVersion() external pure returns (string memory) { return "1.0.0"; }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"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":"EnforcedPause","type":"error"},{"inputs":[],"name":"ExpectedPause","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":"ReentrancyGuardReentrantCall","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":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"received","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"burned","type":"uint256"}],"name":"EmergencyWithdraw","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":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RewardsClaimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RewardsReceived","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Staked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"}],"name":"UnstakeCancelled","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":"unlockTime","type":"uint256"}],"name":"UnstakeRequested","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Unstaked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"implementation","type":"address"}],"name":"Upgraded","type":"event"},{"inputs":[],"name":"DEAD","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"EARLY_PENALTY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MIN_STAKE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"UNSTAKE_DELAY","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":"cancelUnstakeRequest","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claimRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"completeUnstake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"}],"name":"earned","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"emergencyUnstake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"}],"name":"emergencyWithdrawMON","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"address","name":"_to","type":"address"}],"name":"emergencyWithdrawTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getRewardBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getStakerCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"}],"name":"getUserInfo","outputs":[{"internalType":"uint256","name":"stakedAmount","type":"uint256"},{"internalType":"uint256","name":"pendingReward","type":"uint256"},{"internalType":"uint256","name":"unstakeRequestTime","type":"uint256"},{"internalType":"uint256","name":"unstakeRequestAmount","type":"uint256"},{"internalType":"bool","name":"canComplete","type":"bool"},{"internalType":"uint256","name":"timeLeft","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getVersion","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isStaker","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":"_amount","type":"uint256"}],"name":"requestUnstake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rewardPerTokenStored","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"setStakingToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"stake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"stakers","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stakingToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalStaked","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","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":"userInfo","outputs":[{"internalType":"uint256","name":"stakedAmount","type":"uint256"},{"internalType":"uint256","name":"rewardPerTokenPaid","type":"uint256"},{"internalType":"uint256","name":"rewards","type":"uint256"},{"internalType":"uint256","name":"unstakeRequestTime","type":"uint256"},{"internalType":"uint256","name":"unstakeRequestAmount","type":"uint256"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

68207:7977:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;70683:9;:13;70679:150;;70731:9;70713:14;;:27;;;;;;;:::i;:::-;;;;-1:-1:-1;70755:16:0;;-1:-1:-1;70755:14:0;:16::i;:::-;70791:26;;70807:9;422:25:1;;70791:26:0;;410:2:1;395:18;70791:26:0;;;;;;;70679:150;68207:7977;;;;;71069:431;;;;;;;;;;-1:-1:-1;71069:431:0;;;;;:::i;:::-;;:::i;:::-;;;422:25:1;;;410:2;395:18;71069:431:0;;;;;;;;69073:73;;;;;;;;;;;;69104:42;69073:73;;;;;-1:-1:-1;;;;;991:32:1;;;973:51;;961:2;946:18;69073:73:0;827:203:1;76102:79:0;;;;;;;;;;-1:-1:-1;76164:14:0;;;;;;;;;;;;-1:-1:-1;;;76164:14:0;;;;76102:79;;;;;;;:::i;75907:84::-;;;;;;;;;;-1:-1:-1;75974:7:0;:14;75907:84;;68779:44;;;;;;;;;;-1:-1:-1;68779:44:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1950:25:1;;;2006:2;1991:18;;1984:34;;;;2034:18;;;2027:34;;;;2092:2;2077:18;;2070:34;2135:3;2120:19;;2113:35;1937:3;1922:19;68779:44:0;1691:463:1;69024:42:0;;;;;;;;;;;;69064:2;69024:42;;70011:161;;;;;;;;;;-1:-1:-1;70011:161:0;;;;;:::i;:::-;;:::i;72389:553::-;;;;;;;;;;-1:-1:-1;72389:553:0;;;;;:::i;:::-;;:::i;73940:380::-;;;;;;;;;;;;;:::i;70235:53::-;;;;;;;;;;;;;:::i;65530:217::-;;;;;;:::i;:::-;;:::i;65063:136::-;;;;;;;;;;;;;:::i;39383:148::-;;;;;;;;;;-1:-1:-1;;;;;;;;;;;;39514:9:0;;;39383:148;;;3823:14:1;;3816:22;3798:41;;3786:2;3771:18;39383:148:0;3658:187:1;75997:93:0;;;;;;;;;;-1:-1:-1;76066:21:0;75997:93;;73251:681;;;;;;;;;;;;;:::i;75131:768::-;;;;;;;;;;-1:-1:-1;75131:768:0;;;;;:::i;:::-;;:::i;:::-;;;;4131:25:1;;;4187:2;4172:18;;4165:34;;;;4215:18;;;4208:34;;;;4273:2;4258:18;;4251:34;4329:14;4322:22;4316:3;4301:19;;4294:51;4376:3;4361:19;;4354:35;4118:3;4103:19;75131:768:0;3850:545:1;68861:40:0;;;;;;;;;;-1:-1:-1;68861:40:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;36017:103;;;;;;;;;;;;;:::i;68416:27::-;;;;;;;;;;-1:-1:-1;68416:27:0;;;;-1:-1:-1;;;;;68416:27:0;;;74328:795;;;;;;;;;;;;;:::i;69727:184::-;;;;;;;;;;;;;:::i;68456:26::-;;;;;;;;;;;;;;;;70180:49;;;;;;;;;;;;;:::i;35282:147::-;;;;;;;;;;-1:-1:-1;34113:22:0;35413:8;-1:-1:-1;;;;;35413:8:0;35282:147;;71773:608;;;;;;;;;;-1:-1:-1;71773:608:0;;;;;:::i;:::-;;:::i;63128:58::-;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;63128:58:0;;;;;72950:293;;;;;;;;;;;;;:::i;68914:50::-;;;;;;;;;;;;68950:14;68914:50;;70296:173;;;;;;;;;;-1:-1:-1;70296:173:0;;;;;:::i;:::-;;:::i;68489:35::-;;;;;;;;;;;;;;;;70477:156;;;;;;;;;;-1:-1:-1;70477:156:0;;;;;:::i;:::-;;:::i;68971:46::-;;;;;;;;;;;;69011:6;68971:46;;68531:29;;;;;;;;;;;;;;;;36275:220;;;;;;;;;;-1:-1:-1;36275:220:0;;;;;:::i;:::-;;:::i;68830:24::-;;;;;;;;;;-1:-1:-1;68830:24:0;;;;;:::i;:::-;;:::i;70844:217::-;70908:1;70894:11;;:15;:37;;;;;70930:1;70913:14;;:18;70894:37;70890:164;;;70998:11;;70973:14;;:21;;70990:4;70973:21;:::i;:::-;70972:37;;;;:::i;:::-;70948:20;;:61;;;;;;;:::i;:::-;;;;-1:-1:-1;;71041:1:0;71024:14;:18;70890:164;70844:217::o;71069:431::-;-1:-1:-1;;;;;71162:15:0;;71121:7;71162:15;;;:8;:15;;;;;71192:14;;:19;;71188:41;;71220:9;;;;71069:431;-1:-1:-1;;71069:431:0:o;71188:41::-;71264:20;;71299:11;;:15;;;;:37;;;71335:1;71318:14;;:18;71299:37;71295:114;;;71386:11;;71361:14;;:21;;71378:4;71361:21;:::i;:::-;71360:37;;;;:::i;:::-;71353:44;;;;:::i;:::-;;;71295:114;71488:4;71463:1;:20;;;71457:3;:26;;;;:::i;:::-;71439:14;;:45;;;;:::i;:::-;71438:54;;;;:::i;:::-;71426:1;:9;;;:66;;;;:::i;:::-;71419:73;71069:431;-1:-1:-1;;;;71069:431:0:o;70011:161::-;35168:13;:11;:13::i;:::-;70114:1:::1;70090:12:::0;-1:-1:-1;;;;;70090:12:0::1;:26:::0;70082:50:::1;;;::::0;-1:-1:-1;;;70082:50:0;;5395:2:1;70082:50:0::1;::::0;::::1;5377:21:1::0;5434:2;5414:18;;;5407:30;-1:-1:-1;;;5453:18:1;;;5446:41;5504:18;;70082:50:0::1;;;;;;;;;70143:12;:21:::0;;-1:-1:-1;;;;;;70143:21:0::1;-1:-1:-1::0;;;;;70143:21:0;;;::::1;::::0;;;::::1;::::0;;70011:161::o;72389:553::-;31736:21;:19;:21::i;:::-;38842:19:::1;:17;:19::i;:::-;72479:10:::2;71556:16;:14;:16::i;:::-;-1:-1:-1::0;;;;;71587:19:0;::::2;::::0;71583:163:::2;;71649:13;71656:5;71649:6;:13::i;:::-;-1:-1:-1::0;;;;;71623:15:0;::::2;;::::0;;;:8:::2;:15;::::0;;;;:23:::2;::::0;;::::2;:39:::0;;;;71714:20;;71677:34:::2;::::0;;::::2;:57:::0;71583:163:::2;72520:1:::3;72510:7;:11;72502:35;;;::::0;-1:-1:-1;;;72502:35:0;;5735:2:1;72502:35:0::3;::::0;::::3;5717:21:1::0;5774:2;5754:18;;;5747:30;-1:-1:-1;;;5793:18:1;;;5786:41;5844:18;;72502:35:0::3;5533:335:1::0;72502:35:0::3;72565:10;72556:20;::::0;;;:8:::3;:20;::::0;;;;:33;:44;-1:-1:-1;72556:44:0::3;72548:67;;;::::0;-1:-1:-1;;;72548:67:0;;6075:2:1;72548:67:0::3;::::0;::::3;6057:21:1::0;6114:2;6094:18;;;6087:30;-1:-1:-1;;;6133:18:1;;;6126:40;6183:18;;72548:67:0::3;5873:334:1::0;72548:67:0::3;72643:10;72634:20;::::0;;;:8:::3;:20;::::0;;;;:39:::3;;::::0;:44;72626:72:::3;;;::::0;-1:-1:-1;;;72626:72:0;;6414:2:1;72626:72:0::3;::::0;::::3;6396:21:1::0;6453:2;6433:18;;;6426:30;-1:-1:-1;;;6472:18:1;;;6465:45;6527:18;;72626:72:0::3;6212:339:1::0;72626:72:0::3;72728:10;72719:20;::::0;;;:8:::3;:20;::::0;;;;;;;72761:15:::3;72719:39;::::0;::::3;:57:::0;;;72787:41;::::3;:51:::0;;;72864:70:::3;::::0;72831:7;;72902:31:::3;::::0;69011:6:::3;::::0;72902:31:::3;:::i;:::-;72864:70;::::0;;6730:25:1;;;6786:2;6771:18;;6764:34;;;;6703:18;72864:70:0::3;;;;;;;;38872:1:::2;31780:20:::0;30251:1;-1:-1:-1;;;;;;;;;;;32474:23:0;32217:288;31780:20;72389:553;:::o;73940:380::-;31736:21;:19;:21::i;:::-;73999:10:::1;71556:16;:14;:16::i;:::-;-1:-1:-1::0;;;;;71587:19:0;::::1;::::0;71583:163:::1;;71649:13;71656:5;71649:6;:13::i;:::-;-1:-1:-1::0;;;;;71623:15:0;::::1;;::::0;;;:8:::1;:15;::::0;;;;:23:::1;::::0;;::::1;:39:::0;;;;71714:20;;71677:34:::1;::::0;;::::1;:57:::0;71583:163:::1;74048:10:::2;74022:14;74039:20:::0;;;:8:::2;:20;::::0;;;;:28:::2;;::::0;74086:10;74078:33:::2;;;::::0;-1:-1:-1;;;74078:33:0;;7011:2:1;74078:33:0::2;::::0;::::2;6993:21:1::0;7050:2;7030:18;;;7023:30;-1:-1:-1;;;7069:18:1;;;7062:40;7119:18;;74078:33:0::2;6809:334:1::0;74078:33:0::2;74141:10;74163:1;74132:20:::0;;;:8:::2;:20;::::0;;;;;:28:::2;;:32:::0;;;74187:34;74163:1;;74141:10;74210:6;;74163:1;74187:34;74163:1;74187:34;74210:6;74141:10;74187:34:::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;74175:46;;;74240:1;74232:20;;;::::0;-1:-1:-1;;;74232:20:0;;7560:2:1;74232:20:0::2;::::0;::::2;7542:21:1::0;7599:1;7579:18;;;7572:29;-1:-1:-1;;;7617:18:1;;;7610:36;7663:18;;74232:20:0::2;7358:329:1::0;74232:20:0::2;74278:34;::::0;422:25:1;;;74293:10:0::2;::::0;74278:34:::2;::::0;410:2:1;395:18;74278:34:0::2;;;;;;;;74011:309;;31768:1:::1;31780:20:::0;30251:1;-1:-1:-1;;;;;;;;;;;32474:23:0;32217:288;70235:53;35168:13;:11;:13::i;:::-;70275:10:::1;:8;:10::i;65530:217::-:0;63984:13;:11;:13::i;:::-;65646:36:::1;65664:17;65646;:36::i;:::-;65693:46;65715:17;65734:4;65693:21;:46::i;:::-;65530:217:::0;;:::o;65063:136::-;65132:7;64264:20;:18;:20::i;:::-;-1:-1:-1;;;;;;;;;;;;65063:136:0;:::o;73251:681::-;31736:21;:19;:21::i;:::-;38842:19:::1;:17;:19::i;:::-;73327:10:::2;71556:16;:14;:16::i;:::-;-1:-1:-1::0;;;;;71587:19:0;::::2;::::0;71583:163:::2;;71649:13;71656:5;71649:6;:13::i;:::-;-1:-1:-1::0;;;;;71623:15:0;::::2;;::::0;;;:8:::2;:15;::::0;;;;:23:::2;::::0;;::::2;:39:::0;;;;71714:20;;71677:34:::2;::::0;;::::2;:57:::0;71583:163:::2;73380:10:::3;73350:18;73371:20:::0;;;:8:::3;:20;::::0;;;;73410::::3;::::0;::::3;::::0;73402:47:::3;;;::::0;-1:-1:-1;;;73402:47:0;;7894:2:1;73402:47:0::3;::::0;::::3;7876:21:1::0;7933:2;7913:18;;;7906:30;-1:-1:-1;;;7952:18:1;;;7945:40;8002:18;;73402:47:0::3;7692:334:1::0;73402:47:0::3;69011:6;73487:1;:20;;;:36;;;;:::i;:::-;73468:15;:55;;73460:79;;;::::0;-1:-1:-1;;;73460:79:0;;8233:2:1;73460:79:0::3;::::0;::::3;8215:21:1::0;8272:2;8252:18;;;8245:30;-1:-1:-1;;;8291:18:1;;;8284:41;8342:18;;73460:79:0::3;8031:335:1::0;73460:79:0::3;73577:22;::::0;::::3;::::0;73618:14;;:24;-1:-1:-1;73618:24:0::3;73610:47;;;::::0;-1:-1:-1;;;73610:47:0;;6075:2:1;73610:47:0::3;::::0;::::3;6057:21:1::0;6114:2;6094:18;;;6087:30;-1:-1:-1;;;6133:18:1;;;6126:40;6183:18;;73610:47:0::3;5873:334:1::0;73610:47:0::3;73701:1;73678:20;::::0;::::3;:24:::0;;;73713:22:::3;::::0;::::3;:26:::0;;;73750:24;;73768:6;;73678:1;;73750:24:::3;::::0;73768:6;;73750:24:::3;:::i;:::-;;;;;;;;73800:6;73785:11;;:21;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;73834:12:0::3;::::0;73827:53:::3;::::0;-1:-1:-1;;;;;73834:12:0::3;73861:10;73873:6:::0;73827:33:::3;:53::i;:::-;73896:28;::::0;422:25:1;;;73905:10:0::3;::::0;73896:28:::3;::::0;410:2:1;395:18;73896:28:0::3;276:177:1::0;75131:768:0;-1:-1:-1;;;;;75422:15:0;;75200:20;75422:15;;;:8;:15;;;;;75463:14;;;75200:20;;;;;;;;;75504:13;75431:5;75504:6;:13::i;:::-;75549:20;;;;75603:22;;;;75488:29;;-1:-1:-1;75549:20:0;-1:-1:-1;75603:22:0;-1:-1:-1;75650:24:0;;75646:246;;75691:14;69011:6;75708:1;:20;;;:36;;;;:::i;:::-;75773:15;:25;-1:-1:-1;75773:25:0;;-1:-1:-1;75691:53:0;-1:-1:-1;75773:25:0;75824:56;;75856:24;75865:15;75856:6;:24;:::i;:::-;75824:56;;;75852:1;75824:56;75813:67;;75676:216;75646:246;75390:509;75131:768;;;;;;;:::o;36017:103::-;35168:13;:11;:13::i;:::-;36082:30:::1;36109:1;36082:18;:30::i;74328:795::-:0;31736:21;:19;:21::i;:::-;74415:10:::1;74389:14;74406:20:::0;;;:8:::1;:20;::::0;;;;:33;74458:10;74450:37:::1;;;::::0;-1:-1:-1;;;74450:37:0;;8573:2:1;74450:37:0::1;::::0;::::1;8555:21:1::0;8612:2;8592:18;;;8585:30;-1:-1:-1;;;8631:18:1;;;8624:44;8685:18;;74450:37:0::1;8371:338:1::0;74450:37:0::1;74517:10;74544:1;74508:20:::0;;;:8:::1;:20;::::0;;;;;;:37;;;74556:28:::1;::::0;;::::1;:32:::0;;;74641:20;74599:39:::1;::::0;;::::1;:62:::0;;;;74672:39:::1;::::0;::::1;:43:::0;;;74726:41;::::1;:45:::0;;;74782:21;;74797:6;;74544:1;74782:21:::1;::::0;74797:6;;74782:21:::1;:::i;:::-;::::0;;;-1:-1:-1;74824:12:0::1;::::0;-1:-1:-1;74866:3:0::1;74840:22;69064:2;74840:6:::0;:22:::1;:::i;:::-;74839:30;;;;:::i;:::-;74824:45:::0;-1:-1:-1;74880:16:0::1;74899:13;74824:45:::0;74899:6;:13:::1;:::i;:::-;74940:12;::::0;74880:32;;-1:-1:-1;74933:45:0::1;::::0;-1:-1:-1;;;;;74940:12:0::1;69104:42;74973:4:::0;74933:33:::1;:45::i;:::-;74996:12;::::0;74989:55:::1;::::0;-1:-1:-1;;;;;74996:12:0::1;75023:10;75035:8:::0;74989:33:::1;:55::i;:::-;75070:45;::::0;;6730:25:1;;;6786:2;6771:18;;6764:34;;;75088:10:0::1;::::0;75070:45:::1;::::0;6703:18:1;75070:45:0::1;6556:248:1::0;69727:184:0;10220:30;10253:26;:24;:26::i;:::-;10367:15;;10220:59;;-1:-1:-1;10367:15:0;-1:-1:-1;;;10367:15:0;;;10366:16;;10414:14;;10344:19;10797:16;;:34;;;;;10817:14;10797:34;10777:54;;10842:17;10862:11;:16;;10877:1;10862:16;:50;;;;-1:-1:-1;10890:4:0;10882:25;:30;10862:50;10842:70;;10930:12;10929:13;:30;;;;;10947:12;10946:13;10929:30;10925:93;;;10983:23;;-1:-1:-1;;;10983:23:0;;;;;;;;;;;10925:93;11028:18;;-1:-1:-1;;11028:18:0;11045:1;11028:18;;;11057:69;;;;11092:22;;-1:-1:-1;;;;11092:22:0;-1:-1:-1;;;11092:22:0;;;11057:69;69779:26:::1;69794:10;69779:14;:26::i;:::-;69816:24;:22;:24::i;:::-;69851:17;:15;:17::i;:::-;69879:24;:22;:24::i;:::-;11152:14:::0;11148:104;;;11183:23;;-1:-1:-1;;;;11183:23:0;;;11226:14;;-1:-1:-1;8867:50:1;;11226:14:0;;8855:2:1;8840:18;11226:14:0;;;;;;;11148:104;10152:1107;;;;;69727:184::o;70180:49::-;35168:13;:11;:13::i;:::-;70218:8:::1;:6;:8::i;71773:608::-:0;31736:21;:19;:21::i;:::-;38842:19:::1;:17;:19::i;:::-;71854:10:::2;71556:16;:14;:16::i;:::-;-1:-1:-1::0;;;;;71587:19:0;::::2;::::0;71583:163:::2;;71649:13;71656:5;71649:6;:13::i;:::-;-1:-1:-1::0;;;;;71623:15:0;::::2;;::::0;;;:8:::2;:15;::::0;;;;:23:::2;::::0;;::::2;:39:::0;;;;71714:20;;71677:34:::2;::::0;;::::2;:57:::0;71583:163:::2;71909:1:::3;71885:12:::0;-1:-1:-1;;;;;71885:12:0::3;71877:52;;;::::0;-1:-1:-1;;;71877:52:0;;9130:2:1;71877:52:0::3;::::0;::::3;9112:21:1::0;9169:2;9149:18;;;9142:30;-1:-1:-1;;;9188:18:1;;;9181:43;9241:18;;71877:52:0::3;8928:337:1::0;71877:52:0::3;68950:14;71948:7;:20;;71940:48;;;::::0;-1:-1:-1;;;71940:48:0;;9472:2:1;71940:48:0::3;::::0;::::3;9454:21:1::0;9511:2;9491:18;;;9484:30;-1:-1:-1;;;9530:18:1;;;9523:45;9585:18;;71940:48:0::3;9270:339:1::0;71940:48:0::3;72016:12;::::0;72009:73:::3;::::0;-1:-1:-1;;;;;72016:12:0::3;72047:10;72067:4;72074:7:::0;72009:37:::3;:73::i;:::-;72112:10;72103:20;::::0;;;:8:::3;:20;::::0;;;;:44;;72140:7;;72103:20;:44:::3;::::0;72140:7;;72103:44:::3;:::i;:::-;;;;;;;;72173:7;72158:11;;:22;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;72215:10:0::3;72206:20;::::0;;;:8:::3;:20;::::0;;;;;::::3;;72201:120;;72252:10;72243:20;::::0;;;:8:::3;:20;::::0;;;;:27;;-1:-1:-1;;72243:27:0::3;72266:4;72243:27:::0;;::::3;::::0;;;72285:7:::3;:24:::0;;;;::::3;::::0;;;;;;::::3;::::0;;-1:-1:-1;;;;;;72285:24:0::3;::::0;;::::3;::::0;;72201:120:::3;72346:27;::::0;422:25:1;;;72353:10:0::3;::::0;72346:27:::3;::::0;410:2:1;395:18;72346:27:0::3;276:177:1::0;72950:293:0;31736:21;:19;:21::i;:::-;73032:10:::1;73065:1;73023:20:::0;;;:8:::1;:20;::::0;;;;:39:::1;;::::0;73015:66:::1;;;::::0;-1:-1:-1;;;73015:66:0;;7894:2:1;73015:66:0::1;::::0;::::1;7876:21:1::0;7933:2;7913:18;;;7906:30;-1:-1:-1;;;7952:18:1;;;7945:40;8002:18;;73015:66:0::1;7692:334:1::0;73015:66:0::1;73101:10;73134:1;73092:20:::0;;;:8:::1;:20;::::0;;;;;;;:39:::1;::::0;::::1;:43:::0;;;73146:41;;::::1;:45:::0;;;73207:28;::::1;::::0;73134:1;73207:28:::1;31780:20:::0;30251:1;-1:-1:-1;;;;;;;;;;;32474:23:0;32217:288;70296:173;35168:13;:11;:13::i;:::-;70421:39:::1;::::0;-1:-1:-1;;;70421:39:0;;70454:4:::1;70421:39;::::0;::::1;973:51:1::0;70388:73:0::1;::::0;70416:3;;-1:-1:-1;;;;;70421:24:0;::::1;::::0;::::1;::::0;946:18:1;;70421:39:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;70388:27:0;::::1;::::0;:73;:27:::1;:73::i;70477:156::-:0;35168:13;:11;:13::i;:::-;70551:6:::1;70562:3;-1:-1:-1::0;;;;;70562:8:0::1;70578:21;70562:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;70550:54;;;70623:1;70615:10;;;::::0;::::1;36275:220:::0;35168:13;:11;:13::i;:::-;-1:-1:-1;;;;;36360:22:0;::::1;36356:93;;36406:31;::::0;-1:-1:-1;;;36406:31:0;;36434:1:::1;36406:31;::::0;::::1;973:51:1::0;946:18;;36406:31:0::1;827:203:1::0;36356:93:0::1;36459:28;36478:8;36459:18;:28::i;68830:24::-:0;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;68830:24:0;;-1:-1:-1;68830:24:0;:::o;35507:166::-;27776:10;35567:7;34113:22;35413:8;-1:-1:-1;;;;;35413:8:0;;35282:147;35567:7;-1:-1:-1;;;;;35567:23:0;;35563:103;;35614:40;;-1:-1:-1;;;35614:40:0;;27776:10;35614:40;;;973:51:1;946:18;;35614:40:0;827:203:1;31816:393:0;-1:-1:-1;;;;;;;;;;;32019:9:0;;-1:-1:-1;;32019:20:0;32015:90;;32063:30;;-1:-1:-1;;;32063:30:0;;;;;;;;;;;32015:90;30294:1;32182:19;;31816:393::o;39604:132::-;-1:-1:-1;;;;;;;;;;;39514:9:0;;;39666:63;;;39702:15;;-1:-1:-1;;;39702:15:0;;;;;;;;;;;32217:288;30251:1;-1:-1:-1;;;;;;;;;;;32474:23:0;32217:288::o;40408:182::-;39101:16;:14;:16::i;:::-;-1:-1:-1;;;;;;;;;;;40527:17:0;;-1:-1:-1;;40527:17:0::1;::::0;;40560:22:::1;27776:10:::0;40569:12:::1;40560:22;::::0;-1:-1:-1;;;;;991:32:1;;;973:51;;961:2;946:18;40560:22:0::1;;;;;;;40456:134;40408:182::o:0;65956:319::-;66038:4;-1:-1:-1;;;;;66047:6:0;66030:23;;;:121;;;66145:6;-1:-1:-1;;;;;66109:42:0;:32;-1:-1:-1;;;;;;;;;;;46428:53:0;-1:-1:-1;;;;;46428:53:0;;46349:140;66109:32;-1:-1:-1;;;;;66109:42:0;;;66030:121;66012:256;;;66227:29;;-1:-1:-1;;;66227:29:0;;;;;;;;;;;69919:84;35168:13;:11;:13::i;67450:548::-;67568:17;-1:-1:-1;;;;;67550:50:0;;:52;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;67550:52:0;;;;;;;;-1:-1:-1;;67550:52:0;;;;;;;;;;;;:::i;:::-;;;67546:445;;67919:60;;-1:-1:-1;;;67919:60:0;;-1:-1:-1;;;;;991:32:1;;67919:60:0;;;973:51:1;946:18;;67919:60:0;827:203:1;67546:445:0;-1:-1:-1;;;;;;;;;;;67645:40:0;;67641:122;;67713:34;;-1:-1:-1;;;67713:34:0;;;;;422:25:1;;;395:18;;67713:34:0;276:177:1;67641:122:0;67777:54;67807:17;67826:4;67777:29;:54::i;:::-;67603:240;67450:548;;:::o;66398:218::-;66473:4;-1:-1:-1;;;;;66482:6:0;66465:23;;66461:148;;66568:29;;-1:-1:-1;;;66568:29:0;;;;;;;;;;;52444:162;52554:43;;-1:-1:-1;;;;;10184:32:1;;;52554:43:0;;;10166:51:1;10233:18;;;10226:34;;;52527:71:0;;52547:5;;52569:14;;;;;10139:18:1;;52554:43:0;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;52554:43:0;;;;;;;;;;;52527:19;:71::i;36655:253::-;34113:22;36806:8;;-1:-1:-1;;;;;;36825:19:0;;-1:-1:-1;;;;;36825:19:0;;;;;;;;36860:40;;36806:8;;;;;36860:40;;36729:24;;36860:40;36718:190;;36655:253;:::o;15259:210::-;15317:30;;9180:66;15375:27;15360:42;15259:210;-1:-1:-1;;15259:210:0:o;34666:129::-;13056:20;:18;:20::i;:::-;34749:38:::1;34774:12;34749:24;:38::i;31008:113::-:0;13056:20;:18;:20::i;:::-;31079:34:::1;:32;:34::i;39145:61::-:0;13056:20;:18;:20::i;40087:180::-;38842:19;:17;:19::i;:::-;-1:-1:-1;;;;;;;;;;;40207:16:0;;-1:-1:-1;;40207:16:0::1;40219:4;40207:16;::::0;;40239:20:::1;27776:10:::0;40246:12:::1;27696:98:::0;52851:190;52979:53;;-1:-1:-1;;;;;10529:15:1;;;52979:53:0;;;10511:34:1;10581:15;;;10561:18;;;10554:43;10613:18;;;10606:34;;;52952:81:0;;52972:5;;52994:18;;;;;10446::1;;52979:53:0;10271:375:1;52952:81:0;52851:190;;;;:::o;39813:130::-;-1:-1:-1;;;;;;;;;;;39514:9:0;;;39872:64;;39909:15;;-1:-1:-1;;;39909:15:0;;;;;;;;;;;47193:353;47285:37;47304:17;47285:18;:37::i;:::-;47338:36;;-1:-1:-1;;;;;47338:36:0;;;;;;;;47391:11;;:15;47387:152;;47423:53;47452:17;47471:4;47423:28;:53::i;47387:152::-;47509:18;:16;:18::i;59735:738::-;59816:18;59845:19;59985:4;59982:1;59975:4;59969:11;59962:4;59956;59952:15;59949:1;59942:5;59935;59930:60;60044:7;60034:180;;60089:4;60083:11;60135:16;60132:1;60127:3;60112:40;60182:16;60177:3;60170:29;60034:180;-1:-1:-1;;60293:1:0;60287:8;60242:16;;-1:-1:-1;60322:15:0;;:68;;60374:11;60389:1;60374:16;;60322:68;;;-1:-1:-1;;;;;60340:26:0;;;:31;60322:68;60318:148;;;60414:40;;-1:-1:-1;;;60414:40:0;;-1:-1:-1;;;;;991:32:1;;60414:40:0;;;973:51:1;946:18;;60414:40:0;827:203:1;13216:145:0;13284:17;:15;:17::i;:::-;13279:75;;13325:17;;-1:-1:-1;;;13325:17:0;;;;;;;;;;;34803:240;13056:20;:18;:20::i;31129:186::-;13056:20;:18;:20::i;46586:286::-;46664:17;-1:-1:-1;;;;;46664:29:0;;46697:1;46664:34;46660:121;;46722:47;;-1:-1:-1;;;46722:47:0;;-1:-1:-1;;;;;991:32:1;;46722:47:0;;;973:51:1;946:18;;46722:47:0;827:203:1;46660:121:0;-1:-1:-1;;;;;;;;;;;46791:73:0;;-1:-1:-1;;;;;;46791:73:0;-1:-1:-1;;;;;46791:73:0;;;;;;;;;;46586:286::o;24693:256::-;24776:12;24802;24816:23;24843:6;-1:-1:-1;;;;;24843:19:0;24863:4;24843:25;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24801:67;;;;24886:55;24913:6;24921:7;24930:10;24886:26;:55::i;:::-;24879:62;24693:256;-1:-1:-1;;;;;24693:256:0:o;51147:126::-;51198:9;:13;51194:72;;51235:19;;-1:-1:-1;;;51235:19:0;;;;;;;;;;;14656:122;14706:4;14730:26;:24;:26::i;:::-;:40;-1:-1:-1;;;14730:40:0;;;;;;-1:-1:-1;14656:122:0:o;25224:597::-;25372:12;25402:7;25397:417;;25426:19;25434:10;25426:7;:19::i;:::-;25397:417;;;25654:17;;:22;:49;;;;-1:-1:-1;;;;;;25680:18:0;;;:23;25654:49;25650:121;;;25731:24;;-1:-1:-1;;;25731:24:0;;-1:-1:-1;;;;;991:32:1;;25731:24:0;;;973:51:1;946:18;;25731:24:0;827:203:1;25650:121:0;-1:-1:-1;25792:10:0;25397:417;25224:597;;;;;:::o;26378:444::-;26511:17;;:21;26507:308;;26718:10;26712:17;26705:4;26693:10;26689:21;26682:48;26507:308;26784:19;;-1:-1:-1;;;26784:19:0;;;;;;;;;;;14:127:1;75:10;70:3;66:20;63:1;56:31;106:4;103:1;96:15;130:4;127:1;120:15;146:125;211:9;;;232:10;;;229:36;;;245:18;;:::i;458:173::-;526:20;;-1:-1:-1;;;;;575:31:1;;565:42;;555:70;;621:1;618;611:12;555:70;458:173;;;:::o;636:186::-;695:6;748:2;736:9;727:7;723:23;719:32;716:52;;;764:1;761;754:12;716:52;787:29;806:9;787:29;:::i;1035:250::-;1120:1;1130:113;1144:6;1141:1;1138:13;1130:113;;;1220:11;;;1214:18;1201:11;;;1194:39;1166:2;1159:10;1130:113;;;-1:-1:-1;;1277:1:1;1259:16;;1252:27;1035:250::o;1290:396::-;1439:2;1428:9;1421:21;1402:4;1471:6;1465:13;1514:6;1509:2;1498:9;1494:18;1487:34;1530:79;1602:6;1597:2;1586:9;1582:18;1577:2;1569:6;1565:15;1530:79;:::i;:::-;1670:2;1649:15;-1:-1:-1;;1645:29:1;1630:45;;;;1677:2;1626:54;;1290:396;-1:-1:-1;;1290:396:1:o;2159:180::-;2218:6;2271:2;2259:9;2250:7;2246:23;2242:32;2239:52;;;2287:1;2284;2277:12;2239:52;-1:-1:-1;2310:23:1;;2159:180;-1:-1:-1;2159:180:1:o;2344:127::-;2405:10;2400:3;2396:20;2393:1;2386:31;2436:4;2433:1;2426:15;2460:4;2457:1;2450:15;2476:995;2553:6;2561;2614:2;2602:9;2593:7;2589:23;2585:32;2582:52;;;2630:1;2627;2620:12;2582:52;2653:29;2672:9;2653:29;:::i;:::-;2643:39;;2733:2;2722:9;2718:18;2705:32;2756:18;2797:2;2789:6;2786:14;2783:34;;;2813:1;2810;2803:12;2783:34;2851:6;2840:9;2836:22;2826:32;;2896:7;2889:4;2885:2;2881:13;2877:27;2867:55;;2918:1;2915;2908:12;2867:55;2954:2;2941:16;2976:2;2972;2969:10;2966:36;;;2982:18;;:::i;:::-;3057:2;3051:9;3025:2;3111:13;;-1:-1:-1;;3107:22:1;;;3131:2;3103:31;3099:40;3087:53;;;3155:18;;;3175:22;;;3152:46;3149:72;;;3201:18;;:::i;:::-;3241:10;3237:2;3230:22;3276:2;3268:6;3261:18;3316:7;3311:2;3306;3302;3298:11;3294:20;3291:33;3288:53;;;3337:1;3334;3327:12;3288:53;3393:2;3388;3384;3380:11;3375:2;3367:6;3363:15;3350:46;3438:1;3433:2;3428;3420:6;3416:15;3412:24;3405:35;3459:6;3449:16;;;;;;;2476:995;;;;;:::o;4400:260::-;4468:6;4476;4529:2;4517:9;4508:7;4504:23;4500:32;4497:52;;;4545:1;4542;4535:12;4497:52;4568:29;4587:9;4568:29;:::i;:::-;4558:39;;4616:38;4650:2;4639:9;4635:18;4616:38;:::i;:::-;4606:48;;4400:260;;;;;:::o;4665:168::-;4738:9;;;4769;;4786:15;;;4780:22;;4766:37;4756:71;;4807:18;;:::i;4838:217::-;4878:1;4904;4894:132;;4948:10;4943:3;4939:20;4936:1;4929:31;4983:4;4980:1;4973:15;5011:4;5008:1;5001:15;4894:132;-1:-1:-1;5040:9:1;;4838:217::o;5060:128::-;5127:9;;;5148:11;;;5145:37;;;5162:18;;:::i;9614:184::-;9684:6;9737:2;9725:9;9716:7;9712:23;9708:32;9705:52;;;9753:1;9750;9743:12;9705:52;-1:-1:-1;9776:16:1;;9614:184;-1:-1:-1;9614:184:1:o;10651:287::-;10780:3;10818:6;10812:13;10834:66;10893:6;10888:3;10881:4;10873:6;10869:17;10834:66;:::i;:::-;10916:16;;;;;10651:287;-1:-1:-1;;10651:287:1:o

ipfs://5e601679dc13bfde545ba37958fb188eec3d8a3eedbebb55677720fe536a87a1