Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
• library Strings
•    - function toString(uint256 value)
•    - function toHexString(uint256 value)
•    - function toHexString(uint256 value, u ...
• library ECDSA
•    - function _throwError(RecoverError err ...
•    - function tryRecover(bytes32 hash, byt ...
•    - function recover(bytes32 hash, bytes ...
•    - function tryRecover(
•    - function recover(
•    - function tryRecover(
•    - function recover(
•    - function toEthSignedMessageHash(bytes ...
•    - function toEthSignedMessageHash(bytes ...
•    - function toTypedDataHash(bytes32 doma ...
•    - function _domainSeparatorV4()
•    - function _buildDomainSeparator(
•    - function _hashTypedDataV4(bytes32 str ...
•  contract ClaimNAO is EIP712(&q ... *
•    - function isClaimed(address account)
•    - function claim(

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2022-01-12
*/

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


// OpenZeppelin Contracts v4.4.1 (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

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

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

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

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


// OpenZeppelin Contracts v4.4.0 (utils/Strings.sol)

pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        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_SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }
}

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


// OpenZeppelin Contracts v4.4.0 (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.0;


/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        } else if (error == RecoverError.InvalidSignatureV) {
            revert("ECDSA: invalid signature 'v' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
        // Check the signature length
        // - case 65: r,s,v signature (standard)
        // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else if (signature.length == 64) {
            bytes32 r;
            bytes32 vs;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            assembly {
                r := mload(add(signature, 0x20))
                vs := mload(add(signature, 0x40))
            }
            return tryRecover(hash, r, vs);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength);
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address, RecoverError) {
        bytes32 s;
        uint8 v;
        assembly {
            s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
            v := add(shr(255, vs), 27)
        }
        return tryRecover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     *
     * _Available since v4.2._
     */
    function recover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address, RecoverError) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS);
        }
        if (v != 27 && v != 28) {
            return (address(0), RecoverError.InvalidSignatureV);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from `s`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
    }
}

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


// OpenZeppelin Contracts v4.4.0 (utils/cryptography/draft-EIP712.sol)

pragma solidity ^0.8.0;


/**
 * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.
 *
 * The encoding specified in the EIP is very generic, and such a generic 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 their contracts 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].
 *
 * _Available since v3.4._
 */
abstract contract EIP712 {
    /* solhint-disable var-name-mixedcase */
    // 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 _CACHED_DOMAIN_SEPARATOR;
    uint256 private immutable _CACHED_CHAIN_ID;
    address private immutable _CACHED_THIS;

    bytes32 private immutable _HASHED_NAME;
    bytes32 private immutable _HASHED_VERSION;
    bytes32 private immutable _TYPE_HASH;

    /* solhint-enable var-name-mixedcase */

    /**
     * @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) {
        bytes32 hashedName = keccak256(bytes(name));
        bytes32 hashedVersion = keccak256(bytes(version));
        bytes32 typeHash = keccak256(
            "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
        );
        _HASHED_NAME = hashedName;
        _HASHED_VERSION = hashedVersion;
        _CACHED_CHAIN_ID = block.chainid;
        _CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(typeHash, hashedName, hashedVersion);
        _CACHED_THIS = address(this);
        _TYPE_HASH = typeHash;
    }

    /**
     * @dev Returns the domain separator for the current chain.
     */
    function _domainSeparatorV4() internal view returns (bytes32) {
        if (address(this) == _CACHED_THIS && block.chainid == _CACHED_CHAIN_ID) {
            return _CACHED_DOMAIN_SEPARATOR;
        } else {
            return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION);
        }
    }

    function _buildDomainSeparator(
        bytes32 typeHash,
        bytes32 nameHash,
        bytes32 versionHash
    ) private view returns (bytes32) {
        return keccak256(abi.encode(typeHash, nameHash, versionHash, 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 ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
    }
}

// File: contracts/ClaimNAO.sol


pragma solidity ^0.8.4;




contract ClaimNAO is EIP712("Claim NAO", "v1.0.0") {
    address public immutable signer;
    address public immutable token;

    mapping(address => bool) private isClaimedList;

    bytes32 public constant TICKET_HASH_TYPE =
        keccak256("Ticket(address recipient,uint256 amount,uint256 nonce,uint256 deadline)");

    constructor(address _signer, address _token) {
        signer = _signer;
        token = _token;
    }

    function isClaimed(address account) public view returns (bool) {
        return isClaimedList[account];
    }

    function claim(
        bytes memory signature,
        uint256 amount,
        uint256 nonce,
        uint256 deadline
    ) external {
        bytes32 digest = keccak256(
            abi.encodePacked(
                "\x19Ethereum Signed Message:\n32",
                _hashTypedDataV4(keccak256(abi.encode(TICKET_HASH_TYPE, msg.sender, amount, nonce, deadline)))
            )
        );
        address recoverAddress = ECDSA.recover(digest, signature);

        require(isClaimedList[msg.sender] == false, "ERROR: Already Claimed");
        require(recoverAddress == signer, "ERROR: Invalid Signature");
        require(recoverAddress != address(0), "ERROR: Invalid Signature (ECDSA)");
        require(block.timestamp < deadline, "ERROR: Signed Transaction Expired");

        isClaimedList[msg.sender] = true;
        require(IERC20(token).transfer(msg.sender, amount), "ERROR: Transfer Failed.");
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_signer","type":"address"},{"internalType":"address","name":"_token","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"TICKET_HASH_TYPE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"signature","type":"bytes"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"isClaimed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"signer","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

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

0x608060405234801561001057600080fd5b50600436106100575760003560e01c8063238ac9331461005c5780638cc08025146100a05780639b6e472b146100dc578063b252e2f214610111578063fc0c546a14610126575b600080fd5b6100837f000000000000000000000000000b5e295bbbff60ae691f1ba016f20ce38b8f4f81565b6040516001600160a01b0390911681526020015b60405180910390f35b6100cc6100ae36600461099b565b6001600160a01b031660009081526020819052604090205460ff1690565b6040519015158152602001610097565b6101037f57db62c8933759549e294fe05e317cce1d547f6006ea841c449235bda479557181565b604051908152602001610097565b61012461011f3660046109ed565b61014d565b005b6100837f000000000000000000000000d049206fb408a611e543791f2d8f102a8bc253dc81565b604080517f57db62c8933759549e294fe05e317cce1d547f6006ea841c449235bda479557160208201523391810191909152606081018490526080810183905260a081018290526000906101b99060c001604051602081830303815290604052805190602001206104b2565b6040517f19457468657265756d205369676e6564204d6573736167653a0a3332000000006020820152603c810191909152605c0160405160208183030381529060405280519060200120905060006102118287610506565b3360009081526020819052604090205490915060ff16156102725760405162461bcd60e51b815260206004820152601660248201527511549493d48e88105b1c9958591e4810db185a5b595960521b60448201526064015b60405180910390fd5b7f000000000000000000000000000b5e295bbbff60ae691f1ba016f20ce38b8f4f6001600160a01b0316816001600160a01b0316146102f35760405162461bcd60e51b815260206004820152601860248201527f4552524f523a20496e76616c6964205369676e617475726500000000000000006044820152606401610269565b6001600160a01b0381166103495760405162461bcd60e51b815260206004820181905260248201527f4552524f523a20496e76616c6964205369676e617475726520284543445341296044820152606401610269565b8242106103a25760405162461bcd60e51b815260206004820152602160248201527f4552524f523a205369676e6564205472616e73616374696f6e204578706972656044820152601960fa1b6064820152608401610269565b3360008181526020819052604090819020805460ff191660011790555163a9059cbb60e01b81526004810191909152602481018690527f000000000000000000000000d049206fb408a611e543791f2d8f102a8bc253dc6001600160a01b03169063a9059cbb90604401602060405180830381600087803b15801561042657600080fd5b505af115801561043a573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061045e91906109cb565b6104aa5760405162461bcd60e51b815260206004820152601760248201527f4552524f523a205472616e73666572204661696c65642e0000000000000000006044820152606401610269565b505050505050565b60006105006104bf61052a565b8360405161190160f01b6020820152602281018390526042810182905260009060620160405160208183030381529060405280519060200120905092915050565b92915050565b60008060006105158585610651565b91509150610522816106c1565b509392505050565b6000306001600160a01b037f0000000000000000000000009cc3a20d9e7789e5ad5f0b86edf2a65f55d26b411614801561058357507f000000000000000000000000000000000000000000000000000000000000000146145b156105ad57507f7cac8bc78a5a9f86aaf236ffb02eeb975c5483a5f2d2ab10b10b396421267eaf90565b50604080517f8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f6020808301919091527f2e0d4ddfefcbfc8180ded459c7172fda033a0d9bba0fa24887e9e746b117fa5e828401527f15124d26d1272f8d4d5266a24ca397811f414b8cd05a53b26b745f63af5ae2fc60608301524660808301523060a0808401919091528351808403909101815260c0909201909252805191012090565b6000808251604114156106885760208301516040840151606085015160001a61067c8782858561087f565b945094505050506106ba565b8251604014156106b257602083015160408401516106a786838361096c565b9350935050506106ba565b506000905060025b9250929050565b60008160048111156106d5576106d5610ab2565b14156106de5750565b60018160048111156106f2576106f2610ab2565b14156107405760405162461bcd60e51b815260206004820152601860248201527f45434453413a20696e76616c6964207369676e617475726500000000000000006044820152606401610269565b600281600481111561075457610754610ab2565b14156107a25760405162461bcd60e51b815260206004820152601f60248201527f45434453413a20696e76616c6964207369676e6174757265206c656e677468006044820152606401610269565b60038160048111156107b6576107b6610ab2565b141561080f5760405162461bcd60e51b815260206004820152602260248201527f45434453413a20696e76616c6964207369676e6174757265202773272076616c604482015261756560f01b6064820152608401610269565b600481600481111561082357610823610ab2565b141561087c5760405162461bcd60e51b815260206004820152602260248201527f45434453413a20696e76616c6964207369676e6174757265202776272076616c604482015261756560f01b6064820152608401610269565b50565b6000807f7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a08311156108b65750600090506003610963565b8460ff16601b141580156108ce57508460ff16601c14155b156108df5750600090506004610963565b6040805160008082526020820180845289905260ff881692820192909252606081018690526080810185905260019060a0016020604051602081039080840390855afa158015610933573d6000803e3d6000fd5b5050604051601f1901519150506001600160a01b03811661095c57600060019250925050610963565b9150600090505b94509492505050565b6000806001600160ff1b03831660ff84901c601b0161098d8782888561087f565b935093505050935093915050565b6000602082840312156109ad57600080fd5b81356001600160a01b03811681146109c457600080fd5b9392505050565b6000602082840312156109dd57600080fd5b815180151581146109c457600080fd5b60008060008060808587031215610a0357600080fd5b843567ffffffffffffffff80821115610a1b57600080fd5b818701915087601f830112610a2f57600080fd5b813581811115610a4157610a41610ac8565b604051601f8201601f19908116603f01168101908382118183101715610a6957610a69610ac8565b816040528281528a6020848701011115610a8257600080fd5b82602086016020830137600060209382018401529a91890135995050604088013597606001359650945050505050565b634e487b7160e01b600052602160045260246000fd5b634e487b7160e01b600052604160045260246000fdfea2646970667358221220e9ff5b2273e83640336059cb6c90d9257c025247173902080c5e131b75dd342264736f6c63430008070033

000000000000000000000000000b5e295bbbff60ae691f1ba016f20ce38b8f4f000000000000000000000000d049206fb408a611e543791f2d8f102a8bc253dc

-----Decoded View---------------
Arg [0] : _signer (address): 0x000B5E295BBbfF60Ae691f1bA016F20Ce38b8f4F
Arg [1] : _token (address): 0xd049206fB408a611E543791F2d8F102a8bC253dc

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000000b5e295bbbff60ae691f1ba016f20ce38b8f4f
Arg [1] : 000000000000000000000000d049206fb408a611e543791f2d8f102a8bc253dc

19287:1501:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19345:31;;;;;;;;-1:-1:-1;;;;;2674:32:1;;;2656:51;;2644:2;2629:18;19345:31:0;;;;;;;;19735:111;;;;;;:::i;:::-;-1:-1:-1;;;;;19816:22:0;19792:4;19816:22;;;;;;;;;;;;;;19735:111;;;;3162:14:1;;3155:22;3137:41;;3125:2;3110:18;19735:111:0;2997:187:1;19477:136:0;;19529:84;19477:136;;;;;3335:25:1;;;3323:2;3308:18;19477:136:0;3189:177:1;19854:931:0;;;;;;:::i;:::-;;:::i;:::-;;19383:30;;;;;19854:931;20161:65;;;19529:84;20161:65;;;3630:25:1;20190:10:0;3671:18:1;;;3664:60;;;;3740:18;;;3733:34;;;3783:18;;;3776:34;;;3826:19;;;3819:35;;;20005:14:0;;20134:94;;3602:19:1;;20161:65:0;;;;;;;;;;;;20151:76;;;;;;20134:16;:94::i;:::-;20046:197;;1970:66:1;20046:197:0;;;1958:79:1;2053:12;;;2046:28;;;;2090:12;;20046:197:0;;;;;;;;;;;;20022:232;;;;;;20005:249;;20265:22;20290:32;20304:6;20312:9;20290:13;:32::i;:::-;20357:10;20343:13;:25;;;;;;;;;;;20265:57;;-1:-1:-1;20343:25:0;;:34;20335:69;;;;-1:-1:-1;;;20335:69:0;;6432:2:1;20335:69:0;;;6414:21:1;6471:2;6451:18;;;6444:30;-1:-1:-1;;;6490:18:1;;;6483:52;6552:18;;20335:69:0;;;;;;;;;20441:6;-1:-1:-1;;;;;20423:24:0;:14;-1:-1:-1;;;;;20423:24:0;;20415:61;;;;-1:-1:-1;;;20415:61:0;;7185:2:1;20415:61:0;;;7167:21:1;7224:2;7204:18;;;7197:30;7263:26;7243:18;;;7236:54;7307:18;;20415:61:0;6983:348:1;20415:61:0;-1:-1:-1;;;;;20495:28:0;;20487:73;;;;-1:-1:-1;;;20487:73:0;;7941:2:1;20487:73:0;;;7923:21:1;;;7960:18;;;7953:30;8019:34;7999:18;;;7992:62;8071:18;;20487:73:0;7739:356:1;20487:73:0;20597:8;20579:15;:26;20571:72;;;;-1:-1:-1;;;20571:72:0;;6783:2:1;20571:72:0;;;6765:21:1;6822:2;6802:18;;;6795:30;6861:34;6841:18;;;6834:62;-1:-1:-1;;;6912:18:1;;;6905:31;6953:19;;20571:72:0;6581:397:1;20571:72:0;20670:10;20656:13;:25;;;;;;;;;;;;:32;;-1:-1:-1;;20656:32:0;20684:4;20656:32;;;20707:42;-1:-1:-1;;;20707:42:0;;;;;2892:51:1;;;;2959:18;;;2952:34;;;20714:5:0;-1:-1:-1;;;;;20707:22:0;;;;2865:18:1;;20707:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;20699:78;;;;-1:-1:-1;;;20699:78:0;;5677:2:1;20699:78:0;;;5659:21:1;5716:2;5696:18;;;5689:30;5755:25;5735:18;;;5728:53;5798:18;;20699:78:0;5475:347:1;20699:78:0;19994:791;;19854:931;;;;:::o;19043:167::-;19120:7;19147:55;19169:20;:18;:20::i;:::-;19191:10;14513:57;;-1:-1:-1;;;14513:57:0;;;2371:27:1;2414:11;;;2407:27;;;2450:12;;;2443:28;;;14476:7:0;;2487:12:1;;14513:57:0;;;;;;;;;;;;14503:68;;;;;;14496:75;;14383:196;;;;;19147:55;19140:62;19043:167;-1:-1:-1;;19043:167:0:o;9422:231::-;9500:7;9521:17;9540:18;9562:27;9573:4;9579:9;9562:10;:27::i;:::-;9520:69;;;;9600:18;9612:5;9600:11;:18::i;:::-;-1:-1:-1;9636:9:0;9422:231;-1:-1:-1;;;9422:231:0:o;17816:314::-;17869:7;17901:4;-1:-1:-1;;;;;17910:12:0;17893:29;;:66;;;;;17943:16;17926:13;:33;17893:66;17889:234;;;-1:-1:-1;17983:24:0;;17816:314::o;17889:234::-;-1:-1:-1;18319:73:0;;;18069:10;18319:73;;;;4124:25:1;;;;18081:12:0;4165:18:1;;;4158:34;18095:15:0;4208:18:1;;;4201:34;18363:13:0;4251:18:1;;;4244:34;18386:4:0;4294:19:1;;;;4287:61;;;;18319:73:0;;;;;;;;;;4096:19:1;;;;18319:73:0;;;18309:84;;;;;;17816:314::o;7312:1308::-;7393:7;7402:12;7627:9;:16;7647:2;7627:22;7623:990;;;7923:4;7908:20;;7902:27;7973:4;7958:20;;7952:27;8031:4;8016:20;;8010:27;7666:9;8002:36;8074:25;8085:4;8002:36;7902:27;7952;8074:10;:25::i;:::-;8067:32;;;;;;;;;7623:990;8121:9;:16;8141:2;8121:22;8117:496;;;8396:4;8381:20;;8375:27;8447:4;8432:20;;8426:27;8489:23;8500:4;8375:27;8426;8489:10;:23::i;:::-;8482:30;;;;;;;;8117:496;-1:-1:-1;8561:1:0;;-1:-1:-1;8565:35:0;8117:496;7312:1308;;;;;:::o;5583:643::-;5661:20;5652:5;:29;;;;;;;;:::i;:::-;;5648:571;;;5583:643;:::o;5648:571::-;5759:29;5750:5;:38;;;;;;;;:::i;:::-;;5746:473;;;5805:34;;-1:-1:-1;;;5805:34:0;;4964:2:1;5805:34:0;;;4946:21:1;5003:2;4983:18;;;4976:30;5042:26;5022:18;;;5015:54;5086:18;;5805:34:0;4762:348:1;5746:473:0;5870:35;5861:5;:44;;;;;;;;:::i;:::-;;5857:362;;;5922:41;;-1:-1:-1;;;5922:41:0;;5317:2:1;5922:41:0;;;5299:21:1;5356:2;5336:18;;;5329:30;5395:33;5375:18;;;5368:61;5446:18;;5922:41:0;5115:355:1;5857:362:0;5994:30;5985:5;:39;;;;;;;;:::i;:::-;;5981:238;;;6041:44;;-1:-1:-1;;;6041:44:0;;6029:2:1;6041:44:0;;;6011:21:1;6068:2;6048:18;;;6041:30;6107:34;6087:18;;;6080:62;-1:-1:-1;;;6158:18:1;;;6151:32;6200:19;;6041:44:0;5827:398:1;5981:238:0;6116:30;6107:5;:39;;;;;;;;:::i;:::-;;6103:116;;;6163:44;;-1:-1:-1;;;6163:44:0;;7538:2:1;6163:44:0;;;7520:21:1;7577:2;7557:18;;;7550:30;7616:34;7596:18;;;7589:62;-1:-1:-1;;;7667:18:1;;;7660:32;7709:19;;6163:44:0;7336:398:1;6103:116:0;5583:643;:::o;10921:1632::-;11052:7;;11986:66;11973:79;;11969:163;;;-1:-1:-1;12085:1:0;;-1:-1:-1;12089:30:0;12069:51;;11969:163;12146:1;:7;;12151:2;12146:7;;:18;;;;;12157:1;:7;;12162:2;12157:7;;12146:18;12142:102;;;-1:-1:-1;12197:1:0;;-1:-1:-1;12201:30:0;12181:51;;12142:102;12358:24;;;12341:14;12358:24;;;;;;;;;4586:25:1;;;4659:4;4647:17;;4627:18;;;4620:45;;;;4681:18;;;4674:34;;;4724:18;;;4717:34;;;12358:24:0;;4558:19:1;;12358:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;12358:24:0;;-1:-1:-1;;12358:24:0;;;-1:-1:-1;;;;;;;12397:20:0;;12393:103;;12450:1;12454:29;12434:50;;;;;;;12393:103;12516:6;-1:-1:-1;12524:20:0;;-1:-1:-1;10921:1632:0;;;;;;;;:::o;9916:391::-;10030:7;;-1:-1:-1;;;;;10131:75:0;;10233:3;10229:12;;;10243:2;10225:21;10274:25;10285:4;10225:21;10294:1;10131:75;10274:10;:25::i;:::-;10267:32;;;;;;9916:391;;;;;;:::o;14:286:1:-;73:6;126:2;114:9;105:7;101:23;97:32;94:52;;;142:1;139;132:12;94:52;168:23;;-1:-1:-1;;;;;220:31:1;;210:42;;200:70;;266:1;263;256:12;200:70;289:5;14:286;-1:-1:-1;;;14:286:1:o;305:277::-;372:6;425:2;413:9;404:7;400:23;396:32;393:52;;;441:1;438;431:12;393:52;473:9;467:16;526:5;519:13;512:21;505:5;502:32;492:60;;548:1;545;538:12;587:1136;682:6;690;698;706;759:3;747:9;738:7;734:23;730:33;727:53;;;776:1;773;766:12;727:53;816:9;803:23;845:18;886:2;878:6;875:14;872:34;;;902:1;899;892:12;872:34;940:6;929:9;925:22;915:32;;985:7;978:4;974:2;970:13;966:27;956:55;;1007:1;1004;997:12;956:55;1043:2;1030:16;1065:2;1061;1058:10;1055:36;;;1071:18;;:::i;:::-;1146:2;1140:9;1114:2;1200:13;;-1:-1:-1;;1196:22:1;;;1220:2;1192:31;1188:40;1176:53;;;1244:18;;;1264:22;;;1241:46;1238:72;;;1290:18;;:::i;:::-;1330:10;1326:2;1319:22;1365:2;1357:6;1350:18;1407:7;1400:4;1395:2;1391;1387:11;1383:22;1380:35;1377:55;;;1428:1;1425;1418:12;1377:55;1488:2;1481:4;1477:2;1473:13;1466:4;1458:6;1454:17;1441:50;1535:1;1528:4;1511:15;;;1507:26;;1500:37;1511:15;1594:20;;;1581:34;;-1:-1:-1;;1662:2:1;1647:18;;1634:32;;1713:2;1698:18;1685:32;;-1:-1:-1;1515:6:1;-1:-1:-1;;;;;587:1136:1:o;8100:127::-;8161:10;8156:3;8152:20;8149:1;8142:31;8192:4;8189:1;8182:15;8216:4;8213:1;8206:15;8232:127;8293:10;8288:3;8284:20;8281:1;8274:31;8324:4;8321:1;8314:15;8348:4;8345:1;8338:15

ipfs://e9ff5b2273e83640336059cb6c90d9257c025247173902080c5e131b75dd3422