Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at SonicScan.org on 2025-04-24
*/

// SPDX-License-Identifier: MIT


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);
}



pragma solidity ^0.8.20;


/**
 * @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);
}



pragma solidity ^0.8.20;

/**
 * @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;
    }
}


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);
}



pragma solidity ^0.8.20;





/**
 * @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 ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {
    mapping(address account => uint256) private _balances;

    mapping(address account => mapping(address spender => 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 returns (string memory) {
        return _name;
    }

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

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

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual 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 `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) {
        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 {
        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 {
        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);
            }
        }
    }
}


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);
}



pragma solidity ^0.8.20;



/**
 * @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);
}



pragma solidity ^0.8.20;



/**
 * @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);
    }
}



pragma solidity ^0.8.20;


/**
 * @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 Ownable is Context {
    address private _owner;

    /**
     * @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.
     */
    constructor(address initialOwner) {
        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) {
        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 {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}


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;
    }
}



pragma solidity ^0.8.0;


/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

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

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() {
        _paused = false;
    }

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

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

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Throws if the contract is paused.
     */
    function _requireNotPaused() internal view virtual {
        require(!paused(), "Pausable: paused");
    }

    /**
     * @dev Throws if the contract is not paused.
     */
    function _requirePaused() internal view virtual {
        require(paused(), "Pausable: not paused");
    }

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

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



pragma solidity ^0.8.0;






interface ITaxToken {
    function balanceOf(address account) external view returns (uint256);
    function transfer(address to, uint256 amount) external returns (bool);
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function excludeFromTax(address account) external;
    function burn (uint256 amount) external;
}

contract Geode is ERC20, Ownable, ReentrancyGuard, Pausable {
    using SafeERC20 for IERC20;

    ITaxToken public immutable taxToken;
    
    // Minimum deposit amount to prevent dust attacks
    uint256 public minDepositAmount;
    
    event Deposit(address indexed user, uint256 taxTokenAmount, uint256 wrappedAmount);
    event Withdraw(address indexed user, uint256 wrappedAmount, uint256 taxTokenAmount);
    event MinDepositAmountUpdated(uint256 newMinimum);
    event TokensRescued(address token, address to, uint256 amount);

    constructor(
        address _taxToken,
        string memory name,
        string memory symbol,
        uint256 _minDepositAmount
    ) ERC20(name, symbol) Ownable(msg.sender) {
        require(_taxToken != address(0), "Invalid tax token address");
        taxToken = ITaxToken(_taxToken);
        minDepositAmount = _minDepositAmount;
        
    }

    /**
     * @notice Calculate shares to mint for a given amount of tax tokens
     * @param _amount Amount of tax tokens
     * @return Number of shares to mint
     */
    function _getSharesForDeposit(uint256 _amount) internal view returns (uint256) {
        uint256 totalTokens = taxToken.balanceOf(address(this));
        uint256 totalShares = totalSupply();
        
        // For the first deposit, use 1:1 ratio
        if (totalShares == 0 || totalTokens == 0) {
            return _amount;
        }
        
        // Calculate shares based on current ratio
        return (_amount * totalShares) / totalTokens;
    }

    /**
     * @notice Calculate tax tokens to return for a given amount of shares
     * @param _shares Amount of shares
     * @return Number of tax tokens to return
     */
    function _getTokensForShares(uint256 _shares) internal view returns (uint256) {
        uint256 totalTokens = taxToken.balanceOf(address(this));
        uint256 totalShares = totalSupply();
        
        if (totalShares == 0) {
            return 0;
        }
        
        // Calculate tokens based on current ratio
        return (_shares * totalTokens) / totalShares;
    }

    /**
     * @notice Deposit tax tokens and receive wrapped tokens
     * @param _amount Amount of tax tokens to deposit
     */
    function deposit(uint256 _amount) external nonReentrant whenNotPaused {
        require(_amount >= minDepositAmount, "Amount below minimum");
        
        // Check allowance
        uint256 allowance = taxToken.allowance(msg.sender, address(this));
        require(allowance >= _amount, "Insufficient allowance");
        
        // Get balance before transfer to handle fee-on-transfer tokens correctly
        uint256 balanceBefore = taxToken.balanceOf(address(this));
        
        // Transfer tax tokens to this contract
        SafeERC20.safeTransferFrom(IERC20(address(taxToken)), msg.sender, address(this), _amount);
        
        // Calculate actual amount received (handles potential tax)
        uint256 actualReceived = taxToken.balanceOf(address(this)) - balanceBefore;
        require(actualReceived > 0, "No tokens received");
        
        // Calculate shares
        uint256 shares = _getSharesForDeposit(actualReceived);
        require(shares > 0, "Shares calculation error");
        
        // Mint wrapped tokens to user
        _mint(msg.sender, shares);
        
        emit Deposit(msg.sender, actualReceived, shares);
    }

    /**
 * @notice Withdraw tax tokens by burning wrapped tokens
 * @param _shares Amount of wrapped tokens to burn
 */
function withdraw(uint256 _shares) external nonReentrant whenNotPaused {
    require(_shares > 0, "Cannot withdraw 0");
    require(balanceOf(msg.sender) >= _shares, "Insufficient balance");
    
    // Calculate total tokens to return before fees
    uint256 totalTokenAmount = _getTokensForShares(_shares);
    require(totalTokenAmount > 0, "Amount calculation error");
    
    // Define withdrawal fee percentages using local variables (in basis points)
    uint256 totalFeePercent = 1000; // 10% total fee
    uint256 burnFeePercent = 200;   // 2% is burned
    
    // Calculate withdrawal fees
    uint256 totalFeeAmount = (totalTokenAmount * totalFeePercent) / 10000;
    uint256 burnFeeAmount = (totalTokenAmount * burnFeePercent) / 10000;
    
    // Amount user will actually receive
    uint256 finalUserAmount = totalTokenAmount - totalFeeAmount;
    
    // Burn wrapper tokens 
    _burn(msg.sender, _shares);
    
    // Burn the fee tokens 
    taxToken.burn(burnFeeAmount);
    
    // Transfer tax tokens back to user
    SafeERC20.safeTransfer(IERC20(address(taxToken)), msg.sender, finalUserAmount);
    
    emit Withdraw(msg.sender, _shares, finalUserAmount);
}

    /**
     * @notice Get the current exchange rate between wrapper and tax token
     * @return Current exchange rate (in terms of how many tax tokens 1 wrapper token is worth)
     */
    function exchangeRate() external view returns (uint256) {
        uint256 totalTokens = taxToken.balanceOf(address(this));
        uint256 totalShares = totalSupply();
        
        if (totalShares == 0) {
            return 0;
        }
        
        return (totalTokens * 1e18) / totalShares;
    }

    /**
     * @notice Get the amount of tax tokens that would be received for burning shares
     * @param _shares Amount of wrapped tokens
     * @return Amount of tax tokens that would be received
     */
    function previewWithdraw(uint256 _shares) external view returns (uint256) {
    uint256 totalAmount = _getTokensForShares(_shares);
    uint256 feeAmount = (totalAmount * 1000) / 10000; // 10% fee
    return totalAmount - feeAmount; // Return amount after fees
}

    /**
     * @notice Get the amount of shares that would be minted for depositing tokens
     * @param _amount Amount of tax tokens
     * @return Amount of shares that would be minted
     */
    function previewDeposit(uint256 _amount) external view returns (uint256) {
        return _getSharesForDeposit(_amount);
    }

    /**
     * @notice Set minimum deposit amount
     * @param _minAmount New minimum amount
     */
    function setMinDepositAmount(uint256 _minAmount) external onlyOwner {
        minDepositAmount = _minAmount;
        emit MinDepositAmountUpdated(_minAmount);
    }

    /**
     * @notice Pause deposits and withdrawals
     */
    function pause() external onlyOwner {
        _pause();
    }

    /**
     * @notice Unpause deposits and withdrawals
     */
    function unpause() external onlyOwner {
        _unpause();
    }

    /**
     * @notice Rescue tokens accidentally sent to this contract (except taxToken)
     * @param tokenAddress The token address to rescue
     * @param to Address to send the tokens to
     * @param amount Amount of tokens to rescue
     */
    function rescueTokens(address tokenAddress, address to, uint256 amount) external onlyOwner {
        require(tokenAddress != address(taxToken), "Cannot rescue base token");
        require(to != address(0), "Cannot send to zero address");
        
        SafeERC20.safeTransfer(IERC20(tokenAddress), to, amount);
        emit TokensRescued(tokenAddress, to, amount);
    }

}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_taxToken","type":"address"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"uint256","name":"_minDepositAmount","type":"uint256"}],"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":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"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":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"taxTokenAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"wrappedAmount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newMinimum","type":"uint256"}],"name":"MinDepositAmountUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TokensRescued","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"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":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"wrappedAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"taxTokenAmount","type":"uint256"}],"name":"Withdraw","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":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"exchangeRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minDepositAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"previewDeposit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_shares","type":"uint256"}],"name":"previewWithdraw","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"tokenAddress","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"rescueTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_minAmount","type":"uint256"}],"name":"setMinDepositAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"taxToken","outputs":[{"internalType":"contract ITaxToken","name":"","type":"address"}],"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":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_shares","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0000000000000000000000008748d221ca477cd3b4af3229991b3c4fad0ce312000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000c0000000000000000000000000000000000000000000000000016345785d8a0000000000000000000000000000000000000000000000000000000000000000001847656f6465202d20416d65746879737420577261707065720000000000000000000000000000000000000000000000000000000000000000000000000000000547454f4445000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _taxToken (address): 0x8748d221CA477cd3b4AF3229991b3c4faD0cE312
Arg [1] : name (string): Geode - Amethyst Wrapper
Arg [2] : symbol (string): GEODE
Arg [3] : _minDepositAmount (uint256): 100000000000000000

-----Encoded View---------------
8 Constructor Arguments found :
Arg [0] : 0000000000000000000000008748d221ca477cd3b4af3229991b3c4fad0ce312
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [2] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [3] : 000000000000000000000000000000000000000000000000016345785d8a0000
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000018
Arg [5] : 47656f6465202d20416d65746879737420577261707065720000000000000000
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [7] : 47454f4445000000000000000000000000000000000000000000000000000000

45408:7366:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12333:91;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;14626:190;;;;;;:::i;:::-;;:::i;:::-;;;1085:14:1;;1078:22;1060:41;;1048:2;1033:18;14626:190:0;920:187:1;50967:266:0;;;;;;:::i;:::-;;:::i;:::-;;;1489:25:1;;;1477:2;1462:18;50967:266:0;1343:177:1;13435:99:0;13514:12;;13435:99;;45510:35;;;;;;;;;;;;:::i;15426:249::-;;;;;;:::i;:::-;;:::i;51683:167::-;;;;;;:::i;:::-;;:::i;:::-;;49019:1213;;;;;;:::i;:::-;;:::i;13286:84::-;;;13360:2;2272:36:1;;2260:2;2245:18;13286:84:0;2130:184:1;50431:315:0;;;:::i;52061:67::-;;;:::i;43922:86::-;43993:7;;;;43922:86;;45613:31;;;;;;13597:118;;;;;;:::i;:::-;-1:-1:-1;;;;;13689:18:0;13662:7;13689:18;;;;;;;;;;;;13597:118;38451:103;;;:::i;51923:63::-;;;:::i;37776:87::-;37849:6;;-1:-1:-1;;;;;37849:6:0;37776:87;;12543:95;;;:::i;13920:182::-;;;;;;:::i;:::-;;:::i;47702:1189::-;;;;;;:::i;:::-;;:::i;52390:379::-;;;;;;:::i;:::-;;:::i;14165:142::-;;;;;;:::i;:::-;;:::i;51441:128::-;;;;;;:::i;:::-;;:::i;38709:220::-;;;;;;:::i;:::-;;:::i;12333:91::-;12378:13;12411:5;12404:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12333:91;:::o;14626:190::-;14699:4;3990:10;14755:31;3990:10;14771:7;14780:5;14755:8;:31::i;:::-;14804:4;14797:11;;;14626:190;;;;;:::o;50967:266::-;51032:7;51048:19;51070:28;51090:7;51070:19;:28::i;:::-;51048:50;-1:-1:-1;51105:17:0;51148:5;51126:18;51048:50;51140:4;51126:18;:::i;:::-;51125:28;;;;:::i;:::-;51105:48;-1:-1:-1;51178:23:0;51105:48;51178:11;:23;:::i;:::-;51171:30;50967:266;-1:-1:-1;;;;50967:266:0:o;15426:249::-;15513:4;3990:10;15571:37;15587:4;3990:10;15602:5;15571:15;:37::i;:::-;15619:26;15629:4;15635:2;15639:5;15619:9;:26::i;:::-;-1:-1:-1;15663:4:0;;15426:249;-1:-1:-1;;;;15426:249:0:o;51683:167::-;37662:13;:11;:13::i;:::-;51762:16:::1;:29:::0;;;51807:35:::1;::::0;1489:25:1;;;51807:35:0::1;::::0;1477:2:1;1462:18;51807:35:0::1;;;;;;;51683:167:::0;:::o;49019:1213::-;41485:21;:19;:21::i;:::-;43527:19:::1;:17;:19::i;:::-;49115:1:::2;49105:7;:11;49097:41;;;::::0;-1:-1:-1;;;49097:41:0;;4230:2:1;49097:41:0::2;::::0;::::2;4212:21:1::0;4269:2;4249:18;;;4242:30;-1:-1:-1;;;4288:18:1;;;4281:47;4345:18;;49097:41:0::2;;;;;;;;;49163:10;13662:7:::0;13689:18;;;;;;;;;;;49178:7;-1:-1:-1;49153:32:0::2;49145:65;;;::::0;-1:-1:-1;;;49145:65:0;;4576:2:1;49145:65:0::2;::::0;::::2;4558:21:1::0;4615:2;4595:18;;;4588:30;-1:-1:-1;;;4634:18:1;;;4627:50;4694:18;;49145:65:0::2;4374:344:1::0;49145:65:0::2;49276:24;49303:28;49323:7;49303:19;:28::i;:::-;49276:55;;49365:1;49346:16;:20;49338:57;;;::::0;-1:-1:-1;;;49338:57:0;;4925:2:1;49338:57:0::2;::::0;::::2;4907:21:1::0;4964:2;4944:18;;;4937:30;-1:-1:-1;;;4983:18:1;;;4976:54;5047:18;;49338:57:0::2;4723:348:1::0;49338:57:0::2;49516:4;49569:3;49490:23;49701:5;49663:34;49516:4:::0;49663:16;:34:::2;:::i;:::-;49662:44;;;;:::i;:::-;49637:69:::0;-1:-1:-1;49713:21:0::2;49775:5;49738:33;49757:14:::0;49738:16;:33:::2;:::i;:::-;49737:43;;;;:::i;:::-;49713:67:::0;-1:-1:-1;49835:23:0::2;49861:33;49880:14:::0;49861:16;:33:::2;:::i;:::-;49835:59;;49936:26;49942:10;49954:7;49936:5;:26::i;:::-;50004:28;::::0;-1:-1:-1;;;50004:28:0;;::::2;::::0;::::2;1489:25:1::0;;;50004:8:0::2;-1:-1:-1::0;;;;;50004:13:0::2;::::0;::::2;::::0;1462:18:1;;50004:28:0::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50086:78;50124:8;50136:10;50148:15;50086:22;:78::i;:::-;50182:46;::::0;;5250:25:1;;;5306:2;5291:18;;5284:34;;;50191:10:0::2;::::0;50182:46:::2;::::0;5223:18:1;50182:46:0::2;;;;;;;49090:1142;;;;;;41529:20:::0;40923:1;42049:7;:22;41866:213;41529:20;49019:1213;:::o;50431:315::-;50478:7;50498:19;50520:8;-1:-1:-1;;;;;50520:18:0;;50547:4;50520:33;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;50498:55;;50564:19;50586:13;13514:12;;;13435:99;50586:13;50564:35;;50624:11;50639:1;50624:16;50620:57;;50664:1;50657:8;;;;50431:315;:::o;50620:57::-;50727:11;50705:18;:11;50719:4;50705:18;:::i;:::-;50704:34;;;;:::i;:::-;50697:41;;;;50431:315;:::o;52061:67::-;37662:13;:11;:13::i;:::-;52110:10:::1;:8;:10::i;:::-;52061:67::o:0;38451:103::-;37662:13;:11;:13::i;:::-;38516:30:::1;38543:1;38516:18;:30::i;51923:63::-:0;37662:13;:11;:13::i;:::-;51970:8:::1;:6;:8::i;12543:95::-:0;12590:13;12623:7;12616:14;;;;;:::i;13920:182::-;13989:4;3990:10;14045:27;3990:10;14062:2;14066:5;14045:9;:27::i;47702:1189::-;41485:21;:19;:21::i;:::-;43527:19:::1;:17;:19::i;:::-;47802:16:::2;;47791:7;:27;;47783:60;;;::::0;-1:-1:-1;;;47783:60:0;;5720:2:1;47783:60:0::2;::::0;::::2;5702:21:1::0;5759:2;5739:18;;;5732:30;-1:-1:-1;;;5778:18:1;;;5771:50;5838:18;;47783:60:0::2;5518:344:1::0;47783:60:0::2;47912:45;::::0;-1:-1:-1;;;47912:45:0;;47931:10:::2;47912:45;::::0;::::2;6041:51:1::0;47951:4:0::2;6108:18:1::0;;;6101:60;47892:17:0::2;::::0;47912:8:::2;-1:-1:-1::0;;;;;47912:18:0::2;::::0;::::2;::::0;6014::1;;47912:45:0::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;47892:65;;47989:7;47976:9;:20;;47968:55;;;::::0;-1:-1:-1;;;47968:55:0;;6374:2:1;47968:55:0::2;::::0;::::2;6356:21:1::0;6413:2;6393:18;;;6386:30;-1:-1:-1;;;6432:18:1;;;6425:52;6494:18;;47968:55:0::2;6172:346:1::0;47968:55:0::2;48151:33;::::0;-1:-1:-1;;;48151:33:0;;48127:21:::2;::::0;-1:-1:-1;;;;;48151:8:0::2;:18;::::0;::::2;::::0;:33:::2;::::0;48178:4:::2;::::0;48151:33:::2;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;48127:57;;48254:89;48296:8;48308:10;48328:4;48335:7;48254:26;:89::i;:::-;48433:22;48494:13;48458:8;-1:-1:-1::0;;;;;48458:18:0::2;;48485:4;48458:33;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:49;;;;:::i;:::-;48433:74;;48543:1;48526:14;:18;48518:49;;;::::0;-1:-1:-1;;;48518:49:0;;6725:2:1;48518:49:0::2;::::0;::::2;6707:21:1::0;6764:2;6744:18;;;6737:30;-1:-1:-1;;;6783:18:1;;;6776:48;6841:18;;48518:49:0::2;6523:342:1::0;48518:49:0::2;48617:14;48634:36;48655:14;48634:20;:36::i;:::-;48617:53;;48698:1;48689:6;:10;48681:47;;;::::0;-1:-1:-1;;;48681:47:0;;7072:2:1;48681:47:0::2;::::0;::::2;7054:21:1::0;7111:2;7091:18;;;7084:30;-1:-1:-1;;;7130:18:1;;;7123:54;7194:18;;48681:47:0::2;6870:348:1::0;48681:47:0::2;48789:25;48795:10;48807:6;48789:5;:25::i;:::-;48840:43;::::0;;5250:25:1;;;5306:2;5291:18;;5284:34;;;48848:10:0::2;::::0;48840:43:::2;::::0;5223:18:1;48840:43:0::2;;;;;;;47772:1119;;;;41529:20:::0;40923:1;42049:7;:22;41866:213;52390:379;37662:13;:11;:13::i;:::-;52524:8:::1;-1:-1:-1::0;;;;;52500:33:0::1;:12;-1:-1:-1::0;;;;;52500:33:0::1;::::0;52492:70:::1;;;::::0;-1:-1:-1;;;52492:70:0;;7425:2:1;52492:70:0::1;::::0;::::1;7407:21:1::0;7464:2;7444:18;;;7437:30;-1:-1:-1;;;7483:18:1;;;7476:54;7547:18;;52492:70:0::1;7223:348:1::0;52492:70:0::1;-1:-1:-1::0;;;;;52581:16:0;::::1;52573:56;;;::::0;-1:-1:-1;;;52573:56:0;;7778:2:1;52573:56:0::1;::::0;::::1;7760:21:1::0;7817:2;7797:18;;;7790:30;7856:29;7836:18;;;7829:57;7903:18;;52573:56:0::1;7576:351:1::0;52573:56:0::1;52650;52680:12;52695:2;52699:6;52650:22;:56::i;:::-;52722:39;52736:12;52750:2;52754:6;52722:39;;;;;;;;:::i;:::-;;;;;;;;52390:379:::0;;;:::o;14165:142::-;-1:-1:-1;;;;;14272:18:0;;;14245:7;14272:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;14165:142::o;51441:128::-;51505:7;51532:29;51553:7;51532:20;:29::i;38709:220::-;37662:13;:11;:13::i;:::-;-1:-1:-1;;;;;38794:22:0;::::1;38790:93;;38868:1;38840:31;;-1:-1:-1::0;;;38840:31:0::1;;;;;;;;:::i;38790:93::-;38893:28;38912:8;38893:18;:28::i;19485:130::-:0;19570:37;19579:5;19586:7;19595:5;19602:4;19570:8;:37::i;:::-;19485:130;;;:::o;47167:392::-;47236:7;47256:19;47278:8;-1:-1:-1;;;;;47278:18:0;;47305:4;47278:33;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;47256:55;;47322:19;47344:13;13514:12;;;13435:99;47344:13;47322:35;;47382:11;47397:1;47382:16;47378:57;;-1:-1:-1;47422:1:0;;47167:392;-1:-1:-1;;;47167:392:0:o;47378:57::-;47540:11;47515:21;47525:11;47515:7;:21;:::i;:::-;47514:37;;;;:::i;21217:486::-;21317:24;21344:25;21354:5;21361:7;21344:9;:25::i;:::-;21317:52;;-1:-1:-1;;21384:16:0;:36;21380:316;;;21460:5;21441:16;:24;21437:132;;;21520:7;21529:16;21547:5;21493:60;;-1:-1:-1;;;21493:60:0;;;;;;;;;;:::i;21437:132::-;21612:57;21621:5;21628:7;21656:5;21637:16;:24;21663:5;21612:8;:57::i;:::-;21306:397;21217:486;;;:::o;16060:308::-;-1:-1:-1;;;;;16144:18:0;;16140:88;;16213:1;16186:30;;-1:-1:-1;;;16186:30:0;;;;;;;;:::i;16140:88::-;-1:-1:-1;;;;;16242:16:0;;16238:88;;16311:1;16282:32;;-1:-1:-1;;;16282:32:0;;;;;;;;:::i;16238:88::-;16336:24;16344:4;16350:2;16354:5;16336:7;:24::i;37941:166::-;37849:6;;-1:-1:-1;;;;;37849:6:0;3990:10;38001:23;37997:103;;3990:10;38048:40;;-1:-1:-1;;;38048:40:0;;;;;;;;:::i;41565:293::-;40967:1;41699:7;;:19;41691:63;;;;-1:-1:-1;;;41691:63:0;;8860:2:1;41691:63:0;;;8842:21:1;8899:2;8879:18;;;8872:30;8938:33;8918:18;;;8911:61;8989:18;;41691:63:0;8658:355:1;41691:63:0;40967:1;41832:7;:18;41565:293::o;44081:108::-;43993:7;;;;44151:9;44143:38;;;;-1:-1:-1;;;44143:38:0;;9220:2:1;44143:38:0;;;9202:21:1;9259:2;9239:18;;;9232:30;-1:-1:-1;;;9278:18:1;;;9271:46;9334:18;;44143:38:0;9018:340:1;18721:211:0;-1:-1:-1;;;;;18792:21:0;;18788:91;;18864:1;18837:30;;-1:-1:-1;;;18837:30:0;;;;;;;;:::i;18788:91::-;18889:35;18897:7;18914:1;18918:5;18889:7;:35::i;:::-;18721:211;;:::o;27891:162::-;28001:43;;-1:-1:-1;;;;;9555:32:1;;;28001:43:0;;;9537:51:1;9604:18;;;9597:34;;;27974:71:0;;27994:5;;28016:14;;;;;9510:18:1;;28001:43:0;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;28001:43:0;;;;;;;;;;;27974:19;:71::i;44777:120::-;43786:16;:14;:16::i;:::-;44836:7:::1;:15:::0;;-1:-1:-1;;44836:15:0::1;::::0;;44867:22:::1;3990:10:::0;44876:12:::1;44867:22;;;;;;:::i;:::-;;;;;;;;44777:120::o:0;39089:191::-;39182:6;;;-1:-1:-1;;;;;39199:17:0;;;-1:-1:-1;;;;;;39199:17:0;;;;;;;39232:40;;39182:6;;;39199:17;39182:6;;39232:40;;39163:16;;39232:40;39152:128;39089:191;:::o;44518:118::-;43527:19;:17;:19::i;:::-;44578:7:::1;:14:::0;;-1:-1:-1;;44578:14:0::1;44588:4;44578:14;::::0;;44608:20:::1;44615:12;3990:10:::0;;3910:98;28298:190;28399:81;28419:5;28441;-1:-1:-1;;;;;28441:18:0;;28462:4;28468:2;28472:5;28426:53;;;;;;;;;;:::i;46510:468::-;46580:7;46600:19;46622:8;-1:-1:-1;;;;;46622:18:0;;46649:4;46622:33;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;46600:55;;46666:19;46688:13;13514:12;;;13435:99;46688:13;46666:35;-1:-1:-1;46775:16:0;;;:36;;-1:-1:-1;46795:16:0;;46775:36;46771:83;;;-1:-1:-1;46835:7:0;;46510:468;-1:-1:-1;;46510:468:0:o;46771:83::-;46959:11;46934:21;46944:11;46934:7;:21;:::i;18180:213::-;-1:-1:-1;;;;;18251:21:0;;18247:93;;18325:1;18296:32;;-1:-1:-1;;;18296:32:0;;;;;;;;:::i;18247:93::-;18350:35;18366:1;18370:7;18379:5;18350:7;:35::i;20482:443::-;-1:-1:-1;;;;;20595:19:0;;20591:91;;20667:1;20638:32;;-1:-1:-1;;;20638:32:0;;;;;;;;:::i;20591:91::-;-1:-1:-1;;;;;20696:21:0;;20692:92;;20769:1;20741:31;;-1:-1:-1;;;20741:31:0;;;;;;;;:::i;20692:92::-;-1:-1:-1;;;;;20794:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;:35;;;20840:78;;;;20891:7;-1:-1:-1;;;;;20875:31:0;20884:5;-1:-1:-1;;;;;20875:31:0;;20900:5;20875:31;;;;1489:25:1;;1477:2;1462:18;;1343:177;20875:31:0;;;;;;;;20482:443;;;;:::o;16692:1135::-;-1:-1:-1;;;;;16782:18:0;;16778:552;;16936:5;16920:12;;:21;;;;;;;:::i;:::-;;;;-1:-1:-1;16778:552:0;;-1:-1:-1;16778:552:0;;-1:-1:-1;;;;;16996:15:0;;16974:19;16996:15;;;;;;;;;;;17030:19;;;17026:117;;;17102:4;17108:11;17121:5;17077:50;;-1:-1:-1;;;17077:50:0;;;;;;;;;;:::i;17026:117::-;-1:-1:-1;;;;;17266:15:0;;:9;:15;;;;;;;;;;17284:19;;;;17266:37;;16778:552;-1:-1:-1;;;;;17346:16:0;;17342:435;;17512:12;:21;;;;;;;17342:435;;;-1:-1:-1;;;;;17728:13:0;;:9;:13;;;;;;;;;;:22;;;;;;17342:435;17809:2;-1:-1:-1;;;;;17794:25:0;17803:4;-1:-1:-1;;;;;17794:25:0;;17813:5;17794:25;;;;1489::1;;1477:2;1462:18;;1343:177;17794:25:0;;;;;;;;16692:1135;;;:::o;34484:738::-;34565:18;34594:19;34734:4;34731:1;34724:4;34718:11;34711:4;34705;34701:15;34698:1;34691:5;34684;34679:60;34793:7;34783:180;;34838:4;34832:11;34884:16;34881:1;34876:3;34861:40;34931:16;34926:3;34919:29;34783:180;-1:-1:-1;;35042:1:0;35036:8;34991:16;;-1:-1:-1;35071:15:0;;:68;;35123:11;35138:1;35123:16;;35071:68;;;-1:-1:-1;;;;;35089:26:0;;;:31;35071:68;35067:148;;;35196:5;35163:40;;-1:-1:-1;;;35163:40:0;;;;;;;;:::i;44266:108::-;43993:7;;;;44325:41;;;;-1:-1:-1;;;44325:41:0;;9974:2:1;44325:41:0;;;9956:21:1;10013:2;9993:18;;;9986:30;-1:-1:-1;;;10032:18:1;;;10025:50;10092:18;;44325:41:0;9772:344:1;14:418;163:2;152:9;145:21;126:4;195:6;189:13;238:6;233:2;222:9;218:18;211:34;297:6;292:2;284:6;280:15;275:2;264:9;260:18;254:50;353:1;348:2;339:6;328:9;324:22;320:31;313:42;423:2;416;412:7;407:2;399:6;395:15;391:29;380:9;376:45;372:54;364:62;;;14:418;;;;:::o;437:173::-;505:20;;-1:-1:-1;;;;;554:31:1;;544:42;;534:70;;600:1;597;590:12;534:70;437:173;;;:::o;615:300::-;683:6;691;744:2;732:9;723:7;719:23;715:32;712:52;;;760:1;757;750:12;712:52;783:29;802:9;783:29;:::i;:::-;773:39;881:2;866:18;;;;853:32;;-1:-1:-1;;;615:300:1:o;1112:226::-;1171:6;1224:2;1212:9;1203:7;1199:23;1195:32;1192:52;;;1240:1;1237;1230:12;1192:52;-1:-1:-1;1285:23:1;;1112:226;-1:-1:-1;1112:226:1:o;1525:221::-;-1:-1:-1;;;;;1707:32:1;;;;1689:51;;1677:2;1662:18;;1525:221::o;1751:374::-;1828:6;1836;1844;1897:2;1885:9;1876:7;1872:23;1868:32;1865:52;;;1913:1;1910;1903:12;1865:52;1936:29;1955:9;1936:29;:::i;:::-;1926:39;;1984:38;2018:2;2007:9;2003:18;1984:38;:::i;:::-;1751:374;;1974:48;;-1:-1:-1;;;2091:2:1;2076:18;;;;2063:32;;1751:374::o;2319:186::-;2378:6;2431:2;2419:9;2410:7;2406:23;2402:32;2399:52;;;2447:1;2444;2437:12;2399:52;2470:29;2489:9;2470:29;:::i;:::-;2460:39;2319:186;-1:-1:-1;;;2319:186:1:o;2718:260::-;2786:6;2794;2847:2;2835:9;2826:7;2822:23;2818:32;2815:52;;;2863:1;2860;2853:12;2815:52;2886:29;2905:9;2886:29;:::i;:::-;2876:39;;2934:38;2968:2;2957:9;2953:18;2934:38;:::i;:::-;2924:48;;2718:260;;;;;:::o;2983:380::-;3062:1;3058:12;;;;3105;;;3126:61;;3180:4;3172:6;3168:17;3158:27;;3126:61;3233:2;3225:6;3222:14;3202:18;3199:38;3196:161;;3279:10;3274:3;3270:20;3267:1;3260:31;3314:4;3311:1;3304:15;3342:4;3339:1;3332:15;3196:161;;2983:380;;;:::o;3368:127::-;3429:10;3424:3;3420:20;3417:1;3410:31;3460:4;3457:1;3450:15;3484:4;3481:1;3474:15;3500:168;3573:9;;;3604;;3621:15;;;3615:22;;3601:37;3591:71;;3642:18;;:::i;3673:217::-;3713:1;3739;3729:132;;3783:10;3778:3;3774:20;3771:1;3764:31;3818:4;3815:1;3808:15;3846:4;3843:1;3836:15;3729:132;-1:-1:-1;3875:9:1;;3673:217::o;3895:128::-;3962:9;;;3983:11;;;3980:37;;;3997:18;;:::i;5329:184::-;5399:6;5452:2;5440:9;5431:7;5427:23;5423:32;5420:52;;;5468:1;5465;5458:12;5420:52;-1:-1:-1;5491:16:1;;5329:184;-1:-1:-1;5329:184:1:o;7932:371::-;-1:-1:-1;;;;;8152:32:1;;;8134:51;;8221:32;;;;8216:2;8201:18;;8194:60;8285:2;8270:18;;8263:34;;;;8122:2;8107:18;;7932:371::o;8308:345::-;-1:-1:-1;;;;;8528:32:1;;;;8510:51;;8592:2;8577:18;;8570:34;;;;8635:2;8620:18;;8613:34;8498:2;8483:18;;8308:345::o;9642:125::-;9707:9;;;9728:10;;;9725:36;;;9741:18;;:::i

ipfs://d17c02de5fa222f95da022d7fe7658d44e8c713aa499e98194158e4e87b4c393