Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT

pragma solidity 0.8.28;

import "./libraries/FixedMath.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20WrapperUpgradeable.sol";

contract RewardPoolV2 is ERC20WrapperUpgradeable, OwnableUpgradeable {
    using FixedMath for uint128;
    using FixedMath for uint256;

    uint32 internal constant MIN_INCENTIVE_DURATION = 1;
    uint32 internal constant MAX_INCENTIVE_DURATION = 94608000; // 3 years

    struct WithdrawalRequest {
        uint128 value;
        address requester;
        uint32 withdrawAfter;
    }

    mapping(uint256 => WithdrawalRequest) public withdrawalRequests;

    uint256 public nextWithdrawalRequestId;
    uint128 public totalRequestedAmount;
    uint32 public withdrawalDelay;

    uint32 public incentiveEndsAt;

    uint32 internal _updatedAt;
    uint32 public incentiveStartedAt;
    uint128 internal _exchangeRate;

    uint128 public reward;
    uint256 public rewardRate;

    event StakingIncentiveUpdated(uint128 reward, uint32 incentiveEndsAt);
    event WithdrawalDelayChanged(uint256 newWithdrawalDelay);
    event WithdrawalRequested(
        address indexed requester,
        uint256 indexed requestId,
        uint128 redeemAmount,
        uint128 withdrawalAmount,
        uint32 withdrawAfter
    );
    event WithdrawalRequestProcessed(
        uint256 indexed requestId,
        address indexed to
    );

    error InsufficientDeposit(uint256 amount);
    error InvalidIncentiveDuration(uint32 minDuration, uint32 maxDuration);
    error NoReward();
    error OnlyRequesterCanWithdrawToAnotherAddress(address requester);
    error RequestDoesNotExist(uint256 requestId);
    error WithdrawalLocked(uint32 withdrawAfter);
    error ZeroAmount();

    /**
     * @notice Updates the exchange rate of the staking token to underlying token.
     */
    modifier updateExchangeRate() {
        _exchangeRate = exchangeRate();
        _updatedAt = uint32(_lastIncentiveTimestamp());
        _;
    }

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

    function initialize(
        IERC20 underlyingToken_,
        string calldata name_,
        string calldata symbol_,
        uint32 withdrawalDelay_
    ) external initializer {
        __Ownable_init_unchained(msg.sender);
        __ERC20_init_unchained(name_, symbol_);
        __ERC20Wrapper_init_unchained(underlyingToken_);
        withdrawalDelay = withdrawalDelay_;
    }

    /**
     * @dev Owner: Updates the withdrawal delay period.
     * @param newWithdrawalDelay The new delay in seconds.
     */
    function changeWithdrawalDelay(
        uint32 newWithdrawalDelay
    ) external onlyOwner {
        withdrawalDelay = newWithdrawalDelay;
        emit WithdrawalDelayChanged(newWithdrawalDelay);
    }

    /**
     * @dev Owner: Recover underlying tokens that would have been transferred by mistake.
     * @param account The address to receive the tokens.
     * @return recoveredAmount The amount of recovered tokens
     */
    function recover(
        address account
    ) external onlyOwner returns (uint256 recoveredAmount) {
        recoveredAmount =
            underlying().balanceOf(address(this)) -
            (calculateWithdrawalAmount(totalSupply()) +
                totalRequestedAmount +
                _remainingReward());

        underlying().transfer(account, recoveredAmount);
    }

    /**
     * @dev Owner: Updates (starts) the staking incentive program.
     * @param extraReward The extra amount of underlying tokens to be distributed.
     * @param incentiveDuration The duration of the incentive in seconds.
     */
    function updateStakingIncentive(
        uint128 extraReward,
        uint32 incentiveDuration
    ) external onlyOwner updateExchangeRate {
        if (
            incentiveDuration < MIN_INCENTIVE_DURATION ||
            incentiveDuration > MAX_INCENTIVE_DURATION
        )
            revert InvalidIncentiveDuration(
                MIN_INCENTIVE_DURATION,
                MAX_INCENTIVE_DURATION
            );

        uint128 totalReward = _remainingReward() + extraReward;
        if (totalReward == 0) revert NoReward();

        reward = totalReward;
        rewardRate = uint128(totalReward.div(incentiveDuration));
        incentiveStartedAt = uint32(block.timestamp);
        incentiveEndsAt = uint32(block.timestamp) + incentiveDuration;

        _updatedAt = uint32(block.timestamp);

        if (extraReward > 0)
            underlying().transferFrom(msg.sender, address(this), extraReward);

        emit StakingIncentiveUpdated(totalReward, incentiveEndsAt);
    }

    /**
     * @dev Initiates a redemption request by burning a specified amount of staking tokens.
     * @param redeemAmount The number of staking tokens to burn for redemption.
     * @return requestId The ID of the created redemption request.
     */
    function requestWithdrawal(
        uint128 redeemAmount
    ) external updateExchangeRate returns (uint256 requestId) {
        if (redeemAmount == 0) revert ZeroAmount();

        _burn(msg.sender, redeemAmount);

        requestId = nextWithdrawalRequestId++;
        uint128 withdrawalAmount = calculateWithdrawalAmount(redeemAmount);

        uint32 withdrawAfter = uint32(block.timestamp) + withdrawalDelay;

        withdrawalRequests[requestId] = WithdrawalRequest({
            value: withdrawalAmount,
            requester: msg.sender,
            withdrawAfter: withdrawAfter
        });
        totalRequestedAmount += withdrawalAmount;

        emit WithdrawalRequested(
            msg.sender,
            requestId,
            redeemAmount,
            withdrawalAmount,
            withdrawAfter
        );
    }

    /**
     * @dev Processes multiple withdrawal requests and transfers tokens.
     * @param account The address to receive the tokens.
     * @param requestIds The IDs of the withdrawal requests.
     */
    function batchWithdrawTo(
        address account,
        uint256[] calldata requestIds
    ) external {
        uint256 numRequests = requestIds.length;
        uint256 totalAmount;
        for (uint256 i; i < numRequests; ++i) {
            totalAmount += _processWithdrawalRequest(account, requestIds[i]);
        }

        underlying().transfer(account, totalAmount);
    }

    /**
     * @dev Calculates the amount of underlying tokens that can be redeemed for a given account.
     */
    function underlyingBalanceOf(
        address account
    ) external view returns (uint256) {
        return calculateWithdrawalAmount(balanceOf(account));
    }

    /**
     * @dev Allows a user to deposit underlying tokens and mint the corresponding number of wrapped tokens.
     */
    function depositFor(
        address account,
        uint256 amount
    ) public override updateExchangeRate returns (bool) {
        if (account == address(this)) revert ERC20InvalidReceiver(account);

        underlying().transferFrom(msg.sender, address(this), amount);

        uint256 mintAmount = amount.div(exchangeRate());
        if (mintAmount == 0) revert InsufficientDeposit(amount);

        _mint(account, mintAmount);

        return true;
    }

    /**
     * @dev Processes a single withdrawal request and transfers tokens.
     * @param account The address to receive the tokens.
     * @param requestId The ID of the withdrawal request.
     */
    function withdrawTo(
        address account,
        uint256 requestId
    ) public override returns (bool) {
        uint256 amount = _processWithdrawalRequest(account, requestId);
        underlying().transfer(account, amount);

        return true;
    }

    /**
     * @dev Calculates the amount of underlying tokens that can be redeemed for a given staking token amount.
     */
    function calculateWithdrawalAmount(
        uint256 redeemAmount
    ) public view returns (uint128) {
        return uint128(redeemAmount.mul(exchangeRate()));
    }

    /**
     * @dev Retrieves the actual exchange rate of the staking token to underlying token.
     */
    function exchangeRate() public view returns (uint128) {
        uint128 previousExchangeRate = _exchangeRate > 0
            ? _exchangeRate
            : uint128(FixedMath.ONE);

        uint256 totalSupply_ = totalSupply();
        if (totalSupply_ == 0) return previousExchangeRate;

        return
            uint128(
                previousExchangeRate +
                    (rewardRate * (_lastIncentiveTimestamp() - _updatedAt)) /
                    totalSupply_
            );
    }

    /**
     * @dev Handle a withdrawal request.
     * @param account The address to transfer tokens to.
     * @param requestId The ID of the withdrawal request.
     * @return withdrawalAmount The amount of tokens to withdraw.
     */
    function _processWithdrawalRequest(
        address account,
        uint256 requestId
    ) internal returns (uint256 withdrawalAmount) {
        WithdrawalRequest storage request = withdrawalRequests[requestId];
        withdrawalAmount = request.value;
        uint32 withdrawAfter = request.withdrawAfter;
        address requester = request.requester;

        if (withdrawalAmount == 0) revert RequestDoesNotExist(requestId);
        if (block.timestamp < withdrawAfter)
            revert WithdrawalLocked(withdrawAfter);
        if (account != requester && requester != msg.sender)
            revert OnlyRequesterCanWithdrawToAnotherAddress(requester);

        totalRequestedAmount -= uint128(withdrawalAmount);
        delete withdrawalRequests[requestId];

        emit WithdrawalRequestProcessed(requestId, account);
    }

    /**
     * @dev Calculates the unallocated reward amount based on the remaining incentive time.
     */
    function _remainingReward() internal view returns (uint128) {
        return
            uint128(
                rewardRate.mul(incentiveEndsAt - _lastIncentiveTimestamp())
            );
    }

    /**
     * @dev Retrieves the most recent valid timestamp for the incentive program relative to the current moment.
     */
    function _lastIncentiveTimestamp() internal view returns (uint256) {
        return
            block.timestamp < incentiveEndsAt
                ? block.timestamp
                : incentiveEndsAt;
    }
}

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

pragma solidity ^0.8.20;

import {ContextUpgradeable} from "../utils/ContextUpgradeable.sol";
import {Initializable} from "../proxy/utils/Initializable.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);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (proxy/utils/Initializable.sol)

pragma solidity ^0.8.20;

/**
 * @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 reininitialization) 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 Returns a pointer to the storage namespace.
     */
    // solhint-disable-next-line var-name-mixedcase
    function _getInitializableStorage() private pure returns (InitializableStorage storage $) {
        assembly {
            $.slot := INITIALIZABLE_STORAGE
        }
    }
}

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

pragma solidity ^0.8.20;

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import {ContextUpgradeable} from "../../utils/ContextUpgradeable.sol";
import {IERC20Errors} from "@openzeppelin/contracts/interfaces/draft-IERC6093.sol";
import {Initializable} from "../../proxy/utils/Initializable.sol";

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * The default value of {decimals} is 18. To change this, you should override
 * this function so it returns a different value.
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC-20
 * applications.
 */
abstract contract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20, IERC20Metadata, IERC20Errors {
    /// @custom:storage-location erc7201:openzeppelin.storage.ERC20
    struct ERC20Storage {
        mapping(address account => uint256) _balances;

        mapping(address account => mapping(address spender => uint256)) _allowances;

        uint256 _totalSupply;

        string _name;
        string _symbol;
    }

    // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.ERC20")) - 1)) & ~bytes32(uint256(0xff))
    bytes32 private constant ERC20StorageLocation = 0x52c63247e1f47db19d5ce0460030c497f067ca4cebf71ba98eeadabe20bace00;

    function _getERC20Storage() private pure returns (ERC20Storage storage $) {
        assembly {
            $.slot := ERC20StorageLocation
        }
    }

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    function __ERC20_init(string memory name_, string memory symbol_) internal onlyInitializing {
        __ERC20_init_unchained(name_, symbol_);
    }

    function __ERC20_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {
        ERC20Storage storage $ = _getERC20Storage();
        $._name = name_;
        $._symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual returns (string memory) {
        ERC20Storage storage $ = _getERC20Storage();
        return $._name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual returns (string memory) {
        ERC20Storage storage $ = _getERC20Storage();
        return $._symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the default value returned by this function, unless
     * it's overridden.
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual returns (uint256) {
        ERC20Storage storage $ = _getERC20Storage();
        return $._totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual returns (uint256) {
        ERC20Storage storage $ = _getERC20Storage();
        return $._balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `value`.
     */
    function transfer(address to, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, value);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual returns (uint256) {
        ERC20Storage storage $ = _getERC20Storage();
        return $._allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `value` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, value);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Skips emitting an {Approval} event indicating an allowance update. This is not
     * required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve].
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `value`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `value`.
     */
    function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, value);
        _transfer(from, to, value);
        return true;
    }

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _transfer(address from, address to, uint256 value) internal {
        if (from == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        if (to == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(from, to, value);
    }

    /**
     * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`
     * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding
     * this function.
     *
     * Emits a {Transfer} event.
     */
    function _update(address from, address to, uint256 value) internal virtual {
        ERC20Storage storage $ = _getERC20Storage();
        if (from == address(0)) {
            // Overflow check required: The rest of the code assumes that totalSupply never overflows
            $._totalSupply += value;
        } else {
            uint256 fromBalance = $._balances[from];
            if (fromBalance < value) {
                revert ERC20InsufficientBalance(from, fromBalance, value);
            }
            unchecked {
                // Overflow not possible: value <= fromBalance <= totalSupply.
                $._balances[from] = fromBalance - value;
            }
        }

        if (to == address(0)) {
            unchecked {
                // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.
                $._totalSupply -= value;
            }
        } else {
            unchecked {
                // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.
                $._balances[to] += value;
            }
        }

        emit Transfer(from, to, value);
    }

    /**
     * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).
     * Relies on the `_update` mechanism
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _mint(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(address(0), account, value);
    }

    /**
     * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.
     * Relies on the `_update` mechanism.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead
     */
    function _burn(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        _update(account, address(0), value);
    }

    /**
     * @dev Sets `value` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     *
     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
     */
    function _approve(address owner, address spender, uint256 value) internal {
        _approve(owner, spender, value, true);
    }

    /**
     * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.
     *
     * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by
     * `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any
     * `Approval` event during `transferFrom` operations.
     *
     * Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to
     * true using the following override:
     *
     * ```solidity
     * function _approve(address owner, address spender, uint256 value, bool) internal virtual override {
     *     super._approve(owner, spender, value, true);
     * }
     * ```
     *
     * Requirements are the same as {_approve}.
     */
    function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
        ERC20Storage storage $ = _getERC20Storage();
        if (owner == address(0)) {
            revert ERC20InvalidApprover(address(0));
        }
        if (spender == address(0)) {
            revert ERC20InvalidSpender(address(0));
        }
        $._allowances[owner][spender] = value;
        if (emitEvent) {
            emit Approval(owner, spender, value);
        }
    }

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `value`.
     *
     * Does not update the allowance value in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Does not emit an {Approval} event.
     */
    function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            if (currentAllowance < value) {
                revert ERC20InsufficientAllowance(spender, currentAllowance, value);
            }
            unchecked {
                _approve(owner, spender, currentAllowance - value, false);
            }
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/extensions/ERC20Wrapper.sol)

pragma solidity ^0.8.20;

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import {ERC20Upgradeable} from "../ERC20Upgradeable.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {Initializable} from "../../../proxy/utils/Initializable.sol";

/**
 * @dev Extension of the ERC-20 token contract to support token wrapping.
 *
 * Users can deposit and withdraw "underlying tokens" and receive a matching number of "wrapped tokens". This is useful
 * in conjunction with other modules. For example, combining this wrapping mechanism with {ERC20Votes} will allow the
 * wrapping of an existing "basic" ERC-20 into a governance token.
 *
 * WARNING: Any mechanism in which the underlying token changes the {balanceOf} of an account without an explicit transfer
 * may desynchronize this contract's supply and its underlying balance. Please exercise caution when wrapping tokens that
 * may undercollateralize the wrapper (i.e. wrapper's total supply is higher than its underlying balance). See {_recover}
 * for recovering value accrued to the wrapper.
 */
abstract contract ERC20WrapperUpgradeable is Initializable, ERC20Upgradeable {
    /// @custom:storage-location erc7201:openzeppelin.storage.ERC20Wrapper
    struct ERC20WrapperStorage {
        IERC20 _underlying;
    }

    // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.ERC20Wrapper")) - 1)) & ~bytes32(uint256(0xff))
    bytes32 private constant ERC20WrapperStorageLocation = 0x3b5a617e0d4c238430871a64fe18212794b0c8d05a4eac064a8c9039fb5e0700;

    function _getERC20WrapperStorage() private pure returns (ERC20WrapperStorage storage $) {
        assembly {
            $.slot := ERC20WrapperStorageLocation
        }
    }

    /**
     * @dev The underlying token couldn't be wrapped.
     */
    error ERC20InvalidUnderlying(address token);

    function __ERC20Wrapper_init(IERC20 underlyingToken) internal onlyInitializing {
        __ERC20Wrapper_init_unchained(underlyingToken);
    }

    function __ERC20Wrapper_init_unchained(IERC20 underlyingToken) internal onlyInitializing {
        ERC20WrapperStorage storage $ = _getERC20WrapperStorage();
        if (underlyingToken == this) {
            revert ERC20InvalidUnderlying(address(this));
        }
        $._underlying = underlyingToken;
    }

    /**
     * @dev See {ERC20-decimals}.
     */
    function decimals() public view virtual override returns (uint8) {
        ERC20WrapperStorage storage $ = _getERC20WrapperStorage();
        try IERC20Metadata(address($._underlying)).decimals() returns (uint8 value) {
            return value;
        } catch {
            return super.decimals();
        }
    }

    /**
     * @dev Returns the address of the underlying ERC-20 token that is being wrapped.
     */
    function underlying() public view returns (IERC20) {
        ERC20WrapperStorage storage $ = _getERC20WrapperStorage();
        return $._underlying;
    }

    /**
     * @dev Allow a user to deposit underlying tokens and mint the corresponding number of wrapped tokens.
     */
    function depositFor(address account, uint256 value) public virtual returns (bool) {
        ERC20WrapperStorage storage $ = _getERC20WrapperStorage();
        address sender = _msgSender();
        if (sender == address(this)) {
            revert ERC20InvalidSender(address(this));
        }
        if (account == address(this)) {
            revert ERC20InvalidReceiver(account);
        }
        SafeERC20.safeTransferFrom($._underlying, sender, address(this), value);
        _mint(account, value);
        return true;
    }

    /**
     * @dev Allow a user to burn a number of wrapped tokens and withdraw the corresponding number of underlying tokens.
     */
    function withdrawTo(address account, uint256 value) public virtual returns (bool) {
        ERC20WrapperStorage storage $ = _getERC20WrapperStorage();
        if (account == address(this)) {
            revert ERC20InvalidReceiver(account);
        }
        _burn(_msgSender(), value);
        SafeERC20.safeTransfer($._underlying, account, value);
        return true;
    }

    /**
     * @dev Mint wrapped token to cover any underlyingTokens that would have been transferred by mistake or acquired from
     * rebasing mechanisms. Internal function that can be exposed with access control if desired.
     */
    function _recover(address account) internal virtual returns (uint256) {
        ERC20WrapperStorage storage $ = _getERC20WrapperStorage();
        uint256 value = $._underlying.balanceOf(address(this)) - totalSupply();
        _mint(account, value);
        return value;
    }
}

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

pragma solidity ^0.8.20;
import {Initializable} from "../proxy/utils/Initializable.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;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/draft-IERC6093.sol)
pragma solidity ^0.8.20;

/**
 * @dev Standard ERC-20 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-20 tokens.
 */
interface IERC20Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC20InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC20InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     * @param allowance Amount of tokens a `spender` is allowed to operate with.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC20InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC20InvalidSpender(address spender);
}

/**
 * @dev Standard ERC-721 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-721 tokens.
 */
interface IERC721Errors {
    /**
     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-20.
     * Used in balance queries.
     * @param owner Address of the current owner of a token.
     */
    error ERC721InvalidOwner(address owner);

    /**
     * @dev Indicates a `tokenId` whose `owner` is the zero address.
     * @param tokenId Identifier number of a token.
     */
    error ERC721NonexistentToken(uint256 tokenId);

    /**
     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param tokenId Identifier number of a token.
     * @param owner Address of the current owner of a token.
     */
    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC721InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC721InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param tokenId Identifier number of a token.
     */
    error ERC721InsufficientApproval(address operator, uint256 tokenId);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC721InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC721InvalidOperator(address operator);
}

/**
 * @dev Standard ERC-1155 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-1155 tokens.
 */
interface IERC1155Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     * @param tokenId Identifier number of a token.
     */
    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC1155InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC1155InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param owner Address of the current owner of a token.
     */
    error ERC1155MissingApprovalForAll(address operator, address owner);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC1155InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC1155InvalidOperator(address operator);

    /**
     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
     * Used in batch transfers.
     * @param idsLength Length of the array of token identifiers
     * @param valuesLength Length of the array of token amounts
     */
    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}

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

pragma solidity ^0.8.20;

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.20;

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

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

pragma solidity ^0.8.20;

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.20;

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

/**
 * @dev Interface for the optional metadata functions from the ERC-20 standard.
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.20;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.20;

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

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

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

        (bool success, ) = recipient.call{value: amount}("");
        if (!success) {
            revert Errors.FailedCall();
        }
    }

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

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

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

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

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

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

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

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

pragma solidity ^0.8.20;

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

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

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

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

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

pragma solidity ^0.8.20;

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

// SPDX-License-Identifier: GPL-3.0

pragma solidity ^0.8.28;

/// @title Fixed-point math tools
library FixedMath {
    uint256 constant ONE = 1e18;

    function mul(uint256 self, uint256 other) internal pure returns (uint256) {
        return (self * other) / ONE;
    }

    function div(uint256 self, uint256 other) internal pure returns (uint256) {
        return (self * ONE) / other;
    }
}

{
  "optimizer": {
    "enabled": true,
    "runs": 1000000
  },
  "evmVersion": "paris",
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"allowance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientAllowance","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC20InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC20InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC20InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"}],"name":"ERC20InvalidSpender","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"ERC20InvalidUnderlying","type":"error"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"InsufficientDeposit","type":"error"},{"inputs":[{"internalType":"uint32","name":"minDuration","type":"uint32"},{"internalType":"uint32","name":"maxDuration","type":"uint32"}],"name":"InvalidIncentiveDuration","type":"error"},{"inputs":[],"name":"InvalidInitialization","type":"error"},{"inputs":[],"name":"NoReward","type":"error"},{"inputs":[],"name":"NotInitializing","type":"error"},{"inputs":[{"internalType":"address","name":"requester","type":"address"}],"name":"OnlyRequesterCanWithdrawToAnotherAddress","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[{"internalType":"uint256","name":"requestId","type":"uint256"}],"name":"RequestDoesNotExist","type":"error"},{"inputs":[{"internalType":"uint32","name":"withdrawAfter","type":"uint32"}],"name":"WithdrawalLocked","type":"error"},{"inputs":[],"name":"ZeroAmount","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","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":"uint128","name":"reward","type":"uint128"},{"indexed":false,"internalType":"uint32","name":"incentiveEndsAt","type":"uint32"}],"name":"StakingIncentiveUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newWithdrawalDelay","type":"uint256"}],"name":"WithdrawalDelayChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"requestId","type":"uint256"},{"indexed":true,"internalType":"address","name":"to","type":"address"}],"name":"WithdrawalRequestProcessed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"requester","type":"address"},{"indexed":true,"internalType":"uint256","name":"requestId","type":"uint256"},{"indexed":false,"internalType":"uint128","name":"redeemAmount","type":"uint128"},{"indexed":false,"internalType":"uint128","name":"withdrawalAmount","type":"uint128"},{"indexed":false,"internalType":"uint32","name":"withdrawAfter","type":"uint32"}],"name":"WithdrawalRequested","type":"event"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256[]","name":"requestIds","type":"uint256[]"}],"name":"batchWithdrawTo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"redeemAmount","type":"uint256"}],"name":"calculateWithdrawalAmount","outputs":[{"internalType":"uint128","name":"","type":"uint128"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint32","name":"newWithdrawalDelay","type":"uint32"}],"name":"changeWithdrawalDelay","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"depositFor","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"exchangeRate","outputs":[{"internalType":"uint128","name":"","type":"uint128"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"incentiveEndsAt","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"incentiveStartedAt","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"underlyingToken_","type":"address"},{"internalType":"string","name":"name_","type":"string"},{"internalType":"string","name":"symbol_","type":"string"},{"internalType":"uint32","name":"withdrawalDelay_","type":"uint32"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nextWithdrawalRequestId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"recover","outputs":[{"internalType":"uint256","name":"recoveredAmount","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint128","name":"redeemAmount","type":"uint128"}],"name":"requestWithdrawal","outputs":[{"internalType":"uint256","name":"requestId","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"reward","outputs":[{"internalType":"uint128","name":"","type":"uint128"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalRequestedAmount","outputs":[{"internalType":"uint128","name":"","type":"uint128"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"underlying","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"underlyingBalanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint128","name":"extraReward","type":"uint128"},{"internalType":"uint32","name":"incentiveDuration","type":"uint32"}],"name":"updateStakingIncentive","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"requestId","type":"uint256"}],"name":"withdrawTo","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawalDelay","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"withdrawalRequests","outputs":[{"internalType":"uint128","name":"value","type":"uint128"},{"internalType":"address","name":"requester","type":"address"},{"internalType":"uint32","name":"withdrawAfter","type":"uint32"}],"stateMutability":"view","type":"function"}]

6080604052348015600f57600080fd5b506016601a565b60ca565b7ff0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00805468010000000000000000900460ff161560695760405163f92ee8a960e01b815260040160405180910390fd5b80546001600160401b039081161460c75780546001600160401b0319166001600160401b0390811782556040519081527fc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d29060200160405180910390a15b50565b612cc8806100d96000396000f3fe608060405234801561001057600080fd5b50600436106101f05760003560e01c80636f307dc31161010f57806395d89b41116100a2578063b18c25ab11610071578063b18c25ab146105b3578063dd62ed3e146105cf578063f2fde38b14610634578063f55f45231461064757600080fd5b806395d89b411461054c578063a7ab696114610554578063a8968a2d14610578578063a9059cbb146105a057600080fd5b80637df26b2d116100de5780637df26b2d146104635780638da5cb5b14610476578063935a8b841461047e578063937b25811461049157600080fd5b80636f307dc3146103d057806370a08231146103fd578063715018a6146104525780637b0a47ee1461045a57600080fd5b806323b872dd116101875780633ba0b9a9116101565780633ba0b9a91461035d57806363e5ca341461036557806363f1181a146103785780636ca4410d146103bd57600080fd5b806323b872dd1461030a5780632f4f21e21461031d578063313ce567146103305780633289d7da1461034a57600080fd5b806318160ddd116101c357806318160ddd1461028b5780631e465e5e146102b2578063205c2878146102c7578063228cb733146102da57600080fd5b806306fdde03146101f5578063095ea7b3146102135780630cd865ec146102365780630e1a039914610257575b600080fd5b6101fd610650565b60405161020a9190612568565b60405180910390f35b6102266102213660046125f6565b610725565b604051901515815260200161020a565b610249610244366004612622565b61073f565b60405190815260200161020a565b61026a61026536600461263f565b610904565b6040516fffffffffffffffffffffffffffffffff909116815260200161020a565b7f52c63247e1f47db19d5ce0460030c497f067ca4cebf71ba98eeadabe20bace0254610249565b6102c56102c0366004612671565b61092a565b005b6102266102d53660046125f6565b6109b1565b60035461026a9070010000000000000000000000000000000090046fffffffffffffffffffffffffffffffff1681565b61022661031836600461268c565b610a6e565b61022661032b3660046125f6565b610a87565b610338610caf565b60405160ff909116815260200161020a565b6102c56103583660046126ed565b610d86565b61026a611179565b6102c5610373366004612720565b61126a565b6002546103a8907c0100000000000000000000000000000000000000000000000000000000900463ffffffff1681565b60405163ffffffff909116815260200161020a565b6102496103cb3660046127aa565b611359565b6103d8611605565b60405173ffffffffffffffffffffffffffffffffffffffff909116815260200161020a565b61024961040b366004612622565b73ffffffffffffffffffffffffffffffffffffffff1660009081527f52c63247e1f47db19d5ce0460030c497f067ca4cebf71ba98eeadabe20bace00602052604090205490565b6102c5611647565b61024960045481565b6102c561047136600461280e565b61165b565b6103d861189f565b61024961048c366004612622565b6118c8565b61050361049f36600461263f565b600060208190529081526040902080546001909101546fffffffffffffffffffffffffffffffff9091169073ffffffffffffffffffffffffffffffffffffffff81169074010000000000000000000000000000000000000000900463ffffffff1683565b604080516fffffffffffffffffffffffffffffffff909416845273ffffffffffffffffffffffffffffffffffffffff909216602084015263ffffffff169082015260600161020a565b6101fd61192e565b6002546103a890700100000000000000000000000000000000900463ffffffff1681565b6002546103a89074010000000000000000000000000000000000000000900463ffffffff1681565b6102266105ae3660046125f6565b61197f565b60025461026a906fffffffffffffffffffffffffffffffff1681565b6102496105dd3660046128a5565b73ffffffffffffffffffffffffffffffffffffffff91821660009081527f52c63247e1f47db19d5ce0460030c497f067ca4cebf71ba98eeadabe20bace016020908152604080832093909416825291909152205490565b6102c5610642366004612622565b61198d565b61024960015481565b7f52c63247e1f47db19d5ce0460030c497f067ca4cebf71ba98eeadabe20bace0380546060917f52c63247e1f47db19d5ce0460030c497f067ca4cebf71ba98eeadabe20bace00916106a1906128de565b80601f01602080910402602001604051908101604052809291908181526020018280546106cd906128de565b801561071a5780601f106106ef5761010080835404028352916020019161071a565b820191906000526020600020905b8154815290600101906020018083116106fd57829003601f168201915b505050505091505090565b6000336107338185856119f1565b60019150505b92915050565b6000610749611a03565b610751611a5b565b6002546fffffffffffffffffffffffffffffffff166107916102657f52c63247e1f47db19d5ce0460030c497f067ca4cebf71ba98eeadabe20bace025490565b61079b919061295a565b6107a5919061295a565b6fffffffffffffffffffffffffffffffff166107bf611605565b6040517f70a0823100000000000000000000000000000000000000000000000000000000815230600482015273ffffffffffffffffffffffffffffffffffffffff91909116906370a0823190602401602060405180830381865afa15801561082b573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061084f9190612982565b610859919061299b565b9050610863611605565b6040517fa9059cbb00000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff848116600483015260248201849052919091169063a9059cbb906044016020604051808303816000875af11580156108da573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906108fe91906129ae565b50919050565b6000610739610911611179565b83906fffffffffffffffffffffffffffffffff16611aa1565b610932611a03565b600280547fffffffffffffffffffffffff00000000ffffffffffffffffffffffffffffffff1670010000000000000000000000000000000063ffffffff8416908102919091179091556040519081527f61cf77e7a4ccfce117d0449d5a113db003011a722330d53210a6810ef22c56409060200160405180910390a150565b6000806109be8484611ac7565b90506109c8611605565b6040517fa9059cbb00000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff868116600483015260248201849052919091169063a9059cbb906044016020604051808303816000875af1158015610a3f573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610a6391906129ae565b506001949350505050565b600033610a7c858285611d45565b610a63858585611e33565b6000610a91611179565b600380547fffffffffffffffffffffffffffffffff00000000000000000000000000000000166fffffffffffffffffffffffffffffffff92909216919091179055610ada611ede565b6002805463ffffffff929092167801000000000000000000000000000000000000000000000000027fffffffff00000000ffffffffffffffffffffffffffffffffffffffffffffffff9092169190911790553073ffffffffffffffffffffffffffffffffffffffff841603610b98576040517fec442f0500000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff841660048201526024015b60405180910390fd5b610ba0611605565b6040517f23b872dd0000000000000000000000000000000000000000000000000000000081523360048201523060248201526044810184905273ffffffffffffffffffffffffffffffffffffffff91909116906323b872dd906064016020604051808303816000875af1158015610c1b573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610c3f91906129ae565b506000610c66610c4d611179565b84906fffffffffffffffffffffffffffffffff16611f32565b905080600003610ca5576040517f3502834200000000000000000000000000000000000000000000000000000000815260048101849052602401610b8f565b6107338482611f47565b7f3b5a617e0d4c238430871a64fe18212794b0c8d05a4eac064a8c9039fb5e07008054604080517f313ce56700000000000000000000000000000000000000000000000000000000815290516000939273ffffffffffffffffffffffffffffffffffffffff169163313ce5679160048083019260209291908290030181865afa925050508015610d7a575060408051601f3d9081017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0168201909252610d77918101906129d0565b60015b61073957601291505090565b610d8e611a03565b610d96611179565b600380547fffffffffffffffffffffffffffffffff00000000000000000000000000000000166fffffffffffffffffffffffffffffffff92909216919091179055610ddf611ede565b600280547fffffffff00000000ffffffffffffffffffffffffffffffffffffffffffffffff16780100000000000000000000000000000000000000000000000063ffffffff9384160217905560019082161080610e4557506305a39a8063ffffffff8216115b15610e89576040517f12cb8dd4000000000000000000000000000000000000000000000000000000008152600160048201526305a39a806024820152604401610b8f565b600082610e94611a5b565b610e9e919061295a565b9050806fffffffffffffffffffffffffffffffff16600003610eec576040517f6e99268600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600380546fffffffffffffffffffffffffffffffff80841670010000000000000000000000000000000081029190921617909155610f339063ffffffff80851690611f3216565b6fffffffffffffffffffffffffffffffff166004556002805463ffffffff429081167c0100000000000000000000000000000000000000000000000000000000027bffffffffffffffffffffffffffffffffffffffffffffffffffffffff90921691909117909155610fa69083906129f3565b600280547fffffffff0000000000000000ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000063ffffffff938416027fffffffff00000000ffffffffffffffffffffffffffffffffffffffffffffffff161778010000000000000000000000000000000000000000000000004293909316929092029190911790556fffffffffffffffffffffffffffffffff83161561110957611057611605565b6040517f23b872dd0000000000000000000000000000000000000000000000000000000081523360048201523060248201526fffffffffffffffffffffffffffffffff8516604482015273ffffffffffffffffffffffffffffffffffffffff91909116906323b872dd906064016020604051808303816000875af11580156110e3573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061110791906129ae565b505b600254604080516fffffffffffffffffffffffffffffffff841681527401000000000000000000000000000000000000000090920463ffffffff1660208301527fd11bba24ca86aee79dd9262e204258763f92f11686c60a21e14f88133a677f5a910160405180910390a1505050565b60035460009081906fffffffffffffffffffffffffffffffff166111a557670de0b6b3a76400006111bb565b6003546fffffffffffffffffffffffffffffffff165b905060006111e77f52c63247e1f47db19d5ce0460030c497f067ca4cebf71ba98eeadabe20bace025490565b9050806000036111f75750919050565b60025481907801000000000000000000000000000000000000000000000000900463ffffffff16611226611ede565b611230919061299b565b60045461123d9190612a0f565b6112479190612a26565b611263906fffffffffffffffffffffffffffffffff8416612a61565b9250505090565b806000805b828110156112ad576112998686868481811061128d5761128d612a74565b90506020020135611ac7565b6112a39083612a61565b915060010161126f565b506112b6611605565b6040517fa9059cbb00000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff878116600483015260248201849052919091169063a9059cbb906044016020604051808303816000875af115801561132d573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061135191906129ae565b505050505050565b6000611363611179565b600380547fffffffffffffffffffffffffffffffff00000000000000000000000000000000166fffffffffffffffffffffffffffffffff929092169190911790556113ac611ede565b600260186101000a81548163ffffffff021916908363ffffffff160217905550816fffffffffffffffffffffffffffffffff16600003611418576040517f1f2a200500000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b61143433836fffffffffffffffffffffffffffffffff16611fa7565b6001805490600061144483612aa3565b9190505590506000611467836fffffffffffffffffffffffffffffffff16610904565b60025490915060009061149490700100000000000000000000000000000000900463ffffffff16426129f3565b604080516060810182526fffffffffffffffffffffffffffffffff858116825233602080840191825263ffffffff86811685870190815260008b815292839052958220945185547fffffffffffffffffffffffffffffffff0000000000000000000000000000000016908516178555915160019094018054955173ffffffffffffffffffffffffffffffffffffffff9095167fffffffffffffffff000000000000000000000000000000000000000000000000909616959095177401000000000000000000000000000000000000000094909216939093021790925560028054939450859390926115879185911661295a565b82546101009290920a6fffffffffffffffffffffffffffffffff818102199093169183160217909155604080518783168152918516602083015263ffffffff84169082015284915033907f29c908cef2964f2fb7dcfc6052cbf5b3acf7f18a2c0e92b667679f45106013399060600160405180910390a35050919050565b6000807f3b5a617e0d4c238430871a64fe18212794b0c8d05a4eac064a8c9039fb5e07005b5473ffffffffffffffffffffffffffffffffffffffff1692915050565b61164f611a03565b6116596000612003565b565b7ff0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00805468010000000000000000810460ff16159067ffffffffffffffff166000811580156116a65750825b905060008267ffffffffffffffff1660011480156116c35750303b155b9050811580156116d1575080155b15611708576040517ff92ee8a900000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b84547fffffffffffffffffffffffffffffffffffffffffffffffff000000000000000016600117855583156117695784547fffffffffffffffffffffffffffffffffffffffffffffff00ffffffffffffffff16680100000000000000001785555b61177233612099565b6117e58a8a8080601f01602080910402602001604051908101604052809392919081815260200183838082843760009201919091525050604080516020601f8e018190048102820181019092528c815292508c91508b90819084018382808284376000920191909152506120a192505050565b6117ee8b612104565b600280547fffffffffffffffffffffffff00000000ffffffffffffffffffffffffffffffff1670010000000000000000000000000000000063ffffffff89160217905583156118925784547fffffffffffffffffffffffffffffffffffffffffffffff00ffffffffffffffff168555604051600181527fc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d29060200160405180910390a15b5050505050505050505050565b6000807f9016d09d72d40fdae2fd8ceac6b6234c7706214fd39c1cd1e609a0528c19930061162a565b73ffffffffffffffffffffffffffffffffffffffff811660009081527f52c63247e1f47db19d5ce0460030c497f067ca4cebf71ba98eeadabe20bace00602052604081205461191690610904565b6fffffffffffffffffffffffffffffffff1692915050565b7f52c63247e1f47db19d5ce0460030c497f067ca4cebf71ba98eeadabe20bace0480546060917f52c63247e1f47db19d5ce0460030c497f067ca4cebf71ba98eeadabe20bace00916106a1906128de565b600033610733818585611e33565b611995611a03565b73ffffffffffffffffffffffffffffffffffffffff81166119e5576040517f1e4fbdf700000000000000000000000000000000000000000000000000000000815260006004820152602401610b8f565b6119ee81612003565b50565b6119fe83838360016121c3565b505050565b33611a0c61189f565b73ffffffffffffffffffffffffffffffffffffffff1614611659576040517f118cdaa7000000000000000000000000000000000000000000000000000000008152336004820152602401610b8f565b6000611a9c611a68611ede565b600254611a93919074010000000000000000000000000000000000000000900463ffffffff1661299b565b60045490611aa1565b905090565b6000670de0b6b3a7640000611ab68385612a0f565b611ac09190612a26565b9392505050565b6000818152602081905260408120805460018201546fffffffffffffffffffffffffffffffff9091169263ffffffff740100000000000000000000000000000000000000008304169173ffffffffffffffffffffffffffffffffffffffff1690849003611b63576040517f0c4dee0300000000000000000000000000000000000000000000000000000000815260048101869052602401610b8f565b8163ffffffff16421015611bab576040517f90af1d4700000000000000000000000000000000000000000000000000000000815263ffffffff83166004820152602401610b8f565b8073ffffffffffffffffffffffffffffffffffffffff168673ffffffffffffffffffffffffffffffffffffffff1614158015611bfd575073ffffffffffffffffffffffffffffffffffffffff81163314155b15611c4c576040517fbd96f9b200000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff82166004820152602401610b8f565b60028054859190600090611c739084906fffffffffffffffffffffffffffffffff16612adb565b82546fffffffffffffffffffffffffffffffff9182166101009390930a92830291909202199091161790555060008581526020819052604080822080547fffffffffffffffffffffffffffffffff0000000000000000000000000000000016815560010180547fffffffffffffffff0000000000000000000000000000000000000000000000001690555173ffffffffffffffffffffffffffffffffffffffff88169187917f9c1b962e940b919d87abe7aa0561f38ae9f8a55c739839c451c25eacf0dfb8f29190a350505092915050565b73ffffffffffffffffffffffffffffffffffffffff83811660009081527f52c63247e1f47db19d5ce0460030c497f067ca4cebf71ba98eeadabe20bace0160209081526040808320938616835292905220547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8114611e2d5781811015611e1e576040517ffb8f41b200000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff841660048201526024810182905260448101839052606401610b8f565b611e2d848484840360006121c3565b50505050565b73ffffffffffffffffffffffffffffffffffffffff8316611e83576040517f96c6fd1e00000000000000000000000000000000000000000000000000000000815260006004820152602401610b8f565b73ffffffffffffffffffffffffffffffffffffffff8216611ed3576040517fec442f0500000000000000000000000000000000000000000000000000000000815260006004820152602401610b8f565b6119fe838383612330565b60025460009074010000000000000000000000000000000000000000900463ffffffff164210611f2d575060025474010000000000000000000000000000000000000000900463ffffffff1690565b504290565b600081611ab6670de0b6b3a764000085612a0f565b73ffffffffffffffffffffffffffffffffffffffff8216611f97576040517fec442f0500000000000000000000000000000000000000000000000000000000815260006004820152602401610b8f565b611fa360008383612330565b5050565b73ffffffffffffffffffffffffffffffffffffffff8216611ff7576040517f96c6fd1e00000000000000000000000000000000000000000000000000000000815260006004820152602401610b8f565b611fa382600083612330565b7f9016d09d72d40fdae2fd8ceac6b6234c7706214fd39c1cd1e609a0528c19930080547fffffffffffffffffffffffff0000000000000000000000000000000000000000811673ffffffffffffffffffffffffffffffffffffffff848116918217845560405192169182907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a3505050565b611995612501565b6120a9612501565b7f52c63247e1f47db19d5ce0460030c497f067ca4cebf71ba98eeadabe20bace007f52c63247e1f47db19d5ce0460030c497f067ca4cebf71ba98eeadabe20bace036120f58482612b79565b5060048101611e2d8382612b79565b61210c612501565b7f3b5a617e0d4c238430871a64fe18212794b0c8d05a4eac064a8c9039fb5e07003073ffffffffffffffffffffffffffffffffffffffff83160361217e576040517f438d6fe3000000000000000000000000000000000000000000000000000000008152306004820152602401610b8f565b80547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff92909216919091179055565b7f52c63247e1f47db19d5ce0460030c497f067ca4cebf71ba98eeadabe20bace0073ffffffffffffffffffffffffffffffffffffffff8516612234576040517fe602df0500000000000000000000000000000000000000000000000000000000815260006004820152602401610b8f565b73ffffffffffffffffffffffffffffffffffffffff8416612284576040517f94280d6200000000000000000000000000000000000000000000000000000000815260006004820152602401610b8f565b73ffffffffffffffffffffffffffffffffffffffff808616600090815260018301602090815260408083209388168352929052208390558115612329578373ffffffffffffffffffffffffffffffffffffffff168573ffffffffffffffffffffffffffffffffffffffff167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b9258560405161232091815260200190565b60405180910390a35b5050505050565b7f52c63247e1f47db19d5ce0460030c497f067ca4cebf71ba98eeadabe20bace0073ffffffffffffffffffffffffffffffffffffffff841661238b57818160020160008282546123809190612a61565b9091555061243d9050565b73ffffffffffffffffffffffffffffffffffffffff841660009081526020829052604090205482811015612411576040517fe450d38c00000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff861660048201526024810182905260448101849052606401610b8f565b73ffffffffffffffffffffffffffffffffffffffff851660009081526020839052604090209083900390555b73ffffffffffffffffffffffffffffffffffffffff8316612468576002810180548390039055612494565b73ffffffffffffffffffffffffffffffffffffffff831660009081526020829052604090208054830190555b8273ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef846040516124f391815260200190565b60405180910390a350505050565b7ff0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a005468010000000000000000900460ff16611659576040517fd7e6bcf800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b602081526000825180602084015260005b818110156125965760208186018101516040868401015201612579565b5060006040828501015260407fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f83011684010191505092915050565b73ffffffffffffffffffffffffffffffffffffffff811681146119ee57600080fd5b6000806040838503121561260957600080fd5b8235612614816125d4565b946020939093013593505050565b60006020828403121561263457600080fd5b8135611ac0816125d4565b60006020828403121561265157600080fd5b5035919050565b803563ffffffff8116811461266c57600080fd5b919050565b60006020828403121561268357600080fd5b611ac082612658565b6000806000606084860312156126a157600080fd5b83356126ac816125d4565b925060208401356126bc816125d4565b929592945050506040919091013590565b80356fffffffffffffffffffffffffffffffff8116811461266c57600080fd5b6000806040838503121561270057600080fd5b612709836126cd565b915061271760208401612658565b90509250929050565b60008060006040848603121561273557600080fd5b8335612740816125d4565b9250602084013567ffffffffffffffff81111561275c57600080fd5b8401601f8101861361276d57600080fd5b803567ffffffffffffffff81111561278457600080fd5b8660208260051b840101111561279957600080fd5b939660209190910195509293505050565b6000602082840312156127bc57600080fd5b611ac0826126cd565b60008083601f8401126127d757600080fd5b50813567ffffffffffffffff8111156127ef57600080fd5b60208301915083602082850101111561280757600080fd5b9250929050565b6000806000806000806080878903121561282757600080fd5b8635612832816125d4565b9550602087013567ffffffffffffffff81111561284e57600080fd5b61285a89828a016127c5565b909650945050604087013567ffffffffffffffff81111561287a57600080fd5b61288689828a016127c5565b9094509250612899905060608801612658565b90509295509295509295565b600080604083850312156128b857600080fd5b82356128c3816125d4565b915060208301356128d3816125d4565b809150509250929050565b600181811c908216806128f257607f821691505b6020821081036108fe577f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b6fffffffffffffffffffffffffffffffff81811683821601908111156107395761073961292b565b60006020828403121561299457600080fd5b5051919050565b818103818111156107395761073961292b565b6000602082840312156129c057600080fd5b81518015158114611ac057600080fd5b6000602082840312156129e257600080fd5b815160ff81168114611ac057600080fd5b63ffffffff81811683821601908111156107395761073961292b565b80820281158282048414176107395761073961292b565b600082612a5c577f4e487b7100000000000000000000000000000000000000000000000000000000600052601260045260246000fd5b500490565b808201808211156107395761073961292b565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8203612ad457612ad461292b565b5060010190565b6fffffffffffffffffffffffffffffffff82811682821603908111156107395761073961292b565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b601f8211156119fe57806000526020600020601f840160051c81016020851015612b595750805b601f840160051c820191505b818110156123295760008155600101612b65565b815167ffffffffffffffff811115612b9357612b93612b03565b612ba781612ba184546128de565b84612b32565b6020601f821160018114612bf95760008315612bc35750848201515b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600385901b1c1916600184901b178455612329565b6000848152602081207fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe08516915b82811015612c475787850151825560209485019460019092019101612c27565b5084821015612c8357868401517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600387901b60f8161c191681555b50505050600190811b0190555056fea2646970667358221220d3944da32f41140c2f9cc35e1f072a7ea8a4feae36493dae351b147f718f102064736f6c634300081c0033

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