Token

Wrapped Meowcoin (wMEWC)

ERC-20

Overview

Max Total Supply

103,311,260.62545796 wMEWC

Holders

126

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

Other Info

Token Contract (WITH 18 Decimals)

0x73ac14a4cb6ACD525d0bc9b25AaDD60Cbe3BD5D0

Filtered by Token Holder

0xFD4e19738DF7Ba5Cd1bFd74eaDAd35adFb35e970

Balance

0.000000000000000001 wMEWC

Value

$0.00

0xfd4e19738df7ba5cd1bfd74eadad35adfb35e970

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

WrappedMEWC

Compiler Version

v0.8.26+commit.8a97fa7a

Optimization Enabled:

No with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2024-07-01
*/

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol


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

pragma solidity ^0.8.20;

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

// File: @openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.20;


/**
 * @dev Interface for the optional metadata functions from the ERC20 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);
}

// File: @openzeppelin/contracts/utils/Context.sol


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

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

// File: @openzeppelin/contracts/interfaces/draft-IERC6093.sol


// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)
pragma solidity ^0.8.20;

/**
 * @dev Standard ERC20 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 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 ERC721 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC721 tokens.
 */
interface IERC721Errors {
    /**
     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-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 ERC1155 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC1155 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);
}

// File: @openzeppelin/contracts/token/ERC20/ERC20.sol


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

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 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.
 */
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}.
     *
     * 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 `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:
     * ```
     * 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);
            }
        }
    }
}

// File: @openzeppelin/contracts/access/IAccessControl.sol


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

pragma solidity ^0.8.20;

/**
 * @dev External interface of AccessControl declared to support ERC165 detection.
 */
interface IAccessControl {
    /**
     * @dev The `account` is missing a role.
     */
    error AccessControlUnauthorizedAccount(address account, bytes32 neededRole);

    /**
     * @dev The caller of a function is not the expected one.
     *
     * NOTE: Don't confuse with {AccessControlUnauthorizedAccount}.
     */
    error AccessControlBadConfirmation();

    /**
     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
     *
     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
     * {RoleAdminChanged} not being emitted signaling this.
     */
    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);

    /**
     * @dev Emitted when `account` is granted `role`.
     *
     * `sender` is the account that originated the contract call, an admin role
     * bearer except when using {AccessControl-_setupRole}.
     */
    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Emitted when `account` is revoked `role`.
     *
     * `sender` is the account that originated the contract call:
     *   - if using `revokeRole`, it is the admin role bearer
     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
     */
    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) external view returns (bool);

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {AccessControl-_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) external view returns (bytes32);

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been granted `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `callerConfirmation`.
     */
    function renounceRole(bytes32 role, address callerConfirmation) external;
}

// File: @openzeppelin/contracts/utils/introspection/IERC165.sol


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

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * 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[EIP 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);
}

// File: @openzeppelin/contracts/utils/introspection/ERC165.sol


// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/ERC165.sol)

pragma solidity ^0.8.20;


/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

// File: @openzeppelin/contracts/access/AccessControl.sol


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

pragma solidity ^0.8.20;




/**
 * @dev Contract module that allows children to implement role-based access
 * control mechanisms. This is a lightweight version that doesn't allow enumerating role
 * members except through off-chain means by accessing the contract event logs. Some
 * applications may benefit from on-chain enumerability, for those cases see
 * {AccessControlEnumerable}.
 *
 * Roles are referred to by their `bytes32` identifier. These should be exposed
 * in the external API and be unique. The best way to achieve this is by
 * using `public constant` hash digests:
 *
 * ```solidity
 * bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
 * ```
 *
 * Roles can be used to represent a set of permissions. To restrict access to a
 * function call, use {hasRole}:
 *
 * ```solidity
 * function foo() public {
 *     require(hasRole(MY_ROLE, msg.sender));
 *     ...
 * }
 * ```
 *
 * Roles can be granted and revoked dynamically via the {grantRole} and
 * {revokeRole} functions. Each role has an associated admin role, and only
 * accounts that have a role's admin role can call {grantRole} and {revokeRole}.
 *
 * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
 * that only accounts with this role will be able to grant or revoke other
 * roles. More complex role relationships can be created by using
 * {_setRoleAdmin}.
 *
 * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
 * grant and revoke this role. Extra precautions should be taken to secure
 * accounts that have been granted it. We recommend using {AccessControlDefaultAdminRules}
 * to enforce additional security measures for this role.
 */
abstract contract AccessControl is Context, IAccessControl, ERC165 {
    struct RoleData {
        mapping(address account => bool) hasRole;
        bytes32 adminRole;
    }

    mapping(bytes32 role => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

    /**
     * @dev Modifier that checks that an account has a specific role. Reverts
     * with an {AccessControlUnauthorizedAccount} error including the required role.
     */
    modifier onlyRole(bytes32 role) {
        _checkRole(role);
        _;
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);
    }

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) public view virtual returns (bool) {
        return _roles[role].hasRole[account];
    }

    /**
     * @dev Reverts with an {AccessControlUnauthorizedAccount} error if `_msgSender()`
     * is missing `role`. Overriding this function changes the behavior of the {onlyRole} modifier.
     */
    function _checkRole(bytes32 role) internal view virtual {
        _checkRole(role, _msgSender());
    }

    /**
     * @dev Reverts with an {AccessControlUnauthorizedAccount} error if `account`
     * is missing `role`.
     */
    function _checkRole(bytes32 role, address account) internal view virtual {
        if (!hasRole(role, account)) {
            revert AccessControlUnauthorizedAccount(account, role);
        }
    }

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) public view virtual returns (bytes32) {
        return _roles[role].adminRole;
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     *
     * May emit a {RoleGranted} event.
     */
    function grantRole(bytes32 role, address account) public virtual onlyRole(getRoleAdmin(role)) {
        _grantRole(role, account);
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     *
     * May emit a {RoleRevoked} event.
     */
    function revokeRole(bytes32 role, address account) public virtual onlyRole(getRoleAdmin(role)) {
        _revokeRole(role, account);
    }

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been revoked `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `callerConfirmation`.
     *
     * May emit a {RoleRevoked} event.
     */
    function renounceRole(bytes32 role, address callerConfirmation) public virtual {
        if (callerConfirmation != _msgSender()) {
            revert AccessControlBadConfirmation();
        }

        _revokeRole(role, callerConfirmation);
    }

    /**
     * @dev Sets `adminRole` as ``role``'s admin role.
     *
     * Emits a {RoleAdminChanged} event.
     */
    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
        bytes32 previousAdminRole = getRoleAdmin(role);
        _roles[role].adminRole = adminRole;
        emit RoleAdminChanged(role, previousAdminRole, adminRole);
    }

    /**
     * @dev Attempts to grant `role` to `account` and returns a boolean indicating if `role` was granted.
     *
     * Internal function without access restriction.
     *
     * May emit a {RoleGranted} event.
     */
    function _grantRole(bytes32 role, address account) internal virtual returns (bool) {
        if (!hasRole(role, account)) {
            _roles[role].hasRole[account] = true;
            emit RoleGranted(role, account, _msgSender());
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Attempts to revoke `role` to `account` and returns a boolean indicating if `role` was revoked.
     *
     * Internal function without access restriction.
     *
     * May emit a {RoleRevoked} event.
     */
    function _revokeRole(bytes32 role, address account) internal virtual returns (bool) {
        if (hasRole(role, account)) {
            _roles[role].hasRole[account] = false;
            emit RoleRevoked(role, account, _msgSender());
            return true;
        } else {
            return false;
        }
    }
}

// File: @openzeppelin/contracts/security/Pausable.sol


// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)

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

// File: @openzeppelin/contracts/utils/math/Math.sol


// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol)

pragma solidity ^0.8.20;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Muldiv operation overflow.
     */
    error MathOverflowedMulDiv();

    enum Rounding {
        Floor, // Toward negative infinity
        Ceil, // Toward positive infinity
        Trunc, // Toward zero
        Expand // Away from zero
    }

    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds towards infinity instead
     * of rounding towards zero.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        if (b == 0) {
            // Guarantee the same behavior as in a regular Solidity division.
            return a / b;
        }

        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or
     * denominator == 0.
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by
     * Uniswap Labs also under MIT license.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0 = x * y; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            if (denominator <= prod1) {
                revert MathOverflowedMulDiv();
            }

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.
            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.

            uint256 twos = denominator & (0 - denominator);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also
            // works in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
     * towards zero.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10 ** 64) {
                value /= 10 ** 64;
                result += 64;
            }
            if (value >= 10 ** 32) {
                value /= 10 ** 32;
                result += 32;
            }
            if (value >= 10 ** 16) {
                value /= 10 ** 16;
                result += 16;
            }
            if (value >= 10 ** 8) {
                value /= 10 ** 8;
                result += 8;
            }
            if (value >= 10 ** 4) {
                value /= 10 ** 4;
                result += 4;
            }
            if (value >= 10 ** 2) {
                value /= 10 ** 2;
                result += 2;
            }
            if (value >= 10 ** 1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);
        }
    }

    /**
     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
     */
    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
        return uint8(rounding) % 2 == 1;
    }
}

// File: @openzeppelin/contracts/utils/math/SignedMath.sol


// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SignedMath.sol)

pragma solidity ^0.8.20;

/**
 * @dev Standard signed math utilities missing in the Solidity language.
 */
library SignedMath {
    /**
     * @dev Returns the largest of two signed numbers.
     */
    function max(int256 a, int256 b) internal pure returns (int256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two signed numbers.
     */
    function min(int256 a, int256 b) internal pure returns (int256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
        unchecked {
            // must be unchecked in order to support `n = type(int256).min`
            return uint256(n >= 0 ? n : -n);
        }
    }
}

// File: @openzeppelin/contracts/utils/Strings.sol


// OpenZeppelin Contracts (last updated v5.0.0) (utils/Strings.sol)

pragma solidity ^0.8.20;



/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant HEX_DIGITS = "0123456789abcdef";
    uint8 private constant ADDRESS_LENGTH = 20;

    /**
     * @dev The `value` string doesn't fit in the specified `length`.
     */
    error StringsInsufficientHexLength(uint256 value, uint256 length);

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toStringSigned(int256 value) internal pure returns (string memory) {
        return string.concat(value < 0 ? "-" : "", toString(SignedMath.abs(value)));
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        uint256 localValue = value;
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = HEX_DIGITS[localValue & 0xf];
            localValue >>= 4;
        }
        if (localValue != 0) {
            revert StringsInsufficientHexLength(value, length);
        }
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal
     * representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);
    }

    /**
     * @dev Returns true if the two strings are equal.
     */
    function equal(string memory a, string memory b) internal pure returns (bool) {
        return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));
    }
}

// File: @openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol


// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/MessageHashUtils.sol)

pragma solidity ^0.8.20;


/**
 * @dev Signature message hash utilities for producing digests to be consumed by {ECDSA} recovery or signing.
 *
 * The library provides methods for generating a hash of a message that conforms to the
 * https://eips.ethereum.org/EIPS/eip-191[EIP 191] and https://eips.ethereum.org/EIPS/eip-712[EIP 712]
 * specifications.
 */
library MessageHashUtils {
    /**
     * @dev Returns the keccak256 digest of an EIP-191 signed data with version
     * `0x45` (`personal_sign` messages).
     *
     * The digest is calculated by prefixing a bytes32 `messageHash` with
     * `"\x19Ethereum Signed Message:\n32"` and hashing the result. It corresponds with the
     * hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method.
     *
     * NOTE: The `messageHash` parameter is intended to be the result of hashing a raw message with
     * keccak256, although any bytes32 value can be safely used because the final digest will
     * be re-hashed.
     *
     * See {ECDSA-recover}.
     */
    function toEthSignedMessageHash(bytes32 messageHash) internal pure returns (bytes32 digest) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, "\x19Ethereum Signed Message:\n32") // 32 is the bytes-length of messageHash
            mstore(0x1c, messageHash) // 0x1c (28) is the length of the prefix
            digest := keccak256(0x00, 0x3c) // 0x3c is the length of the prefix (0x1c) + messageHash (0x20)
        }
    }

    /**
     * @dev Returns the keccak256 digest of an EIP-191 signed data with version
     * `0x45` (`personal_sign` messages).
     *
     * The digest is calculated by prefixing an arbitrary `message` with
     * `"\x19Ethereum Signed Message:\n" + len(message)` and hashing the result. It corresponds with the
     * hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method.
     *
     * See {ECDSA-recover}.
     */
    function toEthSignedMessageHash(bytes memory message) internal pure returns (bytes32) {
        return
            keccak256(bytes.concat("\x19Ethereum Signed Message:\n", bytes(Strings.toString(message.length)), message));
    }

    /**
     * @dev Returns the keccak256 digest of an EIP-191 signed data with version
     * `0x00` (data with intended validator).
     *
     * The digest is calculated by prefixing an arbitrary `data` with `"\x19\x00"` and the intended
     * `validator` address. Then hashing the result.
     *
     * See {ECDSA-recover}.
     */
    function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked(hex"19_00", validator, data));
    }

    /**
     * @dev Returns the keccak256 digest of an EIP-712 typed data (EIP-191 version `0x01`).
     *
     * The digest is calculated from a `domainSeparator` and a `structHash`, by prefixing them with
     * `\x19\x01` and hashing the result. It corresponds to the hash signed by the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`] JSON-RPC method as part of EIP-712.
     *
     * See {ECDSA-recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 digest) {
        /// @solidity memory-safe-assembly
        assembly {
            let ptr := mload(0x40)
            mstore(ptr, hex"19_01")
            mstore(add(ptr, 0x02), domainSeparator)
            mstore(add(ptr, 0x22), structHash)
            digest := keccak256(ptr, 0x42)
        }
    }
}

// File: @openzeppelin/contracts/utils/StorageSlot.sol


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

pragma solidity ^0.8.20;

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

    struct BooleanSlot {
        bool value;
    }

    struct Bytes32Slot {
        bytes32 value;
    }

    struct Uint256Slot {
        uint256 value;
    }

    struct StringSlot {
        string value;
    }

    struct BytesSlot {
        bytes value;
    }

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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/utils/ShortStrings.sol


// OpenZeppelin Contracts (last updated v5.0.0) (utils/ShortStrings.sol)

pragma solidity ^0.8.20;


// | string  | 0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA   |
// | length  | 0x                                                              BB |
type ShortString is bytes32;

/**
 * @dev This library provides functions to convert short memory strings
 * into a `ShortString` type that can be used as an immutable variable.
 *
 * Strings of arbitrary length can be optimized using this library if
 * they are short enough (up to 31 bytes) by packing them with their
 * length (1 byte) in a single EVM word (32 bytes). Additionally, a
 * fallback mechanism can be used for every other case.
 *
 * Usage example:
 *
 * ```solidity
 * contract Named {
 *     using ShortStrings for *;
 *
 *     ShortString private immutable _name;
 *     string private _nameFallback;
 *
 *     constructor(string memory contractName) {
 *         _name = contractName.toShortStringWithFallback(_nameFallback);
 *     }
 *
 *     function name() external view returns (string memory) {
 *         return _name.toStringWithFallback(_nameFallback);
 *     }
 * }
 * ```
 */
library ShortStrings {
    // Used as an identifier for strings longer than 31 bytes.
    bytes32 private constant FALLBACK_SENTINEL = 0x00000000000000000000000000000000000000000000000000000000000000FF;

    error StringTooLong(string str);
    error InvalidShortString();

    /**
     * @dev Encode a string of at most 31 chars into a `ShortString`.
     *
     * This will trigger a `StringTooLong` error is the input string is too long.
     */
    function toShortString(string memory str) internal pure returns (ShortString) {
        bytes memory bstr = bytes(str);
        if (bstr.length > 31) {
            revert StringTooLong(str);
        }
        return ShortString.wrap(bytes32(uint256(bytes32(bstr)) | bstr.length));
    }

    /**
     * @dev Decode a `ShortString` back to a "normal" string.
     */
    function toString(ShortString sstr) internal pure returns (string memory) {
        uint256 len = byteLength(sstr);
        // using `new string(len)` would work locally but is not memory safe.
        string memory str = new string(32);
        /// @solidity memory-safe-assembly
        assembly {
            mstore(str, len)
            mstore(add(str, 0x20), sstr)
        }
        return str;
    }

    /**
     * @dev Return the length of a `ShortString`.
     */
    function byteLength(ShortString sstr) internal pure returns (uint256) {
        uint256 result = uint256(ShortString.unwrap(sstr)) & 0xFF;
        if (result > 31) {
            revert InvalidShortString();
        }
        return result;
    }

    /**
     * @dev Encode a string into a `ShortString`, or write it to storage if it is too long.
     */
    function toShortStringWithFallback(string memory value, string storage store) internal returns (ShortString) {
        if (bytes(value).length < 32) {
            return toShortString(value);
        } else {
            StorageSlot.getStringSlot(store).value = value;
            return ShortString.wrap(FALLBACK_SENTINEL);
        }
    }

    /**
     * @dev Decode a string that was encoded to `ShortString` or written to storage using {setWithFallback}.
     */
    function toStringWithFallback(ShortString value, string storage store) internal pure returns (string memory) {
        if (ShortString.unwrap(value) != FALLBACK_SENTINEL) {
            return toString(value);
        } else {
            return store;
        }
    }

    /**
     * @dev Return the length of a string that was encoded to `ShortString` or written to storage using
     * {setWithFallback}.
     *
     * WARNING: This will return the "byte length" of the string. This may not reflect the actual length in terms of
     * actual characters as the UTF-8 encoding of a single character can span over multiple bytes.
     */
    function byteLengthWithFallback(ShortString value, string storage store) internal view returns (uint256) {
        if (ShortString.unwrap(value) != FALLBACK_SENTINEL) {
            return byteLength(value);
        } else {
            return bytes(store).length;
        }
    }
}

// File: @openzeppelin/contracts/interfaces/IERC5267.sol


// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC5267.sol)

pragma solidity ^0.8.20;

interface IERC5267 {
    /**
     * @dev MAY be emitted to signal that the domain could have changed.
     */
    event EIP712DomainChanged();

    /**
     * @dev returns the fields and values that describe the domain separator used by this contract for EIP-712
     * signature.
     */
    function eip712Domain()
        external
        view
        returns (
            bytes1 fields,
            string memory name,
            string memory version,
            uint256 chainId,
            address verifyingContract,
            bytes32 salt,
            uint256[] memory extensions
        );
}

// File: @openzeppelin/contracts/utils/cryptography/EIP712.sol


// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/EIP712.sol)

pragma solidity ^0.8.20;




/**
 * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.
 *
 * The encoding scheme specified in the EIP requires a domain separator and a hash of the typed structured data, whose
 * encoding is very generic and therefore its implementation in Solidity is not feasible, thus this contract
 * does not implement the encoding itself. Protocols need to implement the type-specific encoding they need in order to
 * produce the hash of their typed data using a combination of `abi.encode` and `keccak256`.
 *
 * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding
 * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA
 * ({_hashTypedDataV4}).
 *
 * The implementation of the domain separator was designed to be as efficient as possible while still properly updating
 * the chain id to protect against replay attacks on an eventual fork of the chain.
 *
 * NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method
 * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].
 *
 * NOTE: In the upgradeable version of this contract, the cached values will correspond to the address, and the domain
 * separator of the implementation contract. This will cause the {_domainSeparatorV4} function to always rebuild the
 * separator from the immutable values, which is cheaper than accessing a cached version in cold storage.
 *
 * @custom:oz-upgrades-unsafe-allow state-variable-immutable
 */
abstract contract EIP712 is IERC5267 {
    using ShortStrings for *;

    bytes32 private constant TYPE_HASH =
        keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");

    // Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to
    // invalidate the cached domain separator if the chain id changes.
    bytes32 private immutable _cachedDomainSeparator;
    uint256 private immutable _cachedChainId;
    address private immutable _cachedThis;

    bytes32 private immutable _hashedName;
    bytes32 private immutable _hashedVersion;

    ShortString private immutable _name;
    ShortString private immutable _version;
    string private _nameFallback;
    string private _versionFallback;

    /**
     * @dev Initializes the domain separator and parameter caches.
     *
     * The meaning of `name` and `version` is specified in
     * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:
     *
     * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.
     * - `version`: the current major version of the signing domain.
     *
     * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart
     * contract upgrade].
     */
    constructor(string memory name, string memory version) {
        _name = name.toShortStringWithFallback(_nameFallback);
        _version = version.toShortStringWithFallback(_versionFallback);
        _hashedName = keccak256(bytes(name));
        _hashedVersion = keccak256(bytes(version));

        _cachedChainId = block.chainid;
        _cachedDomainSeparator = _buildDomainSeparator();
        _cachedThis = address(this);
    }

    /**
     * @dev Returns the domain separator for the current chain.
     */
    function _domainSeparatorV4() internal view returns (bytes32) {
        if (address(this) == _cachedThis && block.chainid == _cachedChainId) {
            return _cachedDomainSeparator;
        } else {
            return _buildDomainSeparator();
        }
    }

    function _buildDomainSeparator() private view returns (bytes32) {
        return keccak256(abi.encode(TYPE_HASH, _hashedName, _hashedVersion, block.chainid, address(this)));
    }

    /**
     * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this
     * function returns the hash of the fully encoded EIP712 message for this domain.
     *
     * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:
     *
     * ```solidity
     * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(
     *     keccak256("Mail(address to,string contents)"),
     *     mailTo,
     *     keccak256(bytes(mailContents))
     * )));
     * address signer = ECDSA.recover(digest, signature);
     * ```
     */
    function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
        return MessageHashUtils.toTypedDataHash(_domainSeparatorV4(), structHash);
    }

    /**
     * @dev See {IERC-5267}.
     */
    function eip712Domain()
        public
        view
        virtual
        returns (
            bytes1 fields,
            string memory name,
            string memory version,
            uint256 chainId,
            address verifyingContract,
            bytes32 salt,
            uint256[] memory extensions
        )
    {
        return (
            hex"0f", // 01111
            _EIP712Name(),
            _EIP712Version(),
            block.chainid,
            address(this),
            bytes32(0),
            new uint256[](0)
        );
    }

    /**
     * @dev The name parameter for the EIP712 domain.
     *
     * NOTE: By default this function reads _name which is an immutable value.
     * It only reads from storage if necessary (in case the value is too large to fit in a ShortString).
     */
    // solhint-disable-next-line func-name-mixedcase
    function _EIP712Name() internal view returns (string memory) {
        return _name.toStringWithFallback(_nameFallback);
    }

    /**
     * @dev The version parameter for the EIP712 domain.
     *
     * NOTE: By default this function reads _version which is an immutable value.
     * It only reads from storage if necessary (in case the value is too large to fit in a ShortString).
     */
    // solhint-disable-next-line func-name-mixedcase
    function _EIP712Version() internal view returns (string memory) {
        return _version.toStringWithFallback(_versionFallback);
    }
}

// File: wmewc.sol


// WrappedMEWC is an ERC20 token with additional features like access control and pausability
pragma solidity ^0.8.4;





contract WrappedMEWC is ERC20, AccessControl, Pausable, EIP712 {
    // Role definition for minters using a unique hash
    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
    // Hash for the minting function to ensure correct function is called with EIP712
    bytes32 private constant MINT_TYPEHASH = keccak256("MintRequest(address to,uint256 amount,uint256 uuid,uint256 deadline)");
    // Account that will collect transaction fees
    address public feeAccount;
    // Initial fee percentage set at 3%
    uint256 public feePercent = 3;
    // Maximum fee percentage allowed
    uint256 public constant MAX_FEE = 5;

    // Mapping to store used UUIDs
    mapping(bytes32 => bool) private usedUUIDs;

    // Struct to define the mint request parameters
    struct MintRequest {
        address to;
        uint256 amount;
        uint256 uuid;
        uint256 deadline;
    }

    // Constructor to initialize the ERC20 token and set initial roles and fee account
    constructor() 
        ERC20("Wrapped Meowcoin", "wMEWC") 
        EIP712("WrappedMeowcoin", "1") 
    {
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender); // Granting admin role to the contract deployer
        _grantRole(MINTER_ROLE, msg.sender); // Granting minter role to the contract deployer
        feeAccount = msg.sender; // Setting the fee account to the contract deployer initially
    }

    // Function to set the fee account, only accessible by admin
    function setFeeAccount(address _feeAccount) external onlyRole(DEFAULT_ADMIN_ROLE) {
        feeAccount = _feeAccount;
    }

    // Function to set the fee percentage, only accessible by admin and with checks for maximum fee limit
    function setFeePercent(uint256 _feePercent) external onlyRole(DEFAULT_ADMIN_ROLE) {
        require(_feePercent <= MAX_FEE, "Fee percent too high");
        feePercent = _feePercent;
    }

    // Function to transfer tokens with fee deduction
    function transfer(address recipient, uint256 amount) public override returns (bool) {
        uint256 fee = (amount * feePercent) / 100;
        uint256 amountAfterFee = amount - fee;
        super.transfer(feeAccount, fee); // Transfer the fee
        super.transfer(recipient, amountAfterFee); // Transfer the net amount
        return true;
    }

    // Function to mint tokens using a signed request, ensuring it's within the deadline and the signature is valid
    function mint(MintRequest calldata request, uint8 v, bytes32 r, bytes32 s) public {
        require(block.timestamp <= request.deadline, "Expired deadline");
        bytes32 structHash = keccak256(abi.encode(MINT_TYPEHASH, request.to, request.amount, request.uuid, request.deadline));
        bytes32 digest = _hashTypedDataV4(structHash);
        address signer = ecrecover(digest, v, r, s);
        require(hasRole(MINTER_ROLE, signer), "Invalid signature or unauthorized");

        // Check if the UUID has already been used
        bytes32 transactionHash = keccak256(abi.encodePacked(request.to, request.amount, request.uuid, block.chainid));
        require(!usedUUIDs[transactionHash], "UUID already used");

        // Mark this UUID as used
        usedUUIDs[transactionHash] = true;

        _mint(request.to, request.amount); // Mint the full amount to the requester
    }
    
    // Function to burn tokens, reducing the total supply
    function burn(uint256 amount) public {
        _burn(msg.sender, amount); // Burn the specified amount of tokens from the caller's balance
    }

    // Function to pause the contract, only accessible by admin
    function pause() public onlyRole(DEFAULT_ADMIN_ROLE) {
        _pause();
    }

    // Function to unpause the contract, only accessible by admin
    function unpause() public onlyRole(DEFAULT_ADMIN_ROLE) {
        _unpause();
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AccessControlBadConfirmation","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bytes32","name":"neededRole","type":"bytes32"}],"name":"AccessControlUnauthorizedAccount","type":"error"},{"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":[],"name":"InvalidShortString","type":"error"},{"inputs":[{"internalType":"string","name":"str","type":"string"}],"name":"StringTooLong","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":[],"name":"EIP712DomainChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","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"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_FEE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MINTER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"eip712Domain","outputs":[{"internalType":"bytes1","name":"fields","type":"bytes1"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"version","type":"string"},{"internalType":"uint256","name":"chainId","type":"uint256"},{"internalType":"address","name":"verifyingContract","type":"address"},{"internalType":"bytes32","name":"salt","type":"bytes32"},{"internalType":"uint256[]","name":"extensions","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feeAccount","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feePercent","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"uuid","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"internalType":"struct WrappedMEWC.MintRequest","name":"request","type":"tuple"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"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":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"callerConfirmation","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_feeAccount","type":"address"}],"name":"setFeeAccount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_feePercent","type":"uint256"}],"name":"setFeePercent","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","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":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

0x608060405234801561000f575f80fd5b50600436106101c2575f3560e01c806370a08231116100f7578063966e2a4611610095578063bc063e1a1161006f578063bc063e1a146104e6578063d539139314610504578063d547741f14610522578063dd62ed3e1461053e576101c2565b8063966e2a461461047c578063a217fddf14610498578063a9059cbb146104b6576101c2565b80638456cb59116100d15780638456cb591461040057806384b0196e1461040a57806391d148541461042e57806395d89b411461045e576101c2565b806370a08231146103965780637ce3489b146103c65780637fd6f15c146103e2576101c2565b8063313ce5671161016457806342966c681161013e57806342966c68146103225780634b023cf81461033e5780635c975abb1461035a57806365e17c9d14610378576101c2565b8063313ce567146102de57806336568abe146102fc5780633f4ba83a14610318576101c2565b806318160ddd116101a057806318160ddd1461024457806323b872dd14610262578063248a9ca3146102925780632f2ff15d146102c2576101c2565b806301ffc9a7146101c657806306fdde03146101f6578063095ea7b314610214575b5f80fd5b6101e060048036038101906101db9190611cc7565b61056e565b6040516101ed9190611d0c565b60405180910390f35b6101fe6105e7565b60405161020b9190611d95565b60405180910390f35b61022e60048036038101906102299190611e42565b610677565b60405161023b9190611d0c565b60405180910390f35b61024c610699565b6040516102599190611e8f565b60405180910390f35b61027c60048036038101906102779190611ea8565b6106a2565b6040516102899190611d0c565b60405180910390f35b6102ac60048036038101906102a79190611f2b565b6106d0565b6040516102b99190611f65565b60405180910390f35b6102dc60048036038101906102d79190611f7e565b6106ed565b005b6102e661070f565b6040516102f39190611fd7565b60405180910390f35b61031660048036038101906103119190611f7e565b610717565b005b610320610792565b005b61033c60048036038101906103379190611ff0565b6107a9565b005b6103586004803603810190610353919061201b565b6107b6565b005b610362610806565b60405161036f9190611d0c565b60405180910390f35b61038061081b565b60405161038d9190612055565b60405180910390f35b6103b060048036038101906103ab919061201b565b610840565b6040516103bd9190611e8f565b60405180910390f35b6103e060048036038101906103db9190611ff0565b610885565b005b6103ea6108e0565b6040516103f79190611e8f565b60405180910390f35b6104086108e6565b005b6104126108fd565b604051610425979695949392919061215f565b60405180910390f35b61044860048036038101906104439190611f7e565b6109a2565b6040516104559190611d0c565b60405180910390f35b610466610a06565b6040516104739190611d95565b60405180910390f35b6104966004803603810190610491919061222d565b610a96565b005b6104a0610d09565b6040516104ad9190611f65565b60405180910390f35b6104d060048036038101906104cb9190611e42565b610d0f565b6040516104dd9190611d0c565b60405180910390f35b6104ee610d7f565b6040516104fb9190611e8f565b60405180910390f35b61050c610d84565b6040516105199190611f65565b60405180910390f35b61053c60048036038101906105379190611f7e565b610da8565b005b61055860048036038101906105539190612291565b610dca565b6040516105659190611e8f565b60405180910390f35b5f7f7965db0b000000000000000000000000000000000000000000000000000000007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916827bffffffffffffffffffffffffffffffffffffffffffffffffffffffff191614806105e057506105df82610e4c565b5b9050919050565b6060600380546105f6906122fc565b80601f0160208091040260200160405190810160405280929190818152602001828054610622906122fc565b801561066d5780601f106106445761010080835404028352916020019161066d565b820191905f5260205f20905b81548152906001019060200180831161065057829003601f168201915b5050505050905090565b5f80610681610eb5565b905061068e818585610ebc565b600191505092915050565b5f600254905090565b5f806106ac610eb5565b90506106b9858285610ece565b6106c4858585610f60565b60019150509392505050565b5f60055f8381526020019081526020015f20600101549050919050565b6106f6826106d0565b6106ff81611050565b6107098383611064565b50505050565b5f6012905090565b61071f610eb5565b73ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1614610783576040517f6697b23200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b61078d828261114e565b505050565b5f801b61079e81611050565b6107a6611238565b50565b6107b33382611299565b50565b5f801b6107c281611050565b8160095f6101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055505050565b5f60065f9054906101000a900460ff16905090565b60095f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b5f805f8373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f20549050919050565b5f801b61089181611050565b60058211156108d5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016108cc90612376565b60405180910390fd5b81600a819055505050565b600a5481565b5f801b6108f281611050565b6108fa611318565b50565b5f6060805f805f606061090e61137a565b6109166113b5565b46305f801b5f67ffffffffffffffff81111561093557610934612394565b5b6040519080825280602002602001820160405280156109635781602001602082028036833780820191505090505b507f0f00000000000000000000000000000000000000000000000000000000000000959493929190965096509650965096509650965090919293949596565b5f60055f8481526020019081526020015f205f015f8373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f9054906101000a900460ff16905092915050565b606060048054610a15906122fc565b80601f0160208091040260200160405190810160405280929190818152602001828054610a41906122fc565b8015610a8c5780601f10610a6357610100808354040283529160200191610a8c565b820191905f5260205f20905b815481529060010190602001808311610a6f57829003601f168201915b5050505050905090565b8360600135421115610add576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610ad49061240b565b60405180910390fd5b5f7f05dac90127b5beea9d6bac8bf6962ef964e99f78ca9a5ee126ed3158f14d003c855f016020810190610b11919061201b565b866020013587604001358860600135604051602001610b34959493929190612429565b6040516020818303038152906040528051906020012090505f610b56826113f0565b90505f6001828787876040515f8152602001604052604051610b7b949392919061247a565b6020604051602081039080840390855afa158015610b9b573d5f803e3d5ffd5b505050602060405103519050610bd17f9f2df0fed2c77648de5860a4cc508cd0818c85b8b8a1ab4ceeef8d981c8956a6826109a2565b610c10576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610c079061252d565b60405180910390fd5b5f875f016020810190610c23919061201b565b8860200135896040013546604051602001610c4194939291906125b0565b604051602081830303815290604052805190602001209050600b5f8281526020019081526020015f205f9054906101000a900460ff1615610cb7576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610cae90612647565b60405180910390fd5b6001600b5f8381526020019081526020015f205f6101000a81548160ff021916908315150217905550610cff885f016020810190610cf5919061201b565b8960200135611409565b5050505050505050565b5f801b81565b5f806064600a5484610d219190612692565b610d2b9190612700565b90505f8184610d3a9190612730565b9050610d6760095f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1683611488565b50610d728582611488565b5060019250505092915050565b600581565b7f9f2df0fed2c77648de5860a4cc508cd0818c85b8b8a1ab4ceeef8d981c8956a681565b610db1826106d0565b610dba81611050565b610dc4838361114e565b50505050565b5f60015f8473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f8373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f2054905092915050565b5f7f01ffc9a7000000000000000000000000000000000000000000000000000000007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916827bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916149050919050565b5f33905090565b610ec983838360016114aa565b505050565b5f610ed98484610dca565b90507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8114610f5a5781811015610f4b578281836040517ffb8f41b2000000000000000000000000000000000000000000000000000000008152600401610f4293929190612763565b60405180910390fd5b610f5984848484035f6114aa565b5b50505050565b5f73ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff1603610fd0575f6040517f96c6fd1e000000000000000000000000000000000000000000000000000000008152600401610fc79190612055565b60405180910390fd5b5f73ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1603611040575f6040517fec442f050000000000000000000000000000000000000000000000000000000081526004016110379190612055565b60405180910390fd5b61104b838383611679565b505050565b6110618161105c610eb5565b611892565b50565b5f61106f83836109a2565b61114457600160055f8581526020019081526020015f205f015f8473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f6101000a81548160ff0219169083151502179055506110e1610eb5565b73ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff16847f2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d60405160405180910390a460019050611148565b5f90505b92915050565b5f61115983836109a2565b1561122e575f60055f8581526020019081526020015f205f015f8473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f6101000a81548160ff0219169083151502179055506111cb610eb5565b73ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff16847ff6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b60405160405180910390a460019050611232565b5f90505b92915050565b6112406118e3565b5f60065f6101000a81548160ff0219169083151502179055507f5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa611282610eb5565b60405161128f9190612055565b60405180910390a1565b5f73ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1603611309575f6040517f96c6fd1e0000000000000000000000000000000000000000000000000000000081526004016113009190612055565b60405180910390fd5b611314825f83611679565b5050565b61132061192c565b600160065f6101000a81548160ff0219169083151502179055507f62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258611363610eb5565b6040516113709190612055565b60405180910390a1565b60606113b060077f577261707065644d656f77636f696e000000000000000000000000000000000f61197690919063ffffffff16565b905090565b60606113eb60087f310000000000000000000000000000000000000000000000000000000000000161197690919063ffffffff16565b905090565b5f6114026113fc611a23565b83611ad9565b9050919050565b5f73ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1603611479575f6040517fec442f050000000000000000000000000000000000000000000000000000000081526004016114709190612055565b60405180910390fd5b6114845f8383611679565b5050565b5f80611492610eb5565b905061149f818585610f60565b600191505092915050565b5f73ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff160361151a575f6040517fe602df050000000000000000000000000000000000000000000000000000000081526004016115119190612055565b60405180910390fd5b5f73ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff160361158a575f6040517f94280d620000000000000000000000000000000000000000000000000000000081526004016115819190612055565b60405180910390fd5b8160015f8673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f8573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f20819055508015611673578273ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b9258460405161166a9190611e8f565b60405180910390a35b50505050565b5f73ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff16036116c9578060025f8282546116bd9190612798565b92505081905550611797565b5f805f8573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f2054905081811015611752578381836040517fe450d38c00000000000000000000000000000000000000000000000000000000815260040161174993929190612763565b60405180910390fd5b8181035f808673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f2081905550505b5f73ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff16036117de578060025f8282540392505081905550611828565b805f808473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f82825401925050819055505b8173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef836040516118859190611e8f565b60405180910390a3505050565b61189c82826109a2565b6118df5780826040517fe2517d3f0000000000000000000000000000000000000000000000000000000081526004016118d69291906127cb565b60405180910390fd5b5050565b6118eb610806565b61192a576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016119219061283c565b60405180910390fd5b565b611934610806565b15611974576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161196b906128a4565b60405180910390fd5b565b606060ff5f1b83146119925761198b83611b19565b9050611a1d565b81805461199e906122fc565b80601f01602080910402602001604051908101604052809291908181526020018280546119ca906122fc565b8015611a155780601f106119ec57610100808354040283529160200191611a15565b820191905f5260205f20905b8154815290600101906020018083116119f857829003601f168201915b505050505090505b92915050565b5f7f00000000000000000000000073ac14a4cb6acd525d0bc9b25aadd60cbe3bd5d073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff16148015611a9e57507f000000000000000000000000000000000000000000000000000000000000000146145b15611acb577f9dd668a9d18816090f701864504cf58ff33fecc749b180c99b4fbdb0a2d3c09f9050611ad6565b611ad3611b8b565b90505b90565b5f6040517f190100000000000000000000000000000000000000000000000000000000000081528360028201528260228201526042812091505092915050565b60605f611b2583611c20565b90505f602067ffffffffffffffff811115611b4357611b42612394565b5b6040519080825280601f01601f191660200182016040528015611b755781602001600182028036833780820191505090505b5090508181528360208201528092505050919050565b5f7f8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f7f89bfed6ae0c89f13de8a8db48e008e46c09b72a4ec65fac1f39baa0a4860b8947fc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc64630604051602001611c059594939291906128c2565b60405160208183030381529060405280519060200120905090565b5f8060ff835f1c169050601f811115611c65576040517fb3512b0c00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b80915050919050565b5f80fd5b5f7fffffffff0000000000000000000000000000000000000000000000000000000082169050919050565b611ca681611c72565b8114611cb0575f80fd5b50565b5f81359050611cc181611c9d565b92915050565b5f60208284031215611cdc57611cdb611c6e565b5b5f611ce984828501611cb3565b91505092915050565b5f8115159050919050565b611d0681611cf2565b82525050565b5f602082019050611d1f5f830184611cfd565b92915050565b5f81519050919050565b5f82825260208201905092915050565b8281835e5f83830152505050565b5f601f19601f8301169050919050565b5f611d6782611d25565b611d718185611d2f565b9350611d81818560208601611d3f565b611d8a81611d4d565b840191505092915050565b5f6020820190508181035f830152611dad8184611d5d565b905092915050565b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f611dde82611db5565b9050919050565b611dee81611dd4565b8114611df8575f80fd5b50565b5f81359050611e0981611de5565b92915050565b5f819050919050565b611e2181611e0f565b8114611e2b575f80fd5b50565b5f81359050611e3c81611e18565b92915050565b5f8060408385031215611e5857611e57611c6e565b5b5f611e6585828601611dfb565b9250506020611e7685828601611e2e565b9150509250929050565b611e8981611e0f565b82525050565b5f602082019050611ea25f830184611e80565b92915050565b5f805f60608486031215611ebf57611ebe611c6e565b5b5f611ecc86828701611dfb565b9350506020611edd86828701611dfb565b9250506040611eee86828701611e2e565b9150509250925092565b5f819050919050565b611f0a81611ef8565b8114611f14575f80fd5b50565b5f81359050611f2581611f01565b92915050565b5f60208284031215611f4057611f3f611c6e565b5b5f611f4d84828501611f17565b91505092915050565b611f5f81611ef8565b82525050565b5f602082019050611f785f830184611f56565b92915050565b5f8060408385031215611f9457611f93611c6e565b5b5f611fa185828601611f17565b9250506020611fb285828601611dfb565b9150509250929050565b5f60ff82169050919050565b611fd181611fbc565b82525050565b5f602082019050611fea5f830184611fc8565b92915050565b5f6020828403121561200557612004611c6e565b5b5f61201284828501611e2e565b91505092915050565b5f602082840312156120305761202f611c6e565b5b5f61203d84828501611dfb565b91505092915050565b61204f81611dd4565b82525050565b5f6020820190506120685f830184612046565b92915050565b5f7fff0000000000000000000000000000000000000000000000000000000000000082169050919050565b6120a28161206e565b82525050565b5f81519050919050565b5f82825260208201905092915050565b5f819050602082019050919050565b6120da81611e0f565b82525050565b5f6120eb83836120d1565b60208301905092915050565b5f602082019050919050565b5f61210d826120a8565b61211781856120b2565b9350612122836120c2565b805f5b8381101561215257815161213988826120e0565b9750612144836120f7565b925050600181019050612125565b5085935050505092915050565b5f60e0820190506121725f83018a612099565b81810360208301526121848189611d5d565b905081810360408301526121988188611d5d565b90506121a76060830187611e80565b6121b46080830186612046565b6121c160a0830185611f56565b81810360c08301526121d38184612103565b905098975050505050505050565b5f80fd5b5f608082840312156121fa576121f96121e1565b5b81905092915050565b61220c81611fbc565b8114612216575f80fd5b50565b5f8135905061222781612203565b92915050565b5f805f8060e0858703121561224557612244611c6e565b5b5f612252878288016121e5565b945050608061226387828801612219565b93505060a061227487828801611f17565b92505060c061228587828801611f17565b91505092959194509250565b5f80604083850312156122a7576122a6611c6e565b5b5f6122b485828601611dfb565b92505060206122c585828601611dfb565b9150509250929050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52602260045260245ffd5b5f600282049050600182168061231357607f821691505b602082108103612326576123256122cf565b5b50919050565b7f4665652070657263656e7420746f6f20686967680000000000000000000000005f82015250565b5f612360601483611d2f565b915061236b8261232c565b602082019050919050565b5f6020820190508181035f83015261238d81612354565b9050919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b7f4578706972656420646561646c696e65000000000000000000000000000000005f82015250565b5f6123f5601083611d2f565b9150612400826123c1565b602082019050919050565b5f6020820190508181035f830152612422816123e9565b9050919050565b5f60a08201905061243c5f830188611f56565b6124496020830187612046565b6124566040830186611e80565b6124636060830185611e80565b6124706080830184611e80565b9695505050505050565b5f60808201905061248d5f830187611f56565b61249a6020830186611fc8565b6124a76040830185611f56565b6124b46060830184611f56565b95945050505050565b7f496e76616c6964207369676e6174757265206f7220756e617574686f72697a655f8201527f6400000000000000000000000000000000000000000000000000000000000000602082015250565b5f612517602183611d2f565b9150612522826124bd565b604082019050919050565b5f6020820190508181035f8301526125448161250b565b9050919050565b5f8160601b9050919050565b5f6125618261254b565b9050919050565b5f61257282612557565b9050919050565b61258a61258582611dd4565b612568565b82525050565b5f819050919050565b6125aa6125a582611e0f565b612590565b82525050565b5f6125bb8287612579565b6014820191506125cb8286612599565b6020820191506125db8285612599565b6020820191506125eb8284612599565b60208201915081905095945050505050565b7f5555494420616c726561647920757365640000000000000000000000000000005f82015250565b5f612631601183611d2f565b915061263c826125fd565b602082019050919050565b5f6020820190508181035f83015261265e81612625565b9050919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f61269c82611e0f565b91506126a783611e0f565b92508282026126b581611e0f565b915082820484148315176126cc576126cb612665565b5b5092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601260045260245ffd5b5f61270a82611e0f565b915061271583611e0f565b925082612725576127246126d3565b5b828204905092915050565b5f61273a82611e0f565b915061274583611e0f565b925082820390508181111561275d5761275c612665565b5b92915050565b5f6060820190506127765f830186612046565b6127836020830185611e80565b6127906040830184611e80565b949350505050565b5f6127a282611e0f565b91506127ad83611e0f565b92508282019050808211156127c5576127c4612665565b5b92915050565b5f6040820190506127de5f830185612046565b6127eb6020830184611f56565b9392505050565b7f5061757361626c653a206e6f74207061757365640000000000000000000000005f82015250565b5f612826601483611d2f565b9150612831826127f2565b602082019050919050565b5f6020820190508181035f8301526128538161281a565b9050919050565b7f5061757361626c653a20706175736564000000000000000000000000000000005f82015250565b5f61288e601083611d2f565b91506128998261285a565b602082019050919050565b5f6020820190508181035f8301526128bb81612882565b9050919050565b5f60a0820190506128d55f830188611f56565b6128e26020830187611f56565b6128ef6040830186611f56565b6128fc6060830185611e80565b6129096080830184612046565b969550505050505056fea2646970667358221220df0c0512a50a89fbfba98182e9ac6595bec613deb87ee5103aa8afdb361d852a64736f6c634300081a0033

Deployed Bytecode Sourcemap

77649:3898:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30395:204;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;13297:91;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;15590:190;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;14399:99;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;16358:249;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;31675:122;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;32107:138;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;14250:84;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;33244:251;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;81460:84;;;:::i;:::-;;81086:146;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;79142:125;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;36694:86;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;78111:25;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;14561:118;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;79382:191;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;78184:29;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;81305:80;;;:::i;:::-;;75979:580;;;:::i;:::-;;;;;;;;;;;;;:::i;:::-;;;;;;;;30691:138;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;13507:95;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;80116:899;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;30003:49;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;79636:355;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;78259:35;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;77775:62;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;32538:140;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;15129:142;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;30395:204;30480:4;30519:32;30504:47;;;:11;:47;;;;:87;;;;30555:36;30579:11;30555:23;:36::i;:::-;30504:87;30497:94;;30395:204;;;:::o;13297:91::-;13342:13;13375:5;13368:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13297:91;:::o;15590:190::-;15663:4;15680:13;15696:12;:10;:12::i;:::-;15680:28;;15719:31;15728:5;15735:7;15744:5;15719:8;:31::i;:::-;15768:4;15761:11;;;15590:190;;;;:::o;14399:99::-;14451:7;14478:12;;14471:19;;14399:99;:::o;16358:249::-;16445:4;16462:15;16480:12;:10;:12::i;:::-;16462:30;;16503:37;16519:4;16525:7;16534:5;16503:15;:37::i;:::-;16551:26;16561:4;16567:2;16571:5;16551:9;:26::i;:::-;16595:4;16588:11;;;16358:249;;;;;:::o;31675:122::-;31740:7;31767:6;:12;31774:4;31767:12;;;;;;;;;;;:22;;;31760:29;;31675:122;;;:::o;32107:138::-;32181:18;32194:4;32181:12;:18::i;:::-;30287:16;30298:4;30287:10;:16::i;:::-;32212:25:::1;32223:4;32229:7;32212:10;:25::i;:::-;;32107:138:::0;;;:::o;14250:84::-;14299:5;14324:2;14317:9;;14250:84;:::o;33244:251::-;33360:12;:10;:12::i;:::-;33338:34;;:18;:34;;;33334:104;;33396:30;;;;;;;;;;;;;;33334:104;33450:37;33462:4;33468:18;33450:11;:37::i;:::-;;33244:251;;:::o;81460:84::-;30048:4;81495:18;;30287:16;30298:4;30287:10;:16::i;:::-;81526:10:::1;:8;:10::i;:::-;81460:84:::0;:::o;81086:146::-;81134:25;81140:10;81152:6;81134:5;:25::i;:::-;81086:146;:::o;79142:125::-;30048:4;79204:18;;30287:16;30298:4;30287:10;:16::i;:::-;79248:11:::1;79235:10;;:24;;;;;;;;;;;;;;;;;;79142:125:::0;;:::o;36694:86::-;36741:4;36765:7;;;;;;;;;;;36758:14;;36694:86;:::o;78111:25::-;;;;;;;;;;;;;:::o;14561:118::-;14626:7;14653:9;:18;14663:7;14653:18;;;;;;;;;;;;;;;;14646:25;;14561:118;;;:::o;79382:191::-;30048:4;79444:18;;30287:16;30298:4;30287:10;:16::i;:::-;78293:1:::1;79483:11;:22;;79475:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;79554:11;79541:10;:24;;;;79382:191:::0;;:::o;78184:29::-;;;;:::o;81305:80::-;30048:4;81338:18;;30287:16;30298:4;30287:10;:16::i;:::-;81369:8:::1;:6;:8::i;:::-;81305:80:::0;:::o;75979:580::-;76082:13;76110:18;76143:21;76179:15;76209:25;76249:12;76276:27;76384:13;:11;:13::i;:::-;76412:16;:14;:16::i;:::-;76443:13;76479:4;76507:1;76499:10;;76538:1;76524:16;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;76331:220;;;;;;;;;;;;;;;;;;;;;75979:580;;;;;;;:::o;30691:138::-;30768:4;30792:6;:12;30799:4;30792:12;;;;;;;;;;;:20;;:29;30813:7;30792:29;;;;;;;;;;;;;;;;;;;;;;;;;30785:36;;30691:138;;;;:::o;13507:95::-;13554:13;13587:7;13580:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13507:95;:::o;80116:899::-;80236:7;:16;;;80217:15;:35;;80209:64;;;;;;;;;;;;:::i;:::-;;;;;;;;;80284:18;77972:81;80341:7;:10;;;;;;;;;;:::i;:::-;80353:7;:14;;;80369:7;:12;;;80383:7;:16;;;80315:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;80305:96;;;;;;80284:117;;80412:14;80429:28;80446:10;80429:16;:28::i;:::-;80412:45;;80468:14;80485:26;80495:6;80503:1;80506;80509;80485:26;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;80468:43;;80530:28;77813:24;80551:6;80530:7;:28::i;:::-;80522:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;80661:23;80714:7;:10;;;;;;;;;;:::i;:::-;80726:7;:14;;;80742:7;:12;;;80756:13;80697:73;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;80687:84;;;;;;80661:110;;80791:9;:26;80801:15;80791:26;;;;;;;;;;;;;;;;;;;;;80790:27;80782:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;80916:4;80887:9;:26;80897:15;80887:26;;;;;;;;;;;;:33;;;;;;;;;;;;;;;;;;80933;80939:7;:10;;;;;;;;;;:::i;:::-;80951:7;:14;;;80933:5;:33::i;:::-;80198:817;;;;80116:899;;;;:::o;30003:49::-;30048:4;30003:49;;;:::o;79636:355::-;79714:4;79731:11;79769:3;79755:10;;79746:6;:19;;;;:::i;:::-;79745:27;;;;:::i;:::-;79731:41;;79783:22;79817:3;79808:6;:12;;;;:::i;:::-;79783:37;;79831:31;79846:10;;;;;;;;;;;79858:3;79831:14;:31::i;:::-;;79893:41;79908:9;79919:14;79893;:41::i;:::-;;79979:4;79972:11;;;;79636:355;;;;:::o;78259:35::-;78293:1;78259:35;:::o;77775:62::-;77813:24;77775:62;:::o;32538:140::-;32613:18;32626:4;32613:12;:18::i;:::-;30287:16;30298:4;30287:10;:16::i;:::-;32644:26:::1;32656:4;32662:7;32644:11;:26::i;:::-;;32538:140:::0;;;:::o;15129:142::-;15209:7;15236:11;:18;15248:5;15236:18;;;;;;;;;;;;;;;:27;15255:7;15236:27;;;;;;;;;;;;;;;;15229:34;;15129:142;;;;:::o;27731:148::-;27807:4;27846:25;27831:40;;;:11;:40;;;;27824:47;;27731:148;;;:::o;4302:98::-;4355:7;4382:10;4375:17;;4302:98;:::o;20417:130::-;20502:37;20511:5;20518:7;20527:5;20534:4;20502:8;:37::i;:::-;20417:130;;;:::o;22133:487::-;22233:24;22260:25;22270:5;22277:7;22260:9;:25::i;:::-;22233:52;;22320:17;22300:16;:37;22296:317;;22377:5;22358:16;:24;22354:132;;;22437:7;22446:16;22464:5;22410:60;;;;;;;;;;;;;:::i;:::-;;;;;;;;22354:132;22529:57;22538:5;22545:7;22573:5;22554:16;:24;22580:5;22529:8;:57::i;:::-;22296:317;22222:398;22133:487;;;:::o;16992:308::-;17092:1;17076:18;;:4;:18;;;17072:88;;17145:1;17118:30;;;;;;;;;;;:::i;:::-;;;;;;;;17072:88;17188:1;17174:16;;:2;:16;;;17170:88;;17243:1;17214:32;;;;;;;;;;;:::i;:::-;;;;;;;;17170:88;17268:24;17276:4;17282:2;17286:5;17268:7;:24::i;:::-;16992:308;;;:::o;31044:105::-;31111:30;31122:4;31128:12;:10;:12::i;:::-;31111:10;:30::i;:::-;31044:105;:::o;34121:324::-;34198:4;34220:22;34228:4;34234:7;34220;:22::i;:::-;34215:223;;34291:4;34259:6;:12;34266:4;34259:12;;;;;;;;;;;:20;;:29;34280:7;34259:29;;;;;;;;;;;;;;;;:36;;;;;;;;;;;;;;;;;;34342:12;:10;:12::i;:::-;34315:40;;34333:7;34315:40;;34327:4;34315:40;;;;;;;;;;34377:4;34370:11;;;;34215:223;34421:5;34414:12;;34121:324;;;;;:::o;34689:325::-;34767:4;34788:22;34796:4;34802:7;34788;:22::i;:::-;34784:223;;;34859:5;34827:6;:12;34834:4;34827:12;;;;;;;;;;;:20;;:29;34848:7;34827:29;;;;;;;;;;;;;;;;:37;;;;;;;;;;;;;;;;;;34911:12;:10;:12::i;:::-;34884:40;;34902:7;34884:40;;34896:4;34884:40;;;;;;;;;;34946:4;34939:11;;;;34784:223;34990:5;34983:12;;34689:325;;;;;:::o;37549:120::-;36558:16;:14;:16::i;:::-;37618:5:::1;37608:7;;:15;;;;;;;;;;;;;;;;;;37639:22;37648:12;:10;:12::i;:::-;37639:22;;;;;;:::i;:::-;;;;;;;;37549:120::o:0;19653:211::-;19743:1;19724:21;;:7;:21;;;19720:91;;19796:1;19769:30;;;;;;;;;;;:::i;:::-;;;;;;;;19720:91;19821:35;19829:7;19846:1;19850:5;19821:7;:35::i;:::-;19653:211;;:::o;37290:118::-;36299:19;:17;:19::i;:::-;37360:4:::1;37350:7;;:14;;;;;;;;;;;;;;;;;;37380:20;37387:12;:10;:12::i;:::-;37380:20;;;;;;:::i;:::-;;;;;;;;37290:118::o:0;76888:128::-;76934:13;76967:41;76994:13;76967:5;:26;;:41;;;;:::i;:::-;76960:48;;76888:128;:::o;77351:137::-;77400:13;77433:47;77463:16;77433:8;:29;;:47;;;;:::i;:::-;77426:54;;77351:137;:::o;75745:178::-;75822:7;75849:66;75882:20;:18;:20::i;:::-;75904:10;75849:32;:66::i;:::-;75842:73;;75745:178;;;:::o;19112:213::-;19202:1;19183:21;;:7;:21;;;19179:93;;19257:1;19228:32;;;;;;;;;;;:::i;:::-;;;;;;;;19179:93;19282:35;19298:1;19302:7;19311:5;19282:7;:35::i;:::-;19112:213;;:::o;14884:182::-;14953:4;14970:13;14986:12;:10;:12::i;:::-;14970:28;;15009:27;15019:5;15026:2;15030:5;15009:9;:27::i;:::-;15054:4;15047:11;;;14884:182;;;;:::o;21398:443::-;21528:1;21511:19;;:5;:19;;;21507:91;;21583:1;21554:32;;;;;;;;;;;:::i;:::-;;;;;;;;21507:91;21631:1;21612:21;;:7;:21;;;21608:92;;21685:1;21657:31;;;;;;;;;;;:::i;:::-;;;;;;;;21608:92;21740:5;21710:11;:18;21722:5;21710:18;;;;;;;;;;;;;;;:27;21729:7;21710:27;;;;;;;;;;;;;;;:35;;;;21760:9;21756:78;;;21807:7;21791:31;;21800:5;21791:31;;;21816:5;21791:31;;;;;;:::i;:::-;;;;;;;;21756:78;21398:443;;;;:::o;17624:1135::-;17730:1;17714:18;;:4;:18;;;17710:552;;17868:5;17852:12;;:21;;;;;;;:::i;:::-;;;;;;;;17710:552;;;17906:19;17928:9;:15;17938:4;17928:15;;;;;;;;;;;;;;;;17906:37;;17976:5;17962:11;:19;17958:117;;;18034:4;18040:11;18053:5;18009:50;;;;;;;;;;;;;:::i;:::-;;;;;;;;17958:117;18230:5;18216:11;:19;18198:9;:15;18208:4;18198:15;;;;;;;;;;;;;;;:37;;;;17891:371;17710:552;18292:1;18278:16;;:2;:16;;;18274:435;;18460:5;18444:12;;:21;;;;;;;;;;;18274:435;;;18677:5;18660:9;:13;18670:2;18660:13;;;;;;;;;;;;;;;;:22;;;;;;;;;;;18274:435;18741:2;18726:25;;18735:4;18726:25;;;18745:5;18726:25;;;;;;:::i;:::-;;;;;;;;17624:1135;;;:::o;31285:201::-;31374:22;31382:4;31388:7;31374;:22::i;:::-;31369:110;;31453:7;31462:4;31420:47;;;;;;;;;;;;:::i;:::-;;;;;;;;31369:110;31285:201;;:::o;37038:108::-;37105:8;:6;:8::i;:::-;37097:41;;;;;;;;;;;;:::i;:::-;;;;;;;;;37038:108::o;36853:::-;36924:8;:6;:8::i;:::-;36923:9;36915:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;36853:108::o;69115:273::-;69209:13;67061:66;69268:17;;69258:5;69239:46;69235:146;;69309:15;69318:5;69309:8;:15::i;:::-;69302:22;;;;69235:146;69364:5;69357:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;69115:273;;;;;:::o;74646:268::-;74699:7;74740:11;74723:28;;74731:4;74723:28;;;:63;;;;;74772:14;74755:13;:31;74723:63;74719:188;;;74810:22;74803:29;;;;74719:188;74872:23;:21;:23::i;:::-;74865:30;;74646:268;;:::o;61138:410::-;61231:14;61343:4;61337:11;61374:10;61369:3;61362:23;61422:15;61415:4;61410:3;61406:14;61399:39;61475:10;61468:4;61463:3;61459:14;61452:34;61525:4;61520:3;61510:20;61500:30;;61311:230;61138:410;;;;:::o;67770:415::-;67829:13;67855:11;67869:16;67880:4;67869:10;:16::i;:::-;67855:30;;67975:17;68006:2;67995:14;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;67975:34;;68100:3;68095;68088:16;68141:4;68134;68129:3;68125:14;68118:28;68174:3;68167:10;;;;67770:415;;;:::o;74922:181::-;74977:7;72838:95;75036:11;75049:14;75065:13;75088:4;75014:80;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;75004:91;;;;;;74997:98;;74922:181;:::o;68262:251::-;68323:7;68343:14;68396:4;68387;68360:33;;:40;68343:57;;68424:2;68415:6;:11;68411:71;;;68450:20;;;;;;;;;;;;;;68411:71;68499:6;68492:13;;;68262:251;;;:::o;88:117:1:-;197:1;194;187:12;334:149;370:7;410:66;403:5;399:78;388:89;;334:149;;;:::o;489:120::-;561:23;578:5;561:23;:::i;:::-;554:5;551:34;541:62;;599:1;596;589:12;541:62;489:120;:::o;615:137::-;660:5;698:6;685:20;676:29;;714:32;740:5;714:32;:::i;:::-;615:137;;;;:::o;758:327::-;816:6;865:2;853:9;844:7;840:23;836:32;833:119;;;871:79;;:::i;:::-;833:119;991:1;1016:52;1060:7;1051:6;1040:9;1036:22;1016:52;:::i;:::-;1006:62;;962:116;758:327;;;;:::o;1091:90::-;1125:7;1168:5;1161:13;1154:21;1143:32;;1091:90;;;:::o;1187:109::-;1268:21;1283:5;1268:21;:::i;:::-;1263:3;1256:34;1187:109;;:::o;1302:210::-;1389:4;1427:2;1416:9;1412:18;1404:26;;1440:65;1502:1;1491:9;1487:17;1478:6;1440:65;:::i;:::-;1302:210;;;;:::o;1518:99::-;1570:6;1604:5;1598:12;1588:22;;1518:99;;;:::o;1623:169::-;1707:11;1741:6;1736:3;1729:19;1781:4;1776:3;1772:14;1757:29;;1623:169;;;;:::o;1798:139::-;1887:6;1882:3;1877;1871:23;1928:1;1919:6;1914:3;1910:16;1903:27;1798:139;;;:::o;1943:102::-;1984:6;2035:2;2031:7;2026:2;2019:5;2015:14;2011:28;2001:38;;1943:102;;;:::o;2051:377::-;2139:3;2167:39;2200:5;2167:39;:::i;:::-;2222:71;2286:6;2281:3;2222:71;:::i;:::-;2215:78;;2302:65;2360:6;2355:3;2348:4;2341:5;2337:16;2302:65;:::i;:::-;2392:29;2414:6;2392:29;:::i;:::-;2387:3;2383:39;2376:46;;2143:285;2051:377;;;;:::o;2434:313::-;2547:4;2585:2;2574:9;2570:18;2562:26;;2634:9;2628:4;2624:20;2620:1;2609:9;2605:17;2598:47;2662:78;2735:4;2726:6;2662:78;:::i;:::-;2654:86;;2434:313;;;;:::o;2753:126::-;2790:7;2830:42;2823:5;2819:54;2808:65;;2753:126;;;:::o;2885:96::-;2922:7;2951:24;2969:5;2951:24;:::i;:::-;2940:35;;2885:96;;;:::o;2987:122::-;3060:24;3078:5;3060:24;:::i;:::-;3053:5;3050:35;3040:63;;3099:1;3096;3089:12;3040:63;2987:122;:::o;3115:139::-;3161:5;3199:6;3186:20;3177:29;;3215:33;3242:5;3215:33;:::i;:::-;3115:139;;;;:::o;3260:77::-;3297:7;3326:5;3315:16;;3260:77;;;:::o;3343:122::-;3416:24;3434:5;3416:24;:::i;:::-;3409:5;3406:35;3396:63;;3455:1;3452;3445:12;3396:63;3343:122;:::o;3471:139::-;3517:5;3555:6;3542:20;3533:29;;3571:33;3598:5;3571:33;:::i;:::-;3471:139;;;;:::o;3616:474::-;3684:6;3692;3741:2;3729:9;3720:7;3716:23;3712:32;3709:119;;;3747:79;;:::i;:::-;3709:119;3867:1;3892:53;3937:7;3928:6;3917:9;3913:22;3892:53;:::i;:::-;3882:63;;3838:117;3994:2;4020:53;4065:7;4056:6;4045:9;4041:22;4020:53;:::i;:::-;4010:63;;3965:118;3616:474;;;;;:::o;4096:118::-;4183:24;4201:5;4183:24;:::i;:::-;4178:3;4171:37;4096:118;;:::o;4220:222::-;4313:4;4351:2;4340:9;4336:18;4328:26;;4364:71;4432:1;4421:9;4417:17;4408:6;4364:71;:::i;:::-;4220:222;;;;:::o;4448:619::-;4525:6;4533;4541;4590:2;4578:9;4569:7;4565:23;4561:32;4558:119;;;4596:79;;:::i;:::-;4558:119;4716:1;4741:53;4786:7;4777:6;4766:9;4762:22;4741:53;:::i;:::-;4731:63;;4687:117;4843:2;4869:53;4914:7;4905:6;4894:9;4890:22;4869:53;:::i;:::-;4859:63;;4814:118;4971:2;4997:53;5042:7;5033:6;5022:9;5018:22;4997:53;:::i;:::-;4987:63;;4942:118;4448:619;;;;;:::o;5073:77::-;5110:7;5139:5;5128:16;;5073:77;;;:::o;5156:122::-;5229:24;5247:5;5229:24;:::i;:::-;5222:5;5219:35;5209:63;;5268:1;5265;5258:12;5209:63;5156:122;:::o;5284:139::-;5330:5;5368:6;5355:20;5346:29;;5384:33;5411:5;5384:33;:::i;:::-;5284:139;;;;:::o;5429:329::-;5488:6;5537:2;5525:9;5516:7;5512:23;5508:32;5505:119;;;5543:79;;:::i;:::-;5505:119;5663:1;5688:53;5733:7;5724:6;5713:9;5709:22;5688:53;:::i;:::-;5678:63;;5634:117;5429:329;;;;:::o;5764:118::-;5851:24;5869:5;5851:24;:::i;:::-;5846:3;5839:37;5764:118;;:::o;5888:222::-;5981:4;6019:2;6008:9;6004:18;5996:26;;6032:71;6100:1;6089:9;6085:17;6076:6;6032:71;:::i;:::-;5888:222;;;;:::o;6116:474::-;6184:6;6192;6241:2;6229:9;6220:7;6216:23;6212:32;6209:119;;;6247:79;;:::i;:::-;6209:119;6367:1;6392:53;6437:7;6428:6;6417:9;6413:22;6392:53;:::i;:::-;6382:63;;6338:117;6494:2;6520:53;6565:7;6556:6;6545:9;6541:22;6520:53;:::i;:::-;6510:63;;6465:118;6116:474;;;;;:::o;6596:86::-;6631:7;6671:4;6664:5;6660:16;6649:27;;6596:86;;;:::o;6688:112::-;6771:22;6787:5;6771:22;:::i;:::-;6766:3;6759:35;6688:112;;:::o;6806:214::-;6895:4;6933:2;6922:9;6918:18;6910:26;;6946:67;7010:1;6999:9;6995:17;6986:6;6946:67;:::i;:::-;6806:214;;;;:::o;7026:329::-;7085:6;7134:2;7122:9;7113:7;7109:23;7105:32;7102:119;;;7140:79;;:::i;:::-;7102:119;7260:1;7285:53;7330:7;7321:6;7310:9;7306:22;7285:53;:::i;:::-;7275:63;;7231:117;7026:329;;;;:::o;7361:::-;7420:6;7469:2;7457:9;7448:7;7444:23;7440:32;7437:119;;;7475:79;;:::i;:::-;7437:119;7595:1;7620:53;7665:7;7656:6;7645:9;7641:22;7620:53;:::i;:::-;7610:63;;7566:117;7361:329;;;;:::o;7696:118::-;7783:24;7801:5;7783:24;:::i;:::-;7778:3;7771:37;7696:118;;:::o;7820:222::-;7913:4;7951:2;7940:9;7936:18;7928:26;;7964:71;8032:1;8021:9;8017:17;8008:6;7964:71;:::i;:::-;7820:222;;;;:::o;8048:149::-;8084:7;8124:66;8117:5;8113:78;8102:89;;8048:149;;;:::o;8203:115::-;8288:23;8305:5;8288:23;:::i;:::-;8283:3;8276:36;8203:115;;:::o;8324:114::-;8391:6;8425:5;8419:12;8409:22;;8324:114;;;:::o;8444:184::-;8543:11;8577:6;8572:3;8565:19;8617:4;8612:3;8608:14;8593:29;;8444:184;;;;:::o;8634:132::-;8701:4;8724:3;8716:11;;8754:4;8749:3;8745:14;8737:22;;8634:132;;;:::o;8772:108::-;8849:24;8867:5;8849:24;:::i;:::-;8844:3;8837:37;8772:108;;:::o;8886:179::-;8955:10;8976:46;9018:3;9010:6;8976:46;:::i;:::-;9054:4;9049:3;9045:14;9031:28;;8886:179;;;;:::o;9071:113::-;9141:4;9173;9168:3;9164:14;9156:22;;9071:113;;;:::o;9220:732::-;9339:3;9368:54;9416:5;9368:54;:::i;:::-;9438:86;9517:6;9512:3;9438:86;:::i;:::-;9431:93;;9548:56;9598:5;9548:56;:::i;:::-;9627:7;9658:1;9643:284;9668:6;9665:1;9662:13;9643:284;;;9744:6;9738:13;9771:63;9830:3;9815:13;9771:63;:::i;:::-;9764:70;;9857:60;9910:6;9857:60;:::i;:::-;9847:70;;9703:224;9690:1;9687;9683:9;9678:14;;9643:284;;;9647:14;9943:3;9936:10;;9344:608;;;9220:732;;;;:::o;9958:1215::-;10307:4;10345:3;10334:9;10330:19;10322:27;;10359:69;10425:1;10414:9;10410:17;10401:6;10359:69;:::i;:::-;10475:9;10469:4;10465:20;10460:2;10449:9;10445:18;10438:48;10503:78;10576:4;10567:6;10503:78;:::i;:::-;10495:86;;10628:9;10622:4;10618:20;10613:2;10602:9;10598:18;10591:48;10656:78;10729:4;10720:6;10656:78;:::i;:::-;10648:86;;10744:72;10812:2;10801:9;10797:18;10788:6;10744:72;:::i;:::-;10826:73;10894:3;10883:9;10879:19;10870:6;10826:73;:::i;:::-;10909;10977:3;10966:9;10962:19;10953:6;10909:73;:::i;:::-;11030:9;11024:4;11020:20;11014:3;11003:9;10999:19;10992:49;11058:108;11161:4;11152:6;11058:108;:::i;:::-;11050:116;;9958:1215;;;;;;;;;;:::o;11179:117::-;11288:1;11285;11278:12;11340:236;11417:5;11458:3;11449:6;11444:3;11440:16;11436:26;11433:113;;;11465:79;;:::i;:::-;11433:113;11564:6;11555:15;;11340:236;;;;:::o;11582:118::-;11653:22;11669:5;11653:22;:::i;:::-;11646:5;11643:33;11633:61;;11690:1;11687;11680:12;11633:61;11582:118;:::o;11706:135::-;11750:5;11788:6;11775:20;11766:29;;11804:31;11829:5;11804:31;:::i;:::-;11706:135;;;;:::o;11847:826::-;11962:6;11970;11978;11986;12035:3;12023:9;12014:7;12010:23;12006:33;12003:120;;;12042:79;;:::i;:::-;12003:120;12162:1;12187:84;12263:7;12254:6;12243:9;12239:22;12187:84;:::i;:::-;12177:94;;12133:148;12320:3;12347:51;12390:7;12381:6;12370:9;12366:22;12347:51;:::i;:::-;12337:61;;12291:117;12447:3;12474:53;12519:7;12510:6;12499:9;12495:22;12474:53;:::i;:::-;12464:63;;12418:119;12576:3;12603:53;12648:7;12639:6;12628:9;12624:22;12603:53;:::i;:::-;12593:63;;12547:119;11847:826;;;;;;;:::o;12679:474::-;12747:6;12755;12804:2;12792:9;12783:7;12779:23;12775:32;12772:119;;;12810:79;;:::i;:::-;12772:119;12930:1;12955:53;13000:7;12991:6;12980:9;12976:22;12955:53;:::i;:::-;12945:63;;12901:117;13057:2;13083:53;13128:7;13119:6;13108:9;13104:22;13083:53;:::i;:::-;13073:63;;13028:118;12679:474;;;;;:::o;13159:180::-;13207:77;13204:1;13197:88;13304:4;13301:1;13294:15;13328:4;13325:1;13318:15;13345:320;13389:6;13426:1;13420:4;13416:12;13406:22;;13473:1;13467:4;13463:12;13494:18;13484:81;;13550:4;13542:6;13538:17;13528:27;;13484:81;13612:2;13604:6;13601:14;13581:18;13578:38;13575:84;;13631:18;;:::i;:::-;13575:84;13396:269;13345:320;;;:::o;13671:170::-;13811:22;13807:1;13799:6;13795:14;13788:46;13671:170;:::o;13847:366::-;13989:3;14010:67;14074:2;14069:3;14010:67;:::i;:::-;14003:74;;14086:93;14175:3;14086:93;:::i;:::-;14204:2;14199:3;14195:12;14188:19;;13847:366;;;:::o;14219:419::-;14385:4;14423:2;14412:9;14408:18;14400:26;;14472:9;14466:4;14462:20;14458:1;14447:9;14443:17;14436:47;14500:131;14626:4;14500:131;:::i;:::-;14492:139;;14219:419;;;:::o;14644:180::-;14692:77;14689:1;14682:88;14789:4;14786:1;14779:15;14813:4;14810:1;14803:15;14830:166;14970:18;14966:1;14958:6;14954:14;14947:42;14830:166;:::o;15002:366::-;15144:3;15165:67;15229:2;15224:3;15165:67;:::i;:::-;15158:74;;15241:93;15330:3;15241:93;:::i;:::-;15359:2;15354:3;15350:12;15343:19;;15002:366;;;:::o;15374:419::-;15540:4;15578:2;15567:9;15563:18;15555:26;;15627:9;15621:4;15617:20;15613:1;15602:9;15598:17;15591:47;15655:131;15781:4;15655:131;:::i;:::-;15647:139;;15374:419;;;:::o;15799:664::-;16004:4;16042:3;16031:9;16027:19;16019:27;;16056:71;16124:1;16113:9;16109:17;16100:6;16056:71;:::i;:::-;16137:72;16205:2;16194:9;16190:18;16181:6;16137:72;:::i;:::-;16219;16287:2;16276:9;16272:18;16263:6;16219:72;:::i;:::-;16301;16369:2;16358:9;16354:18;16345:6;16301:72;:::i;:::-;16383:73;16451:3;16440:9;16436:19;16427:6;16383:73;:::i;:::-;15799:664;;;;;;;;:::o;16469:545::-;16642:4;16680:3;16669:9;16665:19;16657:27;;16694:71;16762:1;16751:9;16747:17;16738:6;16694:71;:::i;:::-;16775:68;16839:2;16828:9;16824:18;16815:6;16775:68;:::i;:::-;16853:72;16921:2;16910:9;16906:18;16897:6;16853:72;:::i;:::-;16935;17003:2;16992:9;16988:18;16979:6;16935:72;:::i;:::-;16469:545;;;;;;;:::o;17020:220::-;17160:34;17156:1;17148:6;17144:14;17137:58;17229:3;17224:2;17216:6;17212:15;17205:28;17020:220;:::o;17246:366::-;17388:3;17409:67;17473:2;17468:3;17409:67;:::i;:::-;17402:74;;17485:93;17574:3;17485:93;:::i;:::-;17603:2;17598:3;17594:12;17587:19;;17246:366;;;:::o;17618:419::-;17784:4;17822:2;17811:9;17807:18;17799:26;;17871:9;17865:4;17861:20;17857:1;17846:9;17842:17;17835:47;17899:131;18025:4;17899:131;:::i;:::-;17891:139;;17618:419;;;:::o;18043:94::-;18076:8;18124:5;18120:2;18116:14;18095:35;;18043:94;;;:::o;18143:::-;18182:7;18211:20;18225:5;18211:20;:::i;:::-;18200:31;;18143:94;;;:::o;18243:100::-;18282:7;18311:26;18331:5;18311:26;:::i;:::-;18300:37;;18243:100;;;:::o;18349:157::-;18454:45;18474:24;18492:5;18474:24;:::i;:::-;18454:45;:::i;:::-;18449:3;18442:58;18349:157;;:::o;18512:79::-;18551:7;18580:5;18569:16;;18512:79;;;:::o;18597:157::-;18702:45;18722:24;18740:5;18722:24;:::i;:::-;18702:45;:::i;:::-;18697:3;18690:58;18597:157;;:::o;18760:679::-;18956:3;18971:75;19042:3;19033:6;18971:75;:::i;:::-;19071:2;19066:3;19062:12;19055:19;;19084:75;19155:3;19146:6;19084:75;:::i;:::-;19184:2;19179:3;19175:12;19168:19;;19197:75;19268:3;19259:6;19197:75;:::i;:::-;19297:2;19292:3;19288:12;19281:19;;19310:75;19381:3;19372:6;19310:75;:::i;:::-;19410:2;19405:3;19401:12;19394:19;;19430:3;19423:10;;18760:679;;;;;;;:::o;19445:167::-;19585:19;19581:1;19573:6;19569:14;19562:43;19445:167;:::o;19618:366::-;19760:3;19781:67;19845:2;19840:3;19781:67;:::i;:::-;19774:74;;19857:93;19946:3;19857:93;:::i;:::-;19975:2;19970:3;19966:12;19959:19;;19618:366;;;:::o;19990:419::-;20156:4;20194:2;20183:9;20179:18;20171:26;;20243:9;20237:4;20233:20;20229:1;20218:9;20214:17;20207:47;20271:131;20397:4;20271:131;:::i;:::-;20263:139;;19990:419;;;:::o;20415:180::-;20463:77;20460:1;20453:88;20560:4;20557:1;20550:15;20584:4;20581:1;20574:15;20601:410;20641:7;20664:20;20682:1;20664:20;:::i;:::-;20659:25;;20698:20;20716:1;20698:20;:::i;:::-;20693:25;;20753:1;20750;20746:9;20775:30;20793:11;20775:30;:::i;:::-;20764:41;;20954:1;20945:7;20941:15;20938:1;20935:22;20915:1;20908:9;20888:83;20865:139;;20984:18;;:::i;:::-;20865:139;20649:362;20601:410;;;;:::o;21017:180::-;21065:77;21062:1;21055:88;21162:4;21159:1;21152:15;21186:4;21183:1;21176:15;21203:185;21243:1;21260:20;21278:1;21260:20;:::i;:::-;21255:25;;21294:20;21312:1;21294:20;:::i;:::-;21289:25;;21333:1;21323:35;;21338:18;;:::i;:::-;21323:35;21380:1;21377;21373:9;21368:14;;21203:185;;;;:::o;21394:194::-;21434:4;21454:20;21472:1;21454:20;:::i;:::-;21449:25;;21488:20;21506:1;21488:20;:::i;:::-;21483:25;;21532:1;21529;21525:9;21517:17;;21556:1;21550:4;21547:11;21544:37;;;21561:18;;:::i;:::-;21544:37;21394:194;;;;:::o;21594:442::-;21743:4;21781:2;21770:9;21766:18;21758:26;;21794:71;21862:1;21851:9;21847:17;21838:6;21794:71;:::i;:::-;21875:72;21943:2;21932:9;21928:18;21919:6;21875:72;:::i;:::-;21957;22025:2;22014:9;22010:18;22001:6;21957:72;:::i;:::-;21594:442;;;;;;:::o;22042:191::-;22082:3;22101:20;22119:1;22101:20;:::i;:::-;22096:25;;22135:20;22153:1;22135:20;:::i;:::-;22130:25;;22178:1;22175;22171:9;22164:16;;22199:3;22196:1;22193:10;22190:36;;;22206:18;;:::i;:::-;22190:36;22042:191;;;;:::o;22239:332::-;22360:4;22398:2;22387:9;22383:18;22375:26;;22411:71;22479:1;22468:9;22464:17;22455:6;22411:71;:::i;:::-;22492:72;22560:2;22549:9;22545:18;22536:6;22492:72;:::i;:::-;22239:332;;;;;:::o;22577:170::-;22717:22;22713:1;22705:6;22701:14;22694:46;22577:170;:::o;22753:366::-;22895:3;22916:67;22980:2;22975:3;22916:67;:::i;:::-;22909:74;;22992:93;23081:3;22992:93;:::i;:::-;23110:2;23105:3;23101:12;23094:19;;22753:366;;;:::o;23125:419::-;23291:4;23329:2;23318:9;23314:18;23306:26;;23378:9;23372:4;23368:20;23364:1;23353:9;23349:17;23342:47;23406:131;23532:4;23406:131;:::i;:::-;23398:139;;23125:419;;;:::o;23550:166::-;23690:18;23686:1;23678:6;23674:14;23667:42;23550:166;:::o;23722:366::-;23864:3;23885:67;23949:2;23944:3;23885:67;:::i;:::-;23878:74;;23961:93;24050:3;23961:93;:::i;:::-;24079:2;24074:3;24070:12;24063:19;;23722:366;;;:::o;24094:419::-;24260:4;24298:2;24287:9;24283:18;24275:26;;24347:9;24341:4;24337:20;24333:1;24322:9;24318:17;24311:47;24375:131;24501:4;24375:131;:::i;:::-;24367:139;;24094:419;;;:::o;24519:664::-;24724:4;24762:3;24751:9;24747:19;24739:27;;24776:71;24844:1;24833:9;24829:17;24820:6;24776:71;:::i;:::-;24857:72;24925:2;24914:9;24910:18;24901:6;24857:72;:::i;:::-;24939;25007:2;24996:9;24992:18;24983:6;24939:72;:::i;:::-;25021;25089:2;25078:9;25074:18;25065:6;25021:72;:::i;:::-;25103:73;25171:3;25160:9;25156:19;25147:6;25103:73;:::i;:::-;24519:664;;;;;;;;:::o

Swarm Source

ipfs://df0c0512a50a89fbfba98182e9ac6595bec613deb87ee5103aa8afdb361d852a

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.

Tools & Services