Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at hyperevmscan.io on 2025-10-30
*/

// Sources flattened with hardhat v2.26.1 https://hardhat.org

// SPDX-License-Identifier: MIT

// File @openzeppelin/contracts/utils/[email protected]

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.4) (utils/Context.sol)

pragma solidity ^0.8.0;

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

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

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


// File @openzeppelin/contracts/access/[email protected]

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

/**
 * @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.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

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

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @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 {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

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


// File @openzeppelin/contracts/token/ERC20/[email protected]

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
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 amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

    /**
     * @dev Moves `amount` 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 amount) 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 `amount` 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 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` 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 amount) external returns (bool);
}


// File @openzeppelin/contracts/token/ERC20/extensions/[email protected]

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
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);
}


// File @openzeppelin/contracts/token/ERC20/[email protected]

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/ERC20.sol)

pragma solidity ^0.8.0;



/**
 * @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}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * 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 ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

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

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

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override returns (string memory) {
        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 override returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

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

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

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

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `amount` 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 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * 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 `amount`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `amount`.
     */
    function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, allowance(owner, spender) + addedValue);
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        address owner = _msgSender();
        uint256 currentAllowance = allowance(owner, spender);
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(owner, spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `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.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     */
    function _transfer(address from, address to, uint256 amount) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[from] = fromBalance - amount;
            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
            // decrementing then incrementing.
            _balances[to] += amount;
        }

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        unchecked {
            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
            _balances[account] += amount;
        }
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
            // Overflow not possible: amount <= accountBalance <= totalSupply.
            _totalSupply -= amount;
        }

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` 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.
     */
    function _approve(address owner, address spender, uint256 amount) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

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

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}


// File @openzeppelin/contracts/token/ERC20/extensions/[email protected]

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/extensions/ERC20Burnable.sol)

pragma solidity ^0.8.0;


/**
 * @dev Extension of {ERC20} that allows token holders to destroy both their own
 * tokens and those that they have an allowance for, in a way that can be
 * recognized off-chain (via event analysis).
 */
abstract contract ERC20Burnable is Context, ERC20 {
    /**
     * @dev Destroys `amount` tokens from the caller.
     *
     * See {ERC20-_burn}.
     */
    function burn(uint256 amount) public virtual {
        _burn(_msgSender(), amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, deducting from the caller's
     * allowance.
     *
     * See {ERC20-_burn} and {ERC20-allowance}.
     *
     * Requirements:
     *
     * - the caller must have allowance for ``accounts``'s tokens of at least
     * `amount`.
     */
    function burnFrom(address account, uint256 amount) public virtual {
        _spendAllowance(account, _msgSender(), amount);
        _burn(account, amount);
    }
}


// File @openzeppelin/contracts/token/ERC20/extensions/[email protected]

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.4) (token/ERC20/extensions/IERC20Permit.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 *
 * ==== Security Considerations
 *
 * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
 * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
 * considered as an intention to spend the allowance in any specific way. The second is that because permits have
 * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
 * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
 * generally recommended is:
 *
 * ```solidity
 * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
 *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
 *     doThing(..., value);
 * }
 *
 * function doThing(..., uint256 value) public {
 *     token.safeTransferFrom(msg.sender, address(this), value);
 *     ...
 * }
 * ```
 *
 * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
 * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
 * {SafeERC20-safeTransferFrom}).
 *
 * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
 * contracts should have entry points that don't rely on permit.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     *
     * CAUTION: See Security Considerations above.
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}


// File @openzeppelin/contracts/utils/[email protected]

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @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.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @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, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * 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.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @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`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

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

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) 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
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}


// File @openzeppelin/contracts/token/ERC20/utils/[email protected]

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.3) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;



/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 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 {
    using Address for address;

    /**
     * @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.encodeWithSelector(token.transfer.selector, 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.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 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.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));
        }
    }

    /**
     * @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.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);

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

    /**
     * @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`.
     * Revert on invalid signature.
     */
    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
    }

    /**
     * @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).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
    }

    /**
     * @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 silents catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false
        // and not revert is the subcall reverts.

        (bool success, bytes memory returndata) = address(token).call(data);
        return
            success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));
    }
}


// File @openzeppelin/contracts/security/[email protected]

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

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

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

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

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

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;
    }

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

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


// File contracts/MiningPowerToken.sol

// Original license: SPDX_License_Identifier: MIT
// Compatible with OpenZeppelin Contracts ^4.9.0
pragma solidity ^0.8.0;



/**
 * @title MiningPowerToken (mTH)
 * @notice Represents mining power backed 1:1 by USDC deposits (after 1% fee)
 * @dev Mintable and burnable only by owner (DepositMTH contract)
 */
contract MiningPowerToken is ERC20, ERC20Burnable, Ownable {
    constructor() ERC20("MiningPowerToken", "mTH") {}

    /**
     * @notice Mint new mTH tokens
     * @param to Recipient address
     * @param amount Amount to mint
     */
    function mint(address to, uint256 amount) public onlyOwner {
        _mint(to, amount);
    }
}


// File contracts/DepositMTH.sol

// Original license: SPDX_License_Identifier: MIT
pragma solidity ^0.8.0;





/**
 * @title DepositMTH
 * @notice Converts USDC deposits to mTH tokens with 1% fee
 * @dev Users deposit USDC, receive mTH 1:1 after fee. Owner can withdraw USDC to buy mining power.
 */
contract DepositMTH is Ownable, ReentrancyGuard {
    using SafeERC20 for IERC20;

    /// @notice USDC token contract
    IERC20 public immutable usdc;
    
    /// @notice mTH token contract
    MiningPowerToken public immutable mth;
    
    /// @notice Fee recipient address (configurable)
    address public feeRecipient;
    
    /// @notice Price of 1 TH in USDC (6 decimals) - set by owner
    uint256 public thPriceUSDC;
    
    /// @notice Deposit fee in basis points (100 = 1%)
    uint256 public constant DEPOSIT_FEE_BPS = 100;
    
    /// @notice Basis points denominator
    uint256 public constant BPS_DENOMINATOR = 10000;
    
    /// @notice Total USDC deposited (after fees)
    uint256 public totalUSDCDeposited;
    
    /// @notice Total fees collected in USDC
    uint256 public totalFeesCollected;
    
    /// @notice Total USDC withdrawn by owner for mining power purchases
    uint256 public totalUSDCWithdrawn;

    /// @notice Emitted when USDC is deposited and mTH is minted
    event Deposit(address indexed user, uint256 usdcAmount, uint256 mthMinted, uint256 fee);
    
    /// @notice Emitted when owner withdraws USDC for mining power
    event USDCWithdrawn(address indexed owner, uint256 amount, string purpose);
    
    /// @notice Emitted when TH price is updated
    event THPriceUpdated(uint256 oldPrice, uint256 newPrice);
    
    /// @notice Emitted when fee recipient is updated
    event FeeRecipientUpdated(address indexed oldRecipient, address indexed newRecipient);
    
    /// @notice Emitted when fees are distributed
    event FeeDistributed(address indexed recipient, uint256 amount);

    /**
     * @notice Constructor
     * @param _usdc USDC token address
     * @param _mth mTH token address
     * @param _feeRecipient Initial fee recipient address
     * @param _initialTHPrice Initial price of 1 TH in USDC (6 decimals)
     */
    constructor(
        address _usdc,
        address _mth,
        address _feeRecipient,
        uint256 _initialTHPrice
    ) {
        require(_usdc != address(0), "Invalid USDC address");
        require(_mth != address(0), "Invalid mTH address");
        require(_feeRecipient != address(0), "Invalid fee recipient");
        require(_initialTHPrice > 0, "TH price must be greater than 0");
        
        usdc = IERC20(_usdc);
        mth = MiningPowerToken(_mth);
        feeRecipient = _feeRecipient;
        thPriceUSDC = _initialTHPrice;
    }

    /**
     * @notice Deposit USDC and receive mTH tokens based on TH price (1% fee applied)
     * @param amount Amount of USDC to deposit
     * @dev User pays thPriceUSDC per TH. Example: if thPriceUSDC = 100 USDC,
     *      user sends 101 USDC (including 1% fee) to receive 1 mTH (1 TH)
     */
    function depositUSDC(uint256 amount) external nonReentrant {
        require(amount > 0, "Amount must be greater than 0");
        require(thPriceUSDC > 0, "TH price not set");
        
        // Calculate fee and net amount
        uint256 fee = (amount * DEPOSIT_FEE_BPS) / BPS_DENOMINATOR;
        uint256 netAmount = amount - fee;
        
        // Calculate mTH to mint based on TH price
        // netAmount (USDC with 6 decimals) / thPriceUSDC (USDC with 6 decimals) * 1e18 (mTH decimals)
        uint256 mthToMint = (netAmount * 1e18) / thPriceUSDC;
        require(mthToMint > 0, "Amount too small to mint mTH");
        
        // Transfer USDC from user
        usdc.safeTransferFrom(msg.sender, address(this), amount);
        
        // Transfer fee to fee recipient
        if (fee > 0) {
            usdc.safeTransfer(feeRecipient, fee);
            totalFeesCollected += fee;
            emit FeeDistributed(feeRecipient, fee);
        }
        
        // Update total deposited
        totalUSDCDeposited += netAmount;
        
        // Mint mTH based on TH price
        mth.mint(msg.sender, mthToMint);
        
        emit Deposit(msg.sender, amount, mthToMint, fee);
    }

    /**
     * @notice Set TH price in USDC
     * @param _newPrice New price of 1 TH in USDC (6 decimals)
     * @dev Example: 100000000 = 100 USDC per TH
     */
    function setTHPrice(uint256 _newPrice) external onlyOwner {
        require(_newPrice > 0, "Price must be greater than 0");
        uint256 oldPrice = thPriceUSDC;
        thPriceUSDC = _newPrice;
        emit THPriceUpdated(oldPrice, _newPrice);
    }

    /**
     * @notice Set new fee recipient address
     * @param _newRecipient New fee recipient address
     */
    function setFeeRecipient(address _newRecipient) external onlyOwner {
        require(_newRecipient != address(0), "Invalid fee recipient");
        address oldRecipient = feeRecipient;
        feeRecipient = _newRecipient;
        emit FeeRecipientUpdated(oldRecipient, _newRecipient);
    }

    /**
     * @notice Get total fees accrued
     * @return Total fees collected in USDC
     */
    function totalFeeAccrued() external view returns (uint256) {
        return totalFeesCollected;
    }

    /**
     * @notice Owner withdraws USDC to purchase mining power
     * @param amount Amount of USDC to withdraw
     * @param purpose Description of withdrawal purpose (e.g., "Mining power purchase")
     */
    function withdrawUSDC(uint256 amount, string calldata purpose) external onlyOwner nonReentrant {
        require(amount > 0, "Amount must be greater than 0");
        require(usdc.balanceOf(address(this)) >= amount, "Insufficient USDC balance");
        
        totalUSDCWithdrawn += amount;
        
        usdc.safeTransfer(owner(), amount);
        
        emit USDCWithdrawn(owner(), amount, purpose);
    }

    /**
     * @notice Get contract's USDC balance
     * @return USDC balance
     */
    function getUSDCBalance() external view returns (uint256) {
        return usdc.balanceOf(address(this));
    }
    
    /**
     * @notice Get available USDC for withdrawal
     * @return Available USDC balance in contract
     */
    function getAvailableUSDC() external view returns (uint256) {
        return usdc.balanceOf(address(this));
    }
    
    /**
     * @notice Calculate how much mTH a user would receive for a given USDC amount
     * @param usdcAmount Amount of USDC to deposit (including fee)
     * @return mthAmount Amount of mTH that would be minted
     * @return fee Fee amount in USDC
     */
    function calculateMTHAmount(uint256 usdcAmount) external view returns (uint256 mthAmount, uint256 fee) {
        require(usdcAmount > 0, "Amount must be greater than 0");
        require(thPriceUSDC > 0, "TH price not set");
        
        fee = (usdcAmount * DEPOSIT_FEE_BPS) / BPS_DENOMINATOR;
        uint256 netAmount = usdcAmount - fee;
        mthAmount = (netAmount * 1e18) / thPriceUSDC;
    }
    
    /**
     * @notice Calculate how much USDC is needed to receive a specific amount of mTH
     * @param mthAmount Desired amount of mTH to receive
     * @return usdcNeeded Total USDC needed (including fee)
     * @return fee Fee amount in USDC
     */
    function calculateUSDCNeeded(uint256 mthAmount) external view returns (uint256 usdcNeeded, uint256 fee) {
        require(mthAmount > 0, "Amount must be greater than 0");
        require(thPriceUSDC > 0, "TH price not set");
        
        // Calculate USDC needed before fee
        uint256 usdcBeforeFee = (mthAmount * thPriceUSDC) / 1e18;
        
        // Calculate total including 1% fee: usdcNeeded = usdcBeforeFee / 0.99
        usdcNeeded = (usdcBeforeFee * BPS_DENOMINATOR) / (BPS_DENOMINATOR - DEPOSIT_FEE_BPS);
        fee = usdcNeeded - usdcBeforeFee;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_usdc","type":"address"},{"internalType":"address","name":"_mth","type":"address"},{"internalType":"address","name":"_feeRecipient","type":"address"},{"internalType":"uint256","name":"_initialTHPrice","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"usdcAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"mthMinted","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"fee","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"FeeDistributed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldRecipient","type":"address"},{"indexed":true,"internalType":"address","name":"newRecipient","type":"address"}],"name":"FeeRecipientUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"oldPrice","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newPrice","type":"uint256"}],"name":"THPriceUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"string","name":"purpose","type":"string"}],"name":"USDCWithdrawn","type":"event"},{"inputs":[],"name":"BPS_DENOMINATOR","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DEPOSIT_FEE_BPS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"usdcAmount","type":"uint256"}],"name":"calculateMTHAmount","outputs":[{"internalType":"uint256","name":"mthAmount","type":"uint256"},{"internalType":"uint256","name":"fee","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"mthAmount","type":"uint256"}],"name":"calculateUSDCNeeded","outputs":[{"internalType":"uint256","name":"usdcNeeded","type":"uint256"},{"internalType":"uint256","name":"fee","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"depositUSDC","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"feeRecipient","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getAvailableUSDC","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getUSDCBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mth","outputs":[{"internalType":"contract MiningPowerToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newRecipient","type":"address"}],"name":"setFeeRecipient","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newPrice","type":"uint256"}],"name":"setTHPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"thPriceUSDC","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalFeeAccrued","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalFeesCollected","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalUSDCDeposited","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalUSDCWithdrawn","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"usdc","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"string","name":"purpose","type":"string"}],"name":"withdrawUSDC","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000b88339cb7199b77e23db6e890353e22632ba630f000000000000000000000000ece944a12fa41db0bff7717c1a228ac24436aed800000000000000000000000032096c8a8cc68e94c309013898bae9344d823a210000000000000000000000000000000000000000000000000000000005f5e100

-----Decoded View---------------
Arg [0] : _usdc (address): 0xb88339CB7199b77E23DB6E890353E22632Ba630f
Arg [1] : _mth (address): 0xece944a12FA41DB0Bff7717C1a228aC24436AED8
Arg [2] : _feeRecipient (address): 0x32096C8a8cc68e94C309013898bAE9344D823a21
Arg [3] : _initialTHPrice (uint256): 100000000

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 000000000000000000000000b88339cb7199b77e23db6e890353e22632ba630f
Arg [1] : 000000000000000000000000ece944a12fa41db0bff7717c1a228ac24436aed8
Arg [2] : 00000000000000000000000032096c8a8cc68e94c309013898bae9344d823a21
Arg [3] : 0000000000000000000000000000000000000000000000000000000005f5e100

47116:7795:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53641:410;;;;;;:::i;:::-;;:::i;:::-;;;;419:25:1;;;475:2;460:18;;453:34;;;;392:18;53641:410:0;;;;;;;;53000:113;;;:::i;:::-;;;644:25:1;;;632:2;617:18;53000:113:0;498:177:1;47243:28:0;;;;;;;;-1:-1:-1;;;;;858:55:1;;;840:74;;828:2;813:18;47243:28:0;680:240:1;52478:423:0;;;;;;:::i;:::-;;:::i;:::-;;51359:257;;;;;;:::i;:::-;;:::i;47424:27::-;;;;;-1:-1:-1;;;;;47424:27:0;;;48049:33;;;;;;47929;;;;;;47531:26;;;;;;47626:45;;47668:3;47626:45;;3101:103;;;:::i;52149:::-;52226:18;;52149:103;;2460:87;2506:7;2533:6;-1:-1:-1;;;;;2533:6:0;2460:87;;54325:583;;;;;;:::i;:::-;;:::i;47837:33::-;;;;;;47726:47;;47768:5;47726:47;;51743:296;;;;;;:::i;:::-;;:::i;3359:201::-;;;;;;:::i;:::-;;:::i;47320:37::-;;;;;49949:1233;;;;;;:::i;:::-;;:::i;53641:410::-;53712:17;53731:11;53776:1;53763:10;:14;53755:56;;;;-1:-1:-1;;;53755:56:0;;2634:2:1;53755:56:0;;;2616:21:1;2673:2;2653:18;;;2646:30;2712:31;2692:18;;;2685:59;2761:18;;53755:56:0;;;;;;;;;53844:1;53830:11;;:15;53822:44;;;;-1:-1:-1;;;53822:44:0;;2992:2:1;53822:44:0;;;2974:21:1;3031:2;3011:18;;;3004:30;-1:-1:-1;;;3050:18:1;;;3043:46;3106:18;;53822:44:0;2790:340:1;53822:44:0;47768:5;53894:28;47668:3;53894:10;:28;:::i;:::-;53893:48;;;;:::i;:::-;53887:54;-1:-1:-1;53952:17:0;53972:16;53887:54;53972:10;:16;:::i;:::-;54032:11;;53952:36;;-1:-1:-1;54012:16:0;53952:36;54024:4;54012:16;:::i;:::-;54011:32;;;;:::i;:::-;53999:44;;53744:307;53641:410;;;:::o;53000:113::-;53076:29;;-1:-1:-1;;;53076:29:0;;53099:4;53076:29;;;840:74:1;53049:7:0;;53076:4;-1:-1:-1;;;;;53076:14:0;;;;813:18:1;;53076:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;53069:36;;53000:113;:::o;52478:423::-;2346:13;:11;:13::i;:::-;45185:21:::1;:19;:21::i;:::-;52601:1:::2;52592:6;:10;52584:52;;;::::0;-1:-1:-1;;;52584:52:0;;2634:2:1;52584:52:0::2;::::0;::::2;2616:21:1::0;2673:2;2653:18;;;2646:30;2712:31;2692:18;;;2685:59;2761:18;;52584:52:0::2;2432:353:1::0;52584:52:0::2;52655:29;::::0;-1:-1:-1;;;52655:29:0;;52678:4:::2;52655:29;::::0;::::2;840:74:1::0;52688:6:0;;52655:4:::2;-1:-1:-1::0;;;;;52655:14:0::2;::::0;::::2;::::0;813:18:1;;52655:29:0::2;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:39;;52647:77;;;::::0;-1:-1:-1;;;52647:77:0;;4300:2:1;52647:77:0::2;::::0;::::2;4282:21:1::0;4339:2;4319:18;;;4312:30;4378:27;4358:18;;;4351:55;4423:18;;52647:77:0::2;4098:349:1::0;52647:77:0::2;52767:6;52745:18;;:28;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;2506:7:0;2533:6;52794:34:::2;::::0;-1:-1:-1;;;;;2533:6:0;-1:-1:-1;;;;;52794:4:0::2;:17;::::0;52821:6;52794:17:::2;:34::i;:::-;2506:7:::0;2533:6;-1:-1:-1;;;;;2533:6:0;-1:-1:-1;;;;;52854:39:0::2;;52877:6;52885:7;;52854:39;;;;;;;;:::i;:::-;;;;;;;;45229:20:::1;44623:1:::0;45749:22;;45566:213;45229:20:::1;52478:423:::0;;;:::o;51359:257::-;2346:13;:11;:13::i;:::-;51448:1:::1;51436:9;:13;51428:54;;;::::0;-1:-1:-1;;;51428:54:0;;5250:2:1;51428:54:0::1;::::0;::::1;5232:21:1::0;5289:2;5269:18;;;5262:30;5328;5308:18;;;5301:58;5376:18;;51428:54:0::1;5048:352:1::0;51428:54:0::1;51512:11;::::0;;51534:23;;;;51573:35:::1;::::0;;419:25:1;;;475:2;460:18;;453:34;;;51573:35:0::1;::::0;392:18:1;51573:35:0::1;;;;;;;51417:199;51359:257:::0;:::o;3101:103::-;2346:13;:11;:13::i;:::-;3166:30:::1;3193:1;3166:18;:30::i;:::-;3101:103::o:0;54325:583::-;54396:18;54416:11;54460:1;54448:9;:13;54440:55;;;;-1:-1:-1;;;54440:55:0;;2634:2:1;54440:55:0;;;2616:21:1;2673:2;2653:18;;;2646:30;2712:31;2692:18;;;2685:59;2761:18;;54440:55:0;2432:353:1;54440:55:0;54528:1;54514:11;;:15;54506:44;;;;-1:-1:-1;;;54506:44:0;;2992:2:1;54506:44:0;;;2974:21:1;3031:2;3011:18;;;3004:30;-1:-1:-1;;;3050:18:1;;;3043:46;3106:18;;54506:44:0;2790:340:1;54506:44:0;54616:21;54668:4;54653:11;;54641:9;:23;;;;:::i;:::-;54640:32;;;;:::i;:::-;54616:56;-1:-1:-1;54823:33:0;47668:3;47768:5;54823:33;:::i;:::-;54787:31;47768:5;54787:13;:31;:::i;:::-;54786:71;;;;:::i;:::-;54773:84;-1:-1:-1;54874:26:0;54887:13;54773:84;54874:26;:::i;:::-;54868:32;;54429:479;54325:583;;;:::o;51743:296::-;2346:13;:11;:13::i;:::-;-1:-1:-1;;;;;51829:27:0;::::1;51821:61;;;::::0;-1:-1:-1;;;51821:61:0;;5607:2:1;51821:61:0::1;::::0;::::1;5589:21:1::0;5646:2;5626:18;;;5619:30;5685:23;5665:18;;;5658:51;5726:18;;51821:61:0::1;5405:345:1::0;51821:61:0::1;51916:12;::::0;;-1:-1:-1;;;;;51939:28:0;;::::1;-1:-1:-1::0;;51939:28:0;::::1;::::0;::::1;::::0;;;51983:48:::1;::::0;51916:12;::::1;::::0;51939:28;51916:12;;51983:48:::1;::::0;51893:20:::1;::::0;51983:48:::1;51810:229;51743:296:::0;:::o;3359:201::-;2346:13;:11;:13::i;:::-;-1:-1:-1;;;;;3448:22:0;::::1;3440:73;;;::::0;-1:-1:-1;;;3440:73:0;;5957:2:1;3440:73:0::1;::::0;::::1;5939:21:1::0;5996:2;5976:18;;;5969:30;6035:34;6015:18;;;6008:62;6106:8;6086:18;;;6079:36;6132:19;;3440:73:0::1;5755:402:1::0;3440:73:0::1;3524:28;3543:8;3524:18;:28::i;:::-;3359:201:::0;:::o;49949:1233::-;45185:21;:19;:21::i;:::-;50036:1:::1;50027:6;:10;50019:52;;;::::0;-1:-1:-1;;;50019:52:0;;2634:2:1;50019:52:0::1;::::0;::::1;2616:21:1::0;2673:2;2653:18;;;2646:30;2712:31;2692:18;;;2685:59;2761:18;;50019:52:0::1;2432:353:1::0;50019:52:0::1;50104:1;50090:11;;:15;50082:44;;;::::0;-1:-1:-1;;;50082:44:0;;2992:2:1;50082:44:0::1;::::0;::::1;2974:21:1::0;3031:2;3011:18;;;3004:30;-1:-1:-1;;;3050:18:1;;;3043:46;3106:18;;50082:44:0::1;2790:340:1::0;50082:44:0::1;50188:11;47768:5;50203:24;47668:3;50203:6:::0;:24:::1;:::i;:::-;50202:44;;;;:::i;:::-;50188:58:::0;-1:-1:-1;50257:17:0::1;50277:12;50188:58:::0;50277:6;:12:::1;:::i;:::-;50257:32;;50466:17;50507:11;;50487:9;50499:4;50487:16;;;;:::i;:::-;50486:32;;;;:::i;:::-;50466:52;;50549:1;50537:9;:13;50529:54;;;::::0;-1:-1:-1;;;50529:54:0;;6364:2:1;50529:54:0::1;::::0;::::1;6346:21:1::0;6403:2;6383:18;;;6376:30;6442;6422:18;;;6415:58;6490:18;;50529:54:0::1;6162:352:1::0;50529:54:0::1;50640:56;-1:-1:-1::0;;;;;50640:4:0::1;:21;50662:10;50682:4;50689:6:::0;50640:21:::1;:56::i;:::-;50763:7:::0;;50759:169:::1;;50805:12;::::0;50787:36:::1;::::0;-1:-1:-1;;;;;50787:4:0::1;:17:::0;::::1;::::0;50805:12:::1;50819:3:::0;50787:17:::1;:36::i;:::-;50860:3;50838:18;;:25;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;50898:12:0::1;::::0;50883:33:::1;::::0;644:25:1;;;-1:-1:-1;;;;;50898:12:0;;::::1;::::0;50883:33:::1;::::0;632:2:1;617:18;50883:33:0::1;;;;;;;50759:169;51005:9;50983:18;;:31;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;51074:31:0::1;::::0;;;;51083:10:::1;51074:31;::::0;::::1;6693:74:1::0;6783:18;;;6776:34;;;51074:3:0::1;-1:-1:-1::0;;;;;51074:8:0::1;::::0;::::1;::::0;6666:18:1;;51074:31:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;51131:43:0::1;::::0;;7023:25:1;;;7079:2;7064:18;;7057:34;;;7107:18;;;7100:34;;;51139:10:0::1;::::0;-1:-1:-1;51131:43:0::1;::::0;-1:-1:-1;7011:2:1;6996:18;51131:43:0::1;;;;;;;50008:1174;;;45229:20:::0;44623:1;45749:22;;45566:213;2625:132;2506:7;2533:6;-1:-1:-1;;;;;2533:6:0;929:10;2689:23;2681:68;;;;-1:-1:-1;;;2681:68:0;;7347:2:1;2681:68:0;;;7329:21:1;;;7366:18;;;7359:30;7425:34;7405:18;;;7398:62;7477:18;;2681:68:0;7145:356:1;45265:293:0;44667:1;45399:7;;:19;45391:63;;;;-1:-1:-1;;;45391:63:0;;7708:2:1;45391:63:0;;;7690:21:1;7747:2;7727:18;;;7720:30;7786:33;7766:18;;;7759:61;7837:18;;45391:63:0;7506:355:1;45391:63:0;44667:1;45532:7;:18;45265:293::o;36668:177::-;36778:58;;-1:-1:-1;;;;;6711:55:1;;36778:58:0;;;6693:74:1;6783:18;;;6776:34;;;36751:86:0;;36771:5;;36801:23;;6666:18:1;;36778:58:0;;;;-1:-1:-1;;36778:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;36751:19;:86::i;3720:191::-;3794:16;3813:6;;-1:-1:-1;;;;;3830:17:0;;;-1:-1:-1;;3830:17:0;;;;;;3863:40;;3813:6;;;;;;;3863:40;;3794:16;3863:40;3783:128;3720:191;:::o;37090:205::-;37218:68;;-1:-1:-1;;;;;8086:55:1;;;37218:68:0;;;8068:74:1;8178:55;;8158:18;;;8151:83;8250:18;;;8243:34;;;37191:96:0;;37211:5;;37241:27;;8041:18:1;;37218:68:0;7866:417:1;37191:96:0;37090:205;;;;:::o;41014:649::-;41438:23;41464:69;41492:4;41464:69;;;;;;;;;;;;;;;;;41472:5;-1:-1:-1;;;;;41464:27:0;;;:69;;;;;:::i;:::-;41438:95;;41552:10;:17;41573:1;41552:22;:56;;;;41589:10;41578:30;;;;;;;;;;;;:::i;:::-;41544:111;;;;-1:-1:-1;;;41544:111:0;;8772:2:1;41544:111:0;;;8754:21:1;8811:2;8791:18;;;8784:30;8850:34;8830:18;;;8823:62;8921:12;8901:18;;;8894:40;8951:19;;41544:111:0;8570:406:1;30307:229:0;30444:12;30476:52;30498:6;30506:4;30512:1;30515:12;30476:21;:52::i;:::-;30469:59;30307:229;-1:-1:-1;;;;30307:229:0:o;31393:455::-;31563:12;31621:5;31596:21;:30;;31588:81;;;;-1:-1:-1;;;31588:81:0;;9183:2:1;31588:81:0;;;9165:21:1;9222:2;9202:18;;;9195:30;9261:34;9241:18;;;9234:62;9332:8;9312:18;;;9305:36;9358:19;;31588:81:0;8981:402:1;31588:81:0;31681:12;31695:23;31722:6;-1:-1:-1;;;;;31722:11:0;31741:5;31748:4;31722:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;31680:73;;;;31771:69;31798:6;31806:7;31815:10;31827:12;31771:26;:69::i;:::-;31764:76;31393:455;-1:-1:-1;;;;;;;31393:455:0:o;33966:644::-;34151:12;34180:7;34176:427;;;34208:10;:17;34229:1;34208:22;34204:290;;-1:-1:-1;;;;;27847:19:0;;;34418:60;;;;-1:-1:-1;;;34418:60:0;;10137:2:1;34418:60:0;;;10119:21:1;10176:2;10156:18;;;10149:30;10215:31;10195:18;;;10188:59;10264:18;;34418:60:0;9935:353:1;34418:60:0;-1:-1:-1;34515:10:0;34508:17;;34176:427;34558:33;34566:10;34578:12;35313:17;;:21;35309:388;;35545:10;35539:17;35602:15;35589:10;35585:2;35581:19;35574:44;35309:388;35672:12;35665:20;;-1:-1:-1;;;35665:20:0;;;;;;;;:::i;14:226:1:-;73:6;126:2;114:9;105:7;101:23;97:32;94:52;;;142:1;139;132:12;94:52;-1:-1:-1;187:23:1;;14:226;-1:-1:-1;14:226:1:o;925:701::-;1005:6;1013;1021;1074:2;1062:9;1053:7;1049:23;1045:32;1042:52;;;1090:1;1087;1080:12;1042:52;1135:23;;;-1:-1:-1;1233:2:1;1218:18;;1205:32;1260:18;1249:30;;1246:50;;;1292:1;1289;1282:12;1246:50;1315:22;;1368:4;1360:13;;1356:27;-1:-1:-1;1346:55:1;;1397:1;1394;1387:12;1346:55;1437:2;1424:16;1463:18;1455:6;1452:30;1449:50;;;1495:1;1492;1485:12;1449:50;1540:7;1535:2;1526:6;1522:2;1518:15;1514:24;1511:37;1508:57;;;1561:1;1558;1551:12;1508:57;925:701;;1592:2;1584:11;;;;;-1:-1:-1;1614:6:1;;-1:-1:-1;;;925:701:1:o;1862:309::-;1921:6;1974:2;1962:9;1953:7;1949:23;1945:32;1942:52;;;1990:1;1987;1980:12;1942:52;2029:9;2016:23;-1:-1:-1;;;;;2072:5:1;2068:54;2061:5;2058:65;2048:93;;2137:1;2134;2127:12;2048:93;2160:5;1862:309;-1:-1:-1;;;1862:309:1:o;3135:184::-;-1:-1:-1;;;3184:1:1;3177:88;3284:4;3281:1;3274:15;3308:4;3305:1;3298:15;3324:168;3397:9;;;3428;;3445:15;;;3439:22;;3425:37;3415:71;;3466:18;;:::i;:::-;3324:168;;;;:::o;3497:274::-;3537:1;3563;3553:189;;-1:-1:-1;;;3595:1:1;3588:88;3699:4;3696:1;3689:15;3727:4;3724:1;3717:15;3553:189;-1:-1:-1;3756:9:1;;3497:274::o;3776:128::-;3843:9;;;3864:11;;;3861:37;;;3878:18;;:::i;3909:184::-;3979:6;4032:2;4020:9;4011:7;4007:23;4003:32;4000:52;;;4048:1;4045;4038:12;4000:52;-1:-1:-1;4071:16:1;;3909:184;-1:-1:-1;3909:184:1:o;4452:125::-;4517:9;;;4538:10;;;4535:36;;;4551:18;;:::i;4582:461::-;4769:6;4758:9;4751:25;4812:2;4807;4796:9;4792:18;4785:30;4851:6;4846:2;4835:9;4831:18;4824:34;4908:6;4900;4895:2;4884:9;4880:18;4867:48;4964:1;4935:22;;;4959:2;4931:31;;;4924:42;;;;5027:2;5006:15;;;-1:-1:-1;;5002:29:1;4987:45;4983:54;;4582:461;-1:-1:-1;;4582:461:1:o;8288:277::-;8355:6;8408:2;8396:9;8387:7;8383:23;8379:32;8376:52;;;8424:1;8421;8414:12;8376:52;8456:9;8450:16;8509:5;8502:13;8495:21;8488:5;8485:32;8475:60;;8531:1;8528;8521:12;9388:250;9473:1;9483:113;9497:6;9494:1;9491:13;9483:113;;;9573:11;;;9567:18;9554:11;;;9547:39;9519:2;9512:10;9483:113;;;-1:-1:-1;;9630:1:1;9612:16;;9605:27;9388:250::o;9643:287::-;9772:3;9810:6;9804:13;9826:66;9885:6;9880:3;9873:4;9865:6;9861:17;9826:66;:::i;:::-;9908:16;;;;;9643:287;-1:-1:-1;;9643:287:1:o;10293:396::-;10442:2;10431:9;10424:21;10405:4;10474:6;10468:13;10517:6;10512:2;10501:9;10497:18;10490:34;10533:79;10605:6;10600:2;10589:9;10585:18;10580:2;10572:6;10568:15;10533:79;:::i;:::-;10673:2;10652:15;-1:-1:-1;;10648:29:1;10633:45;;;;10680:2;10629:54;;10293:396;-1:-1:-1;;10293:396:1:o

ipfs://33c8eca6f33203dd754f59049ec28d684dc7d004d8129209b68b4c55cb07a5bb