Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
This contract may be a proxy contract. Click on More Options and select Is this a proxy? to confirm and enable the "Read as Proxy" & "Write as Proxy" tabs.
Contract Source Code Verified (Exact Match)
Contract Name:
EthsMarketV2
Compiler Version
v0.8.9+commit.e5eed63a
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2023-11-04 */ // File: @openzeppelin/[email protected]/utils/math/SignedMathUpgradeable.sol // OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol) pragma solidity ^0.8.0; /** * @dev Standard signed math utilities missing in the Solidity language. */ library SignedMathUpgradeable { /** * @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/[email protected]/utils/math/MathUpgradeable.sol // OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol) pragma solidity ^0.8.0; /** * @dev Standard math utilities missing in the Solidity language. */ library MathUpgradeable { enum Rounding { Down, // Toward negative infinity Up, // Toward infinity Zero // Toward zero } /** * @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 up instead * of rounding down. */ function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) { // (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; // Least significant 256 bits of the product uint256 prod1; // Most significant 256 bits of the product assembly { let mm := mulmod(x, y, not(0)) prod0 := mul(x, y) 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. require(denominator > prod1, "Math: mulDiv overflow"); /////////////////////////////////////////////// // 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. // Does not overflow because the denominator cannot be zero at this stage in the function. uint256 twos = denominator & (~denominator + 1); 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 (rounding == Rounding.Up && 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 down. * * 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 + (rounding == Rounding.Up && result * result < a ? 1 : 0); } } /** * @dev Return the log in base 2, rounded down, of a positive value. * 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 + (rounding == Rounding.Up && 1 << result < value ? 1 : 0); } } /** * @dev Return the log in base 10, rounded down, of a positive value. * 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 + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0); } } /** * @dev Return the log in base 256, rounded down, of a positive value. * 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 + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0); } } } // File: @openzeppelin/[email protected]/utils/StringsUpgradeable.sol // OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol) pragma solidity ^0.8.0; /** * @dev String operations. */ library StringsUpgradeable { bytes16 private constant _SYMBOLS = "0123456789abcdef"; uint8 private constant _ADDRESS_LENGTH = 20; /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function toString(uint256 value) internal pure returns (string memory) { unchecked { uint256 length = MathUpgradeable.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), _SYMBOLS)) } value /= 10; if (value == 0) break; } return buffer; } } /** * @dev Converts a `int256` to its ASCII `string` decimal representation. */ function toString(int256 value) internal pure returns (string memory) { return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMathUpgradeable.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, MathUpgradeable.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) { 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] = _SYMBOLS[value & 0xf]; value >>= 4; } require(value == 0, "Strings: hex length insufficient"); 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 keccak256(bytes(a)) == keccak256(bytes(b)); } } // File: @openzeppelin/[email protected]/utils/cryptography/ECDSAUpgradeable.sol // OpenZeppelin Contracts (last updated v4.9.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 ECDSAUpgradeable { enum RecoverError { NoError, InvalidSignature, InvalidSignatureLength, InvalidSignatureS, InvalidSignatureV // Deprecated in v4.8 } 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"); } } /** * @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) { 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. /// @solidity memory-safe-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 { 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 = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); uint8 v = uint8((uint256(vs) >> 255) + 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 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 message) { // 32 is the length in bytes of hash, // enforced by the type signature above /// @solidity memory-safe-assembly assembly { mstore(0x00, "\x19Ethereum Signed Message:\n32") mstore(0x1c, hash) message := keccak256(0x00, 0x3c) } } /** * @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", StringsUpgradeable.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 data) { /// @solidity memory-safe-assembly assembly { let ptr := mload(0x40) mstore(ptr, "\x19\x01") mstore(add(ptr, 0x02), domainSeparator) mstore(add(ptr, 0x22), structHash) data := keccak256(ptr, 0x42) } } /** * @dev Returns an Ethereum Signed Data with intended validator, created from a * `validator` and `data` according to the version 0 of EIP-191. * * See {recover}. */ function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) { return keccak256(abi.encodePacked("\x19\x00", validator, data)); } } // File: @openzeppelin/[email protected]/utils/cryptography/MerkleProofUpgradeable.sol // OpenZeppelin Contracts (last updated v4.9.2) (utils/cryptography/MerkleProof.sol) pragma solidity ^0.8.0; /** * @dev These functions deal with verification of Merkle Tree proofs. * * The tree and the proofs can be generated using our * https://github.com/OpenZeppelin/merkle-tree[JavaScript library]. * You will find a quickstart guide in the readme. * * WARNING: You should avoid using leaf values that are 64 bytes long prior to * hashing, or use a hash function other than keccak256 for hashing leaves. * This is because the concatenation of a sorted pair of internal nodes in * the merkle tree could be reinterpreted as a leaf value. * OpenZeppelin's JavaScript library generates merkle trees that are safe * against this attack out of the box. */ library MerkleProofUpgradeable { /** * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree * defined by `root`. For this, a `proof` must be provided, containing * sibling hashes on the branch from the leaf to the root of the tree. Each * pair of leaves and each pair of pre-images are assumed to be sorted. */ function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) { return processProof(proof, leaf) == root; } /** * @dev Calldata version of {verify} * * _Available since v4.7._ */ function verifyCalldata(bytes32[] calldata proof, bytes32 root, bytes32 leaf) internal pure returns (bool) { return processProofCalldata(proof, leaf) == root; } /** * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt * hash matches the root of the tree. When processing the proof, the pairs * of leafs & pre-images are assumed to be sorted. * * _Available since v4.4._ */ function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) { bytes32 computedHash = leaf; for (uint256 i = 0; i < proof.length; i++) { computedHash = _hashPair(computedHash, proof[i]); } return computedHash; } /** * @dev Calldata version of {processProof} * * _Available since v4.7._ */ function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) { bytes32 computedHash = leaf; for (uint256 i = 0; i < proof.length; i++) { computedHash = _hashPair(computedHash, proof[i]); } return computedHash; } /** * @dev Returns true if the `leaves` can be simultaneously proven to be a part of a merkle tree defined by * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}. * * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details. * * _Available since v4.7._ */ function multiProofVerify( bytes32[] memory proof, bool[] memory proofFlags, bytes32 root, bytes32[] memory leaves ) internal pure returns (bool) { return processMultiProof(proof, proofFlags, leaves) == root; } /** * @dev Calldata version of {multiProofVerify} * * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details. * * _Available since v4.7._ */ function multiProofVerifyCalldata( bytes32[] calldata proof, bool[] calldata proofFlags, bytes32 root, bytes32[] memory leaves ) internal pure returns (bool) { return processMultiProofCalldata(proof, proofFlags, leaves) == root; } /** * @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another * leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false * respectively. * * CAUTION: Not all merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer). * * _Available since v4.7._ */ function processMultiProof( bytes32[] memory proof, bool[] memory proofFlags, bytes32[] memory leaves ) internal pure returns (bytes32 merkleRoot) { // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of // the merkle tree. uint256 leavesLen = leaves.length; uint256 proofLen = proof.length; uint256 totalHashes = proofFlags.length; // Check proof validity. require(leavesLen + proofLen - 1 == totalHashes, "MerkleProof: invalid multiproof"); // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop". bytes32[] memory hashes = new bytes32[](totalHashes); uint256 leafPos = 0; uint256 hashPos = 0; uint256 proofPos = 0; // At each step, we compute the next hash using two values: // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we // get the next hash. // - depending on the flag, either another value from the "main queue" (merging branches) or an element from the // `proof` array. for (uint256 i = 0; i < totalHashes; i++) { bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++]; bytes32 b = proofFlags[i] ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++]) : proof[proofPos++]; hashes[i] = _hashPair(a, b); } if (totalHashes > 0) { require(proofPos == proofLen, "MerkleProof: invalid multiproof"); unchecked { return hashes[totalHashes - 1]; } } else if (leavesLen > 0) { return leaves[0]; } else { return proof[0]; } } /** * @dev Calldata version of {processMultiProof}. * * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details. * * _Available since v4.7._ */ function processMultiProofCalldata( bytes32[] calldata proof, bool[] calldata proofFlags, bytes32[] memory leaves ) internal pure returns (bytes32 merkleRoot) { // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of // the merkle tree. uint256 leavesLen = leaves.length; uint256 proofLen = proof.length; uint256 totalHashes = proofFlags.length; // Check proof validity. require(leavesLen + proofLen - 1 == totalHashes, "MerkleProof: invalid multiproof"); // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop". bytes32[] memory hashes = new bytes32[](totalHashes); uint256 leafPos = 0; uint256 hashPos = 0; uint256 proofPos = 0; // At each step, we compute the next hash using two values: // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we // get the next hash. // - depending on the flag, either another value from the "main queue" (merging branches) or an element from the // `proof` array. for (uint256 i = 0; i < totalHashes; i++) { bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++]; bytes32 b = proofFlags[i] ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++]) : proof[proofPos++]; hashes[i] = _hashPair(a, b); } if (totalHashes > 0) { require(proofPos == proofLen, "MerkleProof: invalid multiproof"); unchecked { return hashes[totalHashes - 1]; } } else if (leavesLen > 0) { return leaves[0]; } else { return proof[0]; } } function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) { return a < b ? _efficientHash(a, b) : _efficientHash(b, a); } function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) { /// @solidity memory-safe-assembly assembly { mstore(0x00, a) mstore(0x20, b) value := keccak256(0x00, 0x40) } } } // File: @openzeppelin/[email protected]/utils/StorageSlotUpgradeable.sol // OpenZeppelin Contracts (last updated v4.9.0) (utils/StorageSlot.sol) // This file was procedurally generated from scripts/generate/templates/StorageSlot.js. pragma solidity ^0.8.0; /** * @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(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract"); * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation; * } * } * ``` * * _Available since v4.1 for `address`, `bool`, `bytes32`, `uint256`._ * _Available since v4.9 for `string`, `bytes`._ */ library StorageSlotUpgradeable { 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/[email protected]/interfaces/IERC1967Upgradeable.sol // OpenZeppelin Contracts (last updated v4.9.0) (interfaces/IERC1967.sol) pragma solidity ^0.8.0; /** * @dev ERC-1967: Proxy Storage Slots. This interface contains the events defined in the ERC. * * _Available since v4.8.3._ */ interface IERC1967Upgradeable { /** * @dev Emitted when the implementation is upgraded. */ event Upgraded(address indexed implementation); /** * @dev Emitted when the admin account has changed. */ event AdminChanged(address previousAdmin, address newAdmin); /** * @dev Emitted when the beacon is changed. */ event BeaconUpgraded(address indexed beacon); } // File: @openzeppelin/[email protected]/proxy/beacon/IBeaconUpgradeable.sol // OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol) pragma solidity ^0.8.0; /** * @dev This is the interface that {BeaconProxy} expects of its beacon. */ interface IBeaconUpgradeable { /** * @dev Must return an address that can be used as a delegate call target. * * {BeaconProxy} will check that this address is a contract. */ function implementation() external view returns (address); } // File: @openzeppelin/[email protected]/interfaces/draft-IERC1822Upgradeable.sol // OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol) pragma solidity ^0.8.0; /** * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified * proxy whose upgrades are fully controlled by the current implementation. */ interface IERC1822ProxiableUpgradeable { /** * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation * address. * * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this * function revert if invoked through a proxy. */ function proxiableUUID() external view returns (bytes32); } // File: @openzeppelin/[email protected]/utils/AddressUpgradeable.sol // OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol) pragma solidity ^0.8.1; /** * @dev Collection of functions related to the address type */ library AddressUpgradeable { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * * Furthermore, `isContract` will also return true if the target contract within * the same transaction is already scheduled for destruction by `SELFDESTRUCT`, * which only has an effect at the end of a transaction. * ==== * * [IMPORTANT] * ==== * You shouldn't rely on `isContract` to protect against flash loan attacks! * * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract * constructor. * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize/address.code.length, which returns 0 // for contracts in construction, since the code is only stored at the end // of the constructor execution. return account.code.length > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); (bool success, ) = recipient.call{value: amount}(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage ) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall( address target, bytes memory data, string memory errorMessage ) internal view returns (bytes memory) { (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract. * * _Available since v4.8._ */ function verifyCallResultFromTarget( address target, bool success, bytes memory returndata, string memory errorMessage ) internal view returns (bytes memory) { if (success) { if (returndata.length == 0) { // only check isContract if the call was successful and the return data is empty // otherwise we already know that it was a contract require(isContract(target), "Address: call to non-contract"); } return returndata; } else { _revert(returndata, errorMessage); } } /** * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason or using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal pure returns (bytes memory) { if (success) { return returndata; } else { _revert(returndata, errorMessage); } } function _revert(bytes memory returndata, string memory errorMessage) private pure { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } // File: @openzeppelin/[email protected]/proxy/utils/Initializable.sol // OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol) pragma solidity ^0.8.2; /** * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect. * * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in * case an upgrade adds a module that needs to be initialized. * * For example: * * [.hljs-theme-light.nopadding] * ```solidity * contract MyToken is ERC20Upgradeable { * function initialize() initializer public { * __ERC20_init("MyToken", "MTK"); * } * } * * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable { * function initializeV2() reinitializer(2) public { * __ERC20Permit_init("MyToken"); * } * } * ``` * * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}. * * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity. * * [CAUTION] * ==== * Avoid leaving a contract uninitialized. * * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed: * * [.hljs-theme-light.nopadding] * ``` * /// @custom:oz-upgrades-unsafe-allow constructor * constructor() { * _disableInitializers(); * } * ``` * ==== */ abstract contract Initializable { /** * @dev Indicates that the contract has been initialized. * @custom:oz-retyped-from bool */ uint8 private _initialized; /** * @dev Indicates that the contract is in the process of being initialized. */ bool private _initializing; /** * @dev Triggered when the contract has been initialized or reinitialized. */ event Initialized(uint8 version); /** * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope, * `onlyInitializing` functions can be used to initialize parent contracts. * * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a * constructor. * * Emits an {Initialized} event. */ modifier initializer() { bool isTopLevelCall = !_initializing; require( (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1), "Initializable: contract is already initialized" ); _initialized = 1; if (isTopLevelCall) { _initializing = true; } _; if (isTopLevelCall) { _initializing = false; emit Initialized(1); } } /** * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be * used to initialize parent contracts. * * A reinitializer may be used after the original initialization step. This is essential to configure modules that * are added through upgrades and that require initialization. * * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer` * cannot be nested. If one is invoked in the context of another, execution will revert. * * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in * a contract, executing them in the right order is up to the developer or operator. * * WARNING: setting the version to 255 will prevent any future reinitialization. * * Emits an {Initialized} event. */ modifier reinitializer(uint8 version) { require(!_initializing && _initialized < version, "Initializable: contract is already initialized"); _initialized = version; _initializing = true; _; _initializing = false; emit Initialized(version); } /** * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the * {initializer} and {reinitializer} modifiers, directly or indirectly. */ modifier onlyInitializing() { require(_initializing, "Initializable: contract is not initializing"); _; } /** * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call. * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized * to any version. It is recommended to use this to lock implementation contracts that are designed to be called * through proxies. * * Emits an {Initialized} event the first time it is successfully executed. */ function _disableInitializers() internal virtual { require(!_initializing, "Initializable: contract is initializing"); if (_initialized != type(uint8).max) { _initialized = type(uint8).max; emit Initialized(type(uint8).max); } } /** * @dev Returns the highest version that has been initialized. See {reinitializer}. */ function _getInitializedVersion() internal view returns (uint8) { return _initialized; } /** * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}. */ function _isInitializing() internal view returns (bool) { return _initializing; } } // File: @openzeppelin/[email protected]/security/ReentrancyGuardUpgradeable.sol // OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol) pragma solidity ^0.8.0; /** * @dev Contract module that helps prevent reentrant calls to a function. * * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier * available, which can be applied to functions to make sure there are no nested * (reentrant) calls to them. * * Note that because there is a single `nonReentrant` guard, functions marked as * `nonReentrant` may not call one another. This can be worked around by making * those functions `private`, and then adding `external` `nonReentrant` entry * points to them. * * TIP: If you would like to learn more about reentrancy and alternative ways * to protect against it, check out our blog post * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul]. */ abstract contract ReentrancyGuardUpgradeable is Initializable { // Booleans are more expensive than uint256 or any type that takes up a full // word because each write operation emits an extra SLOAD to first read the // slot's contents, replace the bits taken up by the boolean, and then write // back. This is the compiler's defense against contract upgrades and // pointer aliasing, and it cannot be disabled. // The values being non-zero value makes deployment a bit more expensive, // but in exchange the refund on every call to nonReentrant will be lower in // amount. Since refunds are capped to a percentage of the total // transaction's gas, it is best to keep them low in cases like this one, to // increase the likelihood of the full refund coming into effect. uint256 private constant _NOT_ENTERED = 1; uint256 private constant _ENTERED = 2; uint256 private _status; function __ReentrancyGuard_init() internal onlyInitializing { __ReentrancyGuard_init_unchained(); } function __ReentrancyGuard_init_unchained() internal onlyInitializing { _status = _NOT_ENTERED; } /** * @dev Prevents a contract from calling itself, directly or indirectly. * Calling a `nonReentrant` function from another `nonReentrant` * function is not supported. It is possible to prevent this from happening * by making the `nonReentrant` function external, and making it call a * `private` function that does the actual work. */ modifier nonReentrant() { _nonReentrantBefore(); _; _nonReentrantAfter(); } function _nonReentrantBefore() private { // On the first call to nonReentrant, _status will be _NOT_ENTERED require(_status != _ENTERED, "ReentrancyGuard: reentrant call"); // Any calls to nonReentrant after this point will fail _status = _ENTERED; } function _nonReentrantAfter() private { // By storing the original value once again, a refund is triggered (see // https://eips.ethereum.org/EIPS/eip-2200) _status = _NOT_ENTERED; } /** * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a * `nonReentrant` function in the call stack. */ function _reentrancyGuardEntered() internal view returns (bool) { return _status == _ENTERED; } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[49] private __gap; } // File: @openzeppelin/[email protected]/proxy/ERC1967/ERC1967UpgradeUpgradeable.sol // OpenZeppelin Contracts (last updated v4.9.0) (proxy/ERC1967/ERC1967Upgrade.sol) pragma solidity ^0.8.2; /** * @dev This abstract contract provides getters and event emitting update functions for * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots. * * _Available since v4.1._ */ abstract contract ERC1967UpgradeUpgradeable is Initializable, IERC1967Upgradeable { function __ERC1967Upgrade_init() internal onlyInitializing { } function __ERC1967Upgrade_init_unchained() internal onlyInitializing { } // This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1 bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143; /** * @dev Storage slot with the address of the current implementation. * This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is * validated in the constructor. */ bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc; /** * @dev Returns the current implementation address. */ function _getImplementation() internal view returns (address) { return StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value; } /** * @dev Stores a new address in the EIP1967 implementation slot. */ function _setImplementation(address newImplementation) private { require(AddressUpgradeable.isContract(newImplementation), "ERC1967: new implementation is not a contract"); StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation; } /** * @dev Perform implementation upgrade * * Emits an {Upgraded} event. */ function _upgradeTo(address newImplementation) internal { _setImplementation(newImplementation); emit Upgraded(newImplementation); } /** * @dev Perform implementation upgrade with additional setup call. * * Emits an {Upgraded} event. */ function _upgradeToAndCall(address newImplementation, bytes memory data, bool forceCall) internal { _upgradeTo(newImplementation); if (data.length > 0 || forceCall) { AddressUpgradeable.functionDelegateCall(newImplementation, data); } } /** * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call. * * Emits an {Upgraded} event. */ function _upgradeToAndCallUUPS(address newImplementation, bytes memory data, bool forceCall) internal { // Upgrades from old implementations will perform a rollback test. This test requires the new // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing // this special case will break upgrade paths from old UUPS implementation to new ones. if (StorageSlotUpgradeable.getBooleanSlot(_ROLLBACK_SLOT).value) { _setImplementation(newImplementation); } else { try IERC1822ProxiableUpgradeable(newImplementation).proxiableUUID() returns (bytes32 slot) { require(slot == _IMPLEMENTATION_SLOT, "ERC1967Upgrade: unsupported proxiableUUID"); } catch { revert("ERC1967Upgrade: new implementation is not UUPS"); } _upgradeToAndCall(newImplementation, data, forceCall); } } /** * @dev Storage slot with the admin of the contract. * This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is * validated in the constructor. */ bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103; /** * @dev Returns the current admin. */ function _getAdmin() internal view returns (address) { return StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value; } /** * @dev Stores a new address in the EIP1967 admin slot. */ function _setAdmin(address newAdmin) private { require(newAdmin != address(0), "ERC1967: new admin is the zero address"); StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value = newAdmin; } /** * @dev Changes the admin of the proxy. * * Emits an {AdminChanged} event. */ function _changeAdmin(address newAdmin) internal { emit AdminChanged(_getAdmin(), newAdmin); _setAdmin(newAdmin); } /** * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy. * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor. */ bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50; /** * @dev Returns the current beacon. */ function _getBeacon() internal view returns (address) { return StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value; } /** * @dev Stores a new beacon in the EIP1967 beacon slot. */ function _setBeacon(address newBeacon) private { require(AddressUpgradeable.isContract(newBeacon), "ERC1967: new beacon is not a contract"); require( AddressUpgradeable.isContract(IBeaconUpgradeable(newBeacon).implementation()), "ERC1967: beacon implementation is not a contract" ); StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value = newBeacon; } /** * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that). * * Emits a {BeaconUpgraded} event. */ function _upgradeBeaconToAndCall(address newBeacon, bytes memory data, bool forceCall) internal { _setBeacon(newBeacon); emit BeaconUpgraded(newBeacon); if (data.length > 0 || forceCall) { AddressUpgradeable.functionDelegateCall(IBeaconUpgradeable(newBeacon).implementation(), data); } } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[50] private __gap; } // File: @openzeppelin/[email protected]/proxy/utils/UUPSUpgradeable.sol // OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/UUPSUpgradeable.sol) pragma solidity ^0.8.0; /** * @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an * {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy. * * A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is * reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing * `UUPSUpgradeable` with a custom implementation of upgrades. * * The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism. * * _Available since v4.1._ */ abstract contract UUPSUpgradeable is Initializable, IERC1822ProxiableUpgradeable, ERC1967UpgradeUpgradeable { function __UUPSUpgradeable_init() internal onlyInitializing { } function __UUPSUpgradeable_init_unchained() internal onlyInitializing { } /// @custom:oz-upgrades-unsafe-allow state-variable-immutable state-variable-assignment address private immutable __self = address(this); /** * @dev Check that the execution is being performed through a delegatecall call and that the execution context is * a proxy contract with an implementation (as defined in ERC1967) pointing to self. This should only be the case * for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a * function through ERC1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to * fail. */ modifier onlyProxy() { require(address(this) != __self, "Function must be called through delegatecall"); require(_getImplementation() == __self, "Function must be called through active proxy"); _; } /** * @dev Check that the execution is not being performed through a delegate call. This allows a function to be * callable on the implementing contract but not through proxies. */ modifier notDelegated() { require(address(this) == __self, "UUPSUpgradeable: must not be called through delegatecall"); _; } /** * @dev Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the * implementation. It is used to validate the implementation's compatibility when performing an upgrade. * * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this * function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier. */ function proxiableUUID() external view virtual override notDelegated returns (bytes32) { return _IMPLEMENTATION_SLOT; } /** * @dev Upgrade the implementation of the proxy to `newImplementation`. * * Calls {_authorizeUpgrade}. * * Emits an {Upgraded} event. * * @custom:oz-upgrades-unsafe-allow-reachable delegatecall */ function upgradeTo(address newImplementation) public virtual onlyProxy { _authorizeUpgrade(newImplementation); _upgradeToAndCallUUPS(newImplementation, new bytes(0), false); } /** * @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call * encoded in `data`. * * Calls {_authorizeUpgrade}. * * Emits an {Upgraded} event. * * @custom:oz-upgrades-unsafe-allow-reachable delegatecall */ function upgradeToAndCall(address newImplementation, bytes memory data) public payable virtual onlyProxy { _authorizeUpgrade(newImplementation); _upgradeToAndCallUUPS(newImplementation, data, true); } /** * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by * {upgradeTo} and {upgradeToAndCall}. * * Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}. * * ```solidity * function _authorizeUpgrade(address) internal override onlyOwner {} * ``` */ function _authorizeUpgrade(address newImplementation) internal virtual; /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[50] private __gap; } // File: @openzeppelin/[email protected]/utils/ContextUpgradeable.sol // OpenZeppelin Contracts v4.4.1 (utils/Context.sol) pragma solidity ^0.8.0; /** * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract ContextUpgradeable is Initializable { function __Context_init() internal onlyInitializing { } function __Context_init_unchained() internal onlyInitializing { } function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[50] private __gap; } // File: @openzeppelin/[email protected]/access/OwnableUpgradeable.sol // OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol) pragma solidity ^0.8.0; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ function __Ownable_init() internal onlyInitializing { __Ownable_init_unchained(); } function __Ownable_init_unchained() internal onlyInitializing { _transferOwnership(_msgSender()); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { require(owner() == _msgSender(), "Ownable: caller is not the owner"); } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby disabling any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[49] private __gap; } // File: EthsMarketV3.sol pragma solidity 0.8.9; contract EthsMarketV2 is Initializable, OwnableUpgradeable, UUPSUpgradeable, ReentrancyGuardUpgradeable{ error EthscriptionNotDeposited(); error ZeroBalance(); struct Order { bytes32 tokenId; } mapping(bytes32 => Order) public orders; mapping(bytes32 => mapping(uint256 => bool)) private ethscriptions_signatures; mapping(bytes32 => mapping(address => uint256)) private ethscriptionReceivedOnBlockNumber; uint256 public protocol_rate; uint256 public timeFrame; address public authorized_verifier; //TRANSFER_BLOCK_CONFIRMATIONS uint256 public ethscription_transfer_cooldown_blocks; mapping(bytes32 => uint256) public orders_sign_time; uint256 public orders_time_range; event OrderInitializes(bytes32 indexed tokenId, address indexed seller, uint256 block_number); event OrderBought(bytes32 indexed tokenId, address indexed seller, string c_name, address indexed buyer, uint256 price, uint256 timestamp); event Orderwithdrawn(bytes32 indexed tokenId ,address indexed seller, uint256 timestamp, string c_name); event ethscriptions_protocol_TransferEthscriptionForPreviousOwner( address indexed previousOwner, address indexed recipient, bytes32 indexed ethscriptionId ); event ethscriptions_protocol_TransferEthscription(address indexed recipient,bytes32 indexed ethscriptionId); /// @custom:oz-upgrades-unsafe-allow constructor constructor() { _disableInitializers(); } function initialize(uint256 _rate, address _authorized_s) public initializer { protocol_rate = _rate; authorized_verifier = _authorized_s; timeFrame = 120; ethscription_transfer_cooldown_blocks = 5; __Ownable_init(); __UUPSUpgradeable_init(); } function setRate(uint256 _rate)external onlyOwner { protocol_rate = _rate; } function setVerifier(address _s)external onlyOwner { authorized_verifier = _s; } function set_orders_time_range(uint256 _t)external onlyOwner { orders_time_range = _t; } function setTimeFrame(uint256 _t)external onlyOwner { timeFrame = _t; } function setDeplayBlocks(uint256 _deplay_blocks)external onlyOwner { ethscription_transfer_cooldown_blocks = _deplay_blocks; } function toBytes32(address addr) pure internal returns (bytes32) { return bytes32(uint256(uint160(addr))); } function protocel_fee_get(uint256 _price, uint256 _discount)view internal returns (uint256){ if(protocol_rate > 0){ uint256 protocol_rate_end = _discount > 0 ? (protocol_rate * (100-_discount) / 100) : (protocol_rate); return _price * protocol_rate_end / 10000; }else{ return 0; } } function creator_fee_get(uint256 _price, uint256 _creator_fee_rate)pure internal returns (uint256){ if(_creator_fee_rate > 0){ return _price * _creator_fee_rate / 10000; }else{ return 0; } } function orderBuy( bytes32 _tokenId, uint256 _price, address _seller, address _buyer, uint256 _timestamp, uint256 _discount, address _creator, uint256 _creator_fee_rate, bytes memory _signature, string memory _c_name ) public payable nonReentrant{ require(_seller != address(0x0), "Error: invalid seller"); require(msg.sender == _buyer, "Error: invilad buyer"); require((block.timestamp - _timestamp) < timeFrame, "Error: expired signature"); require((block.timestamp - orders_sign_time[_tokenId]) > orders_time_range, "Error: invalid signature time"); require(_price == msg.value, "Error: invalid amount"); require(ethscriptions_signatures[_tokenId][_timestamp] != true, "Error: invalid signature"); require(_discount < 100, "Error: invalid discount"); require(_creator_fee_rate < 20, "Error: invalid creator_fee_rate"); { address signer = ECDSAUpgradeable.recover(getEthscripHash(_buyer, _seller, _tokenId, _price, _timestamp, _discount, _creator, _creator_fee_rate), _signature); require(signer == authorized_verifier,"Error: invalid signature"); } { uint256 creator_fee = _creator != address(0x0) ? creator_fee_get(_price,_creator_fee_rate) : 0; payable(_creator).transfer(creator_fee); payable(_seller).transfer(_price - protocel_fee_get(_price,_discount) - creator_fee); } emit ethscriptions_protocol_TransferEthscriptionForPreviousOwner(_seller, _buyer, _tokenId); ethscriptions_signatures[_tokenId][_timestamp] = true; orders_sign_time[_tokenId] = _timestamp; emit OrderBought(_tokenId, _seller, _c_name, _buyer, _price, _timestamp); emit ethscriptions_protocol_TransferEthscription(_buyer, _tokenId); } function getEthscripHash( address _buyer, address _seller, bytes32 _e_id, uint256 _price, uint256 _timestamp, uint256 _discount, address _creator, uint256 _creator_fee_rate ) internal pure returns (bytes32) { bytes32 message = keccak256(abi.encodePacked(_buyer, _seller, _e_id, _price, _timestamp, _discount, _creator, _creator_fee_rate)); bytes32 ethSignedMessage = ECDSAUpgradeable.toEthSignedMessageHash(message); return ethSignedMessage; } function getEthscripHash_withdrawn( address _from, bytes32 _e_id, uint256 _timestamp ) internal pure returns (bytes32) { bytes32 message = keccak256(abi.encodePacked(_from, _e_id, _timestamp)); bytes32 ethSignedMessage = ECDSAUpgradeable.toEthSignedMessageHash(message); return ethSignedMessage; } function withdrawn( address _from, bytes32 _e_id, uint256 _timestamp, bytes memory _signature, string memory _c_name ) public nonReentrant{ require((block.timestamp - _timestamp) < timeFrame, "Error: Expired signature"); require((block.timestamp - orders_sign_time[_e_id]) > orders_time_range, "Error: invalid signature time"); require(ethscriptions_signatures[_e_id][_timestamp] != true, "Error: invalid signature"); bytes32 messageHash = getEthscripHash_withdrawn(_from, _e_id, _timestamp); address signer = ECDSAUpgradeable.recover(messageHash, _signature); require(signer == authorized_verifier,"Error: invalid signature"); require(msg.sender == _from, "Error: No permissions"); emit ethscriptions_protocol_TransferEthscriptionForPreviousOwner(_from, msg.sender, _e_id); ethscriptions_signatures[_e_id][_timestamp] = true; orders_sign_time[_e_id] = _timestamp; emit Orderwithdrawn(_e_id, msg.sender, _timestamp, _c_name); emit ethscriptions_protocol_TransferEthscription(msg.sender, _e_id); } function send_protocol_fee(address _rec) external onlyOwner{ require(address(this).balance != 0, "Error: invalid balance"); require(_rec != address(0x0), "Error: invalid address"); payable(_rec).transfer(address(this).balance); } fallback() external {} function _authorizeUpgrade(address newImplementation) internal onlyOwner override {} }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"EthscriptionNotDeposited","type":"error"},{"inputs":[],"name":"ZeroBalance","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"previousAdmin","type":"address"},{"indexed":false,"internalType":"address","name":"newAdmin","type":"address"}],"name":"AdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"beacon","type":"address"}],"name":"BeaconUpgraded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"version","type":"uint8"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"tokenId","type":"bytes32"},{"indexed":true,"internalType":"address","name":"seller","type":"address"},{"indexed":false,"internalType":"string","name":"c_name","type":"string"},{"indexed":true,"internalType":"address","name":"buyer","type":"address"},{"indexed":false,"internalType":"uint256","name":"price","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"OrderBought","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"tokenId","type":"bytes32"},{"indexed":true,"internalType":"address","name":"seller","type":"address"},{"indexed":false,"internalType":"uint256","name":"block_number","type":"uint256"}],"name":"OrderInitializes","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"tokenId","type":"bytes32"},{"indexed":true,"internalType":"address","name":"seller","type":"address"},{"indexed":false,"internalType":"uint256","name":"timestamp","type":"uint256"},{"indexed":false,"internalType":"string","name":"c_name","type":"string"}],"name":"Orderwithdrawn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"implementation","type":"address"}],"name":"Upgraded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"recipient","type":"address"},{"indexed":true,"internalType":"bytes32","name":"ethscriptionId","type":"bytes32"}],"name":"ethscriptions_protocol_TransferEthscription","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"recipient","type":"address"},{"indexed":true,"internalType":"bytes32","name":"ethscriptionId","type":"bytes32"}],"name":"ethscriptions_protocol_TransferEthscriptionForPreviousOwner","type":"event"},{"stateMutability":"nonpayable","type":"fallback"},{"inputs":[],"name":"authorized_verifier","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ethscription_transfer_cooldown_blocks","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_rate","type":"uint256"},{"internalType":"address","name":"_authorized_s","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_tokenId","type":"bytes32"},{"internalType":"uint256","name":"_price","type":"uint256"},{"internalType":"address","name":"_seller","type":"address"},{"internalType":"address","name":"_buyer","type":"address"},{"internalType":"uint256","name":"_timestamp","type":"uint256"},{"internalType":"uint256","name":"_discount","type":"uint256"},{"internalType":"address","name":"_creator","type":"address"},{"internalType":"uint256","name":"_creator_fee_rate","type":"uint256"},{"internalType":"bytes","name":"_signature","type":"bytes"},{"internalType":"string","name":"_c_name","type":"string"}],"name":"orderBuy","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"orders","outputs":[{"internalType":"bytes32","name":"tokenId","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"orders_sign_time","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"orders_time_range","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"protocol_rate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"proxiableUUID","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_rec","type":"address"}],"name":"send_protocol_fee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_deplay_blocks","type":"uint256"}],"name":"setDeplayBlocks","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_rate","type":"uint256"}],"name":"setRate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_t","type":"uint256"}],"name":"setTimeFrame","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_s","type":"address"}],"name":"setVerifier","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_t","type":"uint256"}],"name":"set_orders_time_range","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"timeFrame","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newImplementation","type":"address"}],"name":"upgradeTo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newImplementation","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"upgradeToAndCall","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"_from","type":"address"},{"internalType":"bytes32","name":"_e_id","type":"bytes32"},{"internalType":"uint256","name":"_timestamp","type":"uint256"},{"internalType":"bytes","name":"_signature","type":"bytes"},{"internalType":"string","name":"_c_name","type":"string"}],"name":"withdrawn","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Deployed Bytecode Sourcemap
80017:7670:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;82196:85;;;;;;;;;;-1:-1:-1;82196:85:0;;;;;:::i;:::-;;:::i;:::-;;81886:90;;;;;;;;;;-1:-1:-1;81886:90:0;;;;;:::i;:::-;;:::i;73790:198::-;;;;;;;;;;-1:-1:-1;73790:198:0;;;;;:::i;:::-;;:::i;87259:269::-;;;;;;;;;;-1:-1:-1;87259:269:0;;;;;:::i;:::-;;:::i;80480:28::-;;;;;;;;;;;;;;;;;;;714:25:1;;;702:2;687:18;80480:28:0;;;;;;;;74319:223;;;;;;:::i;:::-;;:::i;73396:133::-;;;;;;;;;;;;;:::i;81984:94::-;;;;;;;;;;-1:-1:-1;81984:94:0;;;;;:::i;:::-;;:::i;80688:51::-;;;;;;;;;;-1:-1:-1;80688:51:0;;;;;:::i;:::-;;;;;;;;;;;;;;78829:103;;;;;;;;;;;;;:::i;80746:32::-;;;;;;;;;;;;;;;;83184:1948;;;;;;:::i;:::-;;:::i;80515:24::-;;;;;;;;;;;;;;;;78188:87;;;;;;;;;;-1:-1:-1;78261:6:0;;-1:-1:-1;;;;;78261:6:0;78188:87;;;-1:-1:-1;;;;;3649:32:1;;;3631:51;;3619:2;3604:18;78188:87:0;3485:203:1;80249:39:0;;;;;;;;;;-1:-1:-1;80249:39:0;;;;;:::i;:::-;;;;;;;;;;;;;;82289:140;;;;;;;;;;-1:-1:-1;82289:140:0;;;;;:::i;:::-;;:::i;86080:1171::-;;;;;;;;;;-1:-1:-1;86080:1171:0;;;;;:::i;:::-;;:::i;81573:305::-;;;;;;;;;;-1:-1:-1;81573:305:0;;;;;:::i;:::-;;:::i;82086:102::-;;;;;;;;;;-1:-1:-1;82086:102:0;;;;;:::i;:::-;;:::i;80627:52::-;;;;;;;;;;;;;;;;80548:34;;;;;;;;;;-1:-1:-1;80548:34:0;;;;-1:-1:-1;;;;;80548:34:0;;;79087:201;;;;;;;;;;-1:-1:-1;79087:201:0;;;;;:::i;:::-;;:::i;82196:85::-;78074:13;:11;:13::i;:::-;82259:9:::1;:14:::0;82196:85::o;81886:90::-;78074:13;:11;:13::i;:::-;81947::::1;:21:::0;81886:90::o;73790:198::-;72257:4;-1:-1:-1;;;;;72266:6:0;72249:23;;;72241:80;;;;-1:-1:-1;;;72241:80:0;;;;;;;:::i;:::-;;;;;;;;;72364:6;-1:-1:-1;;;;;72340:30:0;:20;-1:-1:-1;;;;;;;;;;;65032:65:0;-1:-1:-1;;;;;65032:65:0;;64952:153;72340:20;-1:-1:-1;;;;;72340:30:0;;72332:87;;;;-1:-1:-1;;;72332:87:0;;;;;;;:::i;:::-;73872:36:::1;73890:17;73872;:36::i;:::-;73960:12;::::0;;73970:1:::1;73960:12:::0;;;::::1;::::0;::::1;::::0;;;73919:61:::1;::::0;73941:17;;73960:12;73919:21:::1;:61::i;:::-;73790:198:::0;:::o;87259:269::-;78074:13;:11;:13::i;:::-;87337:21:::1;87329:61;;;::::0;-1:-1:-1;;;87329:61:0;;5737:2:1;87329:61:0::1;::::0;::::1;5719:21:1::0;5776:2;5756:18;;;5749:30;-1:-1:-1;;;5795:18:1;;;5788:52;5857:18;;87329:61:0::1;5535:346:1::0;87329:61:0::1;-1:-1:-1::0;;;;;87409:20:0;::::1;87401:55;;;::::0;-1:-1:-1;;;87401:55:0;;6088:2:1;87401:55:0::1;::::0;::::1;6070:21:1::0;6127:2;6107:18;;;6100:30;-1:-1:-1;;;6146:18:1;;;6139:52;6208:18;;87401:55:0::1;5886:346:1::0;87401:55:0::1;87467:45;::::0;-1:-1:-1;;;;;87467:22:0;::::1;::::0;87490:21:::1;87467:45:::0;::::1;;;::::0;::::1;::::0;;;87490:21;87467:22;:45;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;87259:269:::0;:::o;74319:223::-;72257:4;-1:-1:-1;;;;;72266:6:0;72249:23;;;72241:80;;;;-1:-1:-1;;;72241:80:0;;;;;;;:::i;:::-;72364:6;-1:-1:-1;;;;;72340:30:0;:20;-1:-1:-1;;;;;;;;;;;65032:65:0;-1:-1:-1;;;;;65032:65:0;;64952:153;72340:20;-1:-1:-1;;;;;72340:30:0;;72332:87;;;;-1:-1:-1;;;72332:87:0;;;;;;;:::i;:::-;74435:36:::1;74453:17;74435;:36::i;:::-;74482:52;74504:17;74523:4;74529;74482:21;:52::i;73396:133::-:0;73474:7;72702:4;-1:-1:-1;;;;;72711:6:0;72694:23;;72686:92;;;;-1:-1:-1;;;72686:92:0;;6439:2:1;72686:92:0;;;6421:21:1;6478:2;6458:18;;;6451:30;6517:34;6497:18;;;6490:62;6588:26;6568:18;;;6561:54;6632:19;;72686:92:0;6237:420:1;72686:92:0;-1:-1:-1;;;;;;;;;;;;73396:133:0;:::o;81984:94::-;78074:13;:11;:13::i;:::-;82046:19:::1;:24:::0;;-1:-1:-1;;;;;;82046:24:0::1;-1:-1:-1::0;;;;;82046:24:0;;;::::1;::::0;;;::::1;::::0;;81984:94::o;78829:103::-;78074:13;:11;:13::i;:::-;78894:30:::1;78921:1;78894:18;:30::i;:::-;78829:103::o:0;83184:1948::-;62476:21;:19;:21::i;:::-;-1:-1:-1;;;;;83549:23:0;::::1;83541:57;;;::::0;-1:-1:-1;;;83541:57:0;;6864:2:1;83541:57:0::1;::::0;::::1;6846:21:1::0;6903:2;6883:18;;;6876:30;-1:-1:-1;;;6922:18:1;;;6915:51;6983:18;;83541:57:0::1;6662:345:1::0;83541:57:0::1;83617:10;-1:-1:-1::0;;;;;83617:20:0;::::1;;83609:53;;;::::0;-1:-1:-1;;;83609:53:0;;7214:2:1;83609:53:0::1;::::0;::::1;7196:21:1::0;7253:2;7233:18;;;7226:30;-1:-1:-1;;;7272:18:1;;;7265:50;7332:18;;83609:53:0::1;7012:344:1::0;83609:53:0::1;83714:9;::::0;83682:28:::1;83700:10:::0;83682:15:::1;:28;:::i;:::-;83681:42;83673:79;;;::::0;-1:-1:-1;;;83673:79:0;;7825:2:1;83673:79:0::1;::::0;::::1;7807:21:1::0;7864:2;7844:18;;;7837:30;7903:26;7883:18;;;7876:54;7947:18;;83673:79:0::1;7623:348:1::0;83673:79:0::1;83820:17;::::0;83790:26:::1;::::0;;;:16:::1;:26;::::0;;;;;83772:44:::1;::::0;:15:::1;:44;:::i;:::-;83771:66;83763:108;;;::::0;-1:-1:-1;;;83763:108:0;;8178:2:1;83763:108:0::1;::::0;::::1;8160:21:1::0;8217:2;8197:18;;;8190:30;8256:31;8236:18;;;8229:59;8305:18;;83763:108:0::1;7976:353:1::0;83763:108:0::1;83901:9;83891:6;:19;83883:53;;;::::0;-1:-1:-1;;;83883:53:0;;8536:2:1;83883:53:0::1;::::0;::::1;8518:21:1::0;8575:2;8555:18;;;8548:30;-1:-1:-1;;;8594:18:1;;;8587:51;8655:18;;83883:53:0::1;8334:345:1::0;83883:53:0::1;83955:34;::::0;;;:24:::1;:34;::::0;;;;;;;:46;;;;;;;;;::::1;;:54;;:46:::0;:54:::1;;83947:91;;;;-1:-1:-1::0;;;83947:91:0::1;;;;;;;:::i;:::-;84069:3;84057:9;:15;84049:51;;;::::0;-1:-1:-1;;;84049:51:0;;9239:2:1;84049:51:0::1;::::0;::::1;9221:21:1::0;9278:2;9258:18;;;9251:30;9317:25;9297:18;;;9290:53;9360:18;;84049:51:0::1;9037:347:1::0;84049:51:0::1;84139:2;84119:17;:22;84111:66;;;::::0;-1:-1:-1;;;84111:66:0;;9591:2:1;84111:66:0::1;::::0;::::1;9573:21:1::0;9630:2;9610:18;;;9603:30;9669:33;9649:18;;;9642:61;9720:18;;84111:66:0::1;9389:355:1::0;84111:66:0::1;84205:14;84222:140;84247:102;84263:6;84271:7;84280:8;84290:6;84298:10;84310:9;84321:8;84331:17;84247:15;:102::i;:::-;84351:10;84222:24;:140::i;:::-;84395:19;::::0;84205:157;;-1:-1:-1;;;;;;84385:29:0;;::::1;84395:19:::0;::::1;84385:29;84377:65;;;;-1:-1:-1::0;;;84377:65:0::1;;;;;;;:::i;:::-;-1:-1:-1::0;84479:19:0::1;-1:-1:-1::0;;;;;84501:24:0;::::1;:72;;84572:1;84501:72;;;84528:41;84544:6;84551:17;84528:15;:41::i;:::-;84588:39;::::0;84479:94;;-1:-1:-1;;;;;;84588:26:0;::::1;::::0;:39;::::1;;;::::0;84479:94;;84588:39:::1;::::0;;;84479:94;84588:26;:39;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;84650:7;-1:-1:-1::0;;;;;84642:25:0::1;:84;84714:11;84677:34;84694:6;84701:9;84677:16;:34::i;:::-;84668:43;::::0;:6;:43:::1;:::i;:::-;:57;;;;:::i;:::-;84642:84;::::0;;::::1;::::0;;::::1;::::0;::::1;::::0;;;;;;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;84464:274;84839:8;84831:6;-1:-1:-1::0;;;;;84762:86:0::1;84822:7;-1:-1:-1::0;;;;;84762:86:0::1;;;;;;;;;;;84859:34;::::0;;;:24:::1;:34;::::0;;;;;;;:46;;;;;;;;:53;;-1:-1:-1;;84859:53:0::1;84908:4;84859:53;::::0;;84923:26;;;:16:::1;:26:::0;;;;;;;:39;;;84980:67;-1:-1:-1;;;;;84980:67:0;;::::1;::::0;;;::::1;::::0;84884:8;;84980:67:::1;::::0;::::1;::::0;85011:7;;85028:6;;84894:10;;84980:67:::1;:::i;:::-;;;;;;;;85063:61;::::0;85115:8;;-1:-1:-1;;;;;85063:61:0;::::1;::::0;::::1;::::0;;;::::1;62520:20:::0;61737:1;63040:7;:22;62857:213;62520:20;83184:1948;;;;;;;;;;:::o;82289:140::-;78074:13;:11;:13::i;:::-;82367:37:::1;:54:::0;82289:140::o;86080:1171::-;62476:21;:19;:21::i;:::-;86323:9:::1;::::0;86291:28:::1;86309:10:::0;86291:15:::1;:28;:::i;:::-;86290:42;86282:79;;;::::0;-1:-1:-1;;;86282:79:0;;10844:2:1;86282:79:0::1;::::0;::::1;10826:21:1::0;10883:2;10863:18;;;10856:30;10922:26;10902:18;;;10895:54;10966:18;;86282:79:0::1;10642:348:1::0;86282:79:0::1;86426:17;::::0;86399:23:::1;::::0;;;:16:::1;:23;::::0;;;;;86381:41:::1;::::0;:15:::1;:41;:::i;:::-;86380:63;86372:105;;;::::0;-1:-1:-1;;;86372:105:0;;8178:2:1;86372:105:0::1;::::0;::::1;8160:21:1::0;8217:2;8197:18;;;8190:30;8256:31;8236:18;;;8229:59;8305:18;;86372:105:0::1;7976:353:1::0;86372:105:0::1;86497:31;::::0;;;:24:::1;:31;::::0;;;;;;;:43;;;;;;;;;::::1;;:51;;:43:::0;:51:::1;;86489:88;;;;-1:-1:-1::0;;;86489:88:0::1;;;;;;;:::i;:::-;86590:19;86612:51;86638:5;86645;86652:10;86612:25;:51::i;:::-;86590:73;;86674:14;86691:49;86716:11;86729:10;86691:24;:49::i;:::-;86769:19;::::0;86674:66;;-1:-1:-1;;;;;;86759:29:0;;::::1;86769:19:::0;::::1;86759:29;86751:65;;;;-1:-1:-1::0;;;86751:65:0::1;;;;;;;:::i;:::-;86835:10;-1:-1:-1::0;;;;;86835:19:0;::::1;;86827:53;;;::::0;-1:-1:-1;;;86827:53:0;;11197:2:1;86827:53:0::1;::::0;::::1;11179:21:1::0;11236:2;11216:18;;;11209:30;-1:-1:-1;;;11255:18:1;;;11248:51;11316:18;;86827:53:0::1;10995:345:1::0;86827:53:0::1;86898:85;::::0;86977:5;;86965:10:::1;::::0;-1:-1:-1;;;;;86898:85:0;::::1;::::0;::::1;::::0;;;::::1;86996:31;::::0;;;:24:::1;:31;::::0;;;;;;;:43;;;;;;;;:50;;-1:-1:-1;;86996:50:0::1;87042:4;86996:50;::::0;;87057:23;;;:16:::1;:23:::0;;;;;;;:36;;;87111:54;87133:10:::1;::::0;87021:5;;87111:54:::1;::::0;::::1;::::0;87028:10;;87157:7;;87111:54:::1;:::i;:::-;;;;;;;;87181:62;::::0;87237:5;;87225:10:::1;::::0;87181:62:::1;::::0;;;::::1;86271:980;;62520:20:::0;61737:1;63040:7;:22;62857:213;62520:20;86080:1171;;;;;:::o;81573:305::-;56449:19;56472:13;;;;;;56471:14;;56519:34;;;;-1:-1:-1;56537:12:0;;56552:1;56537:12;;;;:16;56519:34;56518:108;;;-1:-1:-1;56598:4:0;45215:19;:23;;;56559:66;;-1:-1:-1;56608:12:0;;;;;:17;56559:66;56496:204;;;;-1:-1:-1;;;56496:204:0;;11843:2:1;56496:204:0;;;11825:21:1;11882:2;11862:18;;;11855:30;11921:34;11901:18;;;11894:62;-1:-1:-1;;;11972:18:1;;;11965:44;12026:19;;56496:204:0;11641:410:1;56496:204:0;56711:12;:16;;-1:-1:-1;;56711:16:0;56726:1;56711:16;;;56738:67;;;;56773:13;:20;;-1:-1:-1;;56773:20:0;;;;;56738:67;81661:13:::1;:21:::0;;;81693:19:::1;:35:::0;;-1:-1:-1;;;;;;81693:35:0::1;-1:-1:-1::0;;;;;81693:35:0;::::1;;::::0;;81751:3:::1;81739:9;:15:::0;81805:1:::1;81765:37;:41:::0;81819:16:::1;:14;:16::i;:::-;81846:24;:22;:24::i;:::-;56831:14:::0;56827:102;;;56878:5;56862:21;;-1:-1:-1;;56862:21:0;;;56903:14;;-1:-1:-1;12208:36:1;;56903:14:0;;12196:2:1;12181:18;56903:14:0;;;;;;;56827:102;56438:498;81573:305;;:::o;82086:102::-;78074:13;:11;:13::i;:::-;82158:17:::1;:22:::0;82086:102::o;79087:201::-;78074:13;:11;:13::i;:::-;-1:-1:-1;;;;;79176:22:0;::::1;79168:73;;;::::0;-1:-1:-1;;;79168:73:0;;12457:2:1;79168:73:0::1;::::0;::::1;12439:21:1::0;12496:2;12476:18;;;12469:30;12535:34;12515:18;;;12508:62;-1:-1:-1;;;12586:18:1;;;12579:36;12632:19;;79168:73:0::1;12255:402:1::0;79168:73:0::1;79252:28;79271:8;79252:18;:28::i;78353:132::-:0;78261:6;;-1:-1:-1;;;;;78261:6:0;76300:10;78417:23;78409:68;;;;-1:-1:-1;;;78409:68:0;;12864:2:1;78409:68:0;;;12846:21:1;;;12883:18;;;12876:30;12942:34;12922:18;;;12915:62;12994:18;;78409:68:0;12662:356:1;87566:116:0;78074:13;:11;:13::i;66354:958::-;64454:66;66774:59;;;66770:535;;;66850:37;66869:17;66850:18;:37::i;66770:535::-;66953:17;-1:-1:-1;;;;;66924:61:0;;:63;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;66924:63:0;;;;;;;;-1:-1:-1;;66924:63:0;;;;;;;;;;;;:::i;:::-;;;66920:306;;67154:56;;-1:-1:-1;;;67154:56:0;;13414:2:1;67154:56:0;;;13396:21:1;13453:2;13433:18;;;13426:30;13492:34;13472:18;;;13465:62;-1:-1:-1;;;13543:18:1;;;13536:44;13597:19;;67154:56:0;13212:410:1;66920:306:0;-1:-1:-1;;;;;;;;;;;67038:28:0;;67030:82;;;;-1:-1:-1;;;67030:82:0;;13829:2:1;67030:82:0;;;13811:21:1;13868:2;13848:18;;;13841:30;13907:34;13887:18;;;13880:62;-1:-1:-1;;;13958:18:1;;;13951:39;14007:19;;67030:82:0;13627:405:1;67030:82:0;66988:140;67240:53;67258:17;67277:4;67283:9;67240:17;:53::i;79448:191::-;79541:6;;;-1:-1:-1;;;;;79558:17:0;;;-1:-1:-1;;;;;;79558:17:0;;;;;;;79591:40;;79541:6;;;79558:17;79541:6;;79591:40;;79522:16;;79591:40;79511:128;79448:191;:::o;62556:293::-;61781:1;62690:7;;:19;;62682:63;;;;-1:-1:-1;;;62682:63:0;;14239:2:1;62682:63:0;;;14221:21:1;14278:2;14258:18;;;14251:30;14317:33;14297:18;;;14290:61;14368:18;;62682:63:0;14037:355:1;62682:63:0;61781:1;62823:7;:18;62556:293::o;85142:559::-;85472:100;;-1:-1:-1;;14792:2:1;14788:15;;;14784:24;;85472:100:0;;;14772:37:1;14843:15;;;14839:24;;14825:12;;;14818:46;14880:12;;;14873:28;;;14917:12;;;14910:28;;;14954:13;;;14947:29;;;14992:13;;;14985:29;;;15049:15;;;15045:24;15030:13;;;15023:47;15086:13;;;15079:29;;;85424:7:0;;;;15124:13:1;;85472:100:0;;;;;;;;;;;;85462:111;;;;;;85444:129;;85584:24;85611:48;85651:7;25081:34;24876:15;25068:48;;;25137:4;25130:18;;;;25189:4;25173:21;;;24807:405;85611:48;85584:75;85142:559;-1:-1:-1;;;;;;;;;;;85142:559:0:o;21271:231::-;21349:7;21370:17;21389:18;21411:27;21422:4;21428:9;21411:10;:27::i;:::-;21369:69;;;;21449:18;21461:5;21449:11;:18::i;:::-;-1:-1:-1;21485:9:0;-1:-1:-1;21271:231:0;;;;;:::o;82928:248::-;83018:7;83040:21;;83037:132;;83113:5;83084:26;83093:17;83084:6;:26;:::i;:::-;:34;;;;:::i;:::-;83077:41;;;;83037:132;-1:-1:-1;83156:1:0;83149:8;;82567:353;82672:13;;82650:7;;82672:17;82669:244;;82705:25;82745:1;82733:9;:13;:73;;82792:13;;82733:73;;;82784:3;82767:13;82771:9;82784:3;82767:13;:::i;:::-;82750;;:31;;;;:::i;:::-;:37;;;;:::i;:::-;82705:101;-1:-1:-1;82857:5:0;82828:26;82705:101;82828:6;:26;:::i;:::-;:34;;;;:::i;:::-;82821:41;;;;;85709:363;85901:42;;-1:-1:-1;;15748:2:1;15744:15;;;15740:53;85901:42:0;;;15728:66:1;15810:12;;;15803:28;;;15847:12;;;15840:28;;;85853:7:0;;;;15884:12:1;;85901:42:0;;;;;;;;;;;;85891:53;;;;;;85873:71;;85955:24;85982:48;86022:7;25081:34;24876:15;25068:48;;;25137:4;25130:18;;;;25189:4;25173:21;;;24807:405;85982:48;85955:75;85709:363;-1:-1:-1;;;;;;85709:363:0:o;77731:97::-;58592:13;;;;;;;58584:69;;;;-1:-1:-1;;;58584:69:0;;;;;;;:::i;:::-;77794:26:::1;:24;:26::i;71394:68::-:0;58592:13;;;;;;;58584:69;;;;-1:-1:-1;;;58584:69:0;;;;;;;:::i;65201:284::-;-1:-1:-1;;;;;45215:19:0;;;65275:106;;;;-1:-1:-1;;;65275:106:0;;16521:2:1;65275:106:0;;;16503:21:1;16560:2;16540:18;;;16533:30;16599:34;16579:18;;;16572:62;-1:-1:-1;;;16650:18:1;;;16643:43;16703:19;;65275:106:0;16319:409:1;65275:106:0;-1:-1:-1;;;;;;;;;;;65392:85:0;;-1:-1:-1;;;;;;65392:85:0;-1:-1:-1;;;;;65392:85:0;;;;;;;;;;65201:284::o;65894:281::-;66003:29;66014:17;66003:10;:29::i;:::-;66061:1;66047:4;:11;:15;:28;;;;66066:9;66047:28;66043:125;;;66092:64;66132:17;66151:4;66092:39;:64::i;:::-;;65894:281;;;:::o;19722:747::-;19803:7;19812:12;19841:9;:16;19861:2;19841:22;19837:625;;;20185:4;20170:20;;20164:27;20235:4;20220:20;;20214:27;20293:4;20278:20;;20272:27;19880:9;20264:36;20336:25;20347:4;20264:36;20164:27;20214;20336:10;:25::i;:::-;20329:32;;;;;;;;;19837:625;-1:-1:-1;20410:1:0;;-1:-1:-1;20414:35:0;19837:625;19722:747;;;;;:::o;18115:521::-;18193:20;18184:5;:29;;;;;;;;:::i;:::-;;18180:449;;;18115:521;:::o;18180:449::-;18291:29;18282:5;:38;;;;;;;;:::i;:::-;;18278:351;;;18337:34;;-1:-1:-1;;;18337:34:0;;17067:2:1;18337:34:0;;;17049:21:1;17106:2;17086:18;;;17079:30;17145:26;17125:18;;;17118:54;17189:18;;18337:34:0;16865:348:1;18278:351:0;18402:35;18393:5;:44;;;;;;;;:::i;:::-;;18389:240;;;18454:41;;-1:-1:-1;;;18454:41:0;;17420:2:1;18454:41:0;;;17402:21:1;17459:2;17439:18;;;17432:30;17498:33;17478:18;;;17471:61;17549:18;;18454:41:0;17218:355:1;18389:240:0;18526:30;18517:5;:39;;;;;;;;:::i;:::-;;18513:116;;;18573:44;;-1:-1:-1;;;18573:44:0;;17780:2:1;18573:44:0;;;17762:21:1;17819:2;17799:18;;;17792:30;17858:34;17838:18;;;17831:62;-1:-1:-1;;;17909:18:1;;;17902:32;17951:19;;18573:44:0;17578:398:1;77836:113:0;58592:13;;;;;;;58584:69;;;;-1:-1:-1;;;58584:69:0;;;;;;;:::i;:::-;77909:32:::1;76300:10:::0;77909:18:::1;:32::i;65598:155::-:0;65665:37;65684:17;65665:18;:37::i;:::-;65718:27;;-1:-1:-1;;;;;65718:27:0;;;;;;;;65598:155;:::o;50312:200::-;50395:12;50427:77;50448:6;50456:4;50427:77;;;;;;;;;;;;;;;;;:20;:77::i;:::-;50420:84;50312:200;-1:-1:-1;;;50312:200:0:o;22655:1477::-;22743:7;;23677:66;23664:79;;23660:163;;;-1:-1:-1;23776:1:0;;-1:-1:-1;23780:30:0;23760:51;;23660:163;23937:24;;;23920:14;23937:24;;;;;;;;;18208:25:1;;;18281:4;18269:17;;18249:18;;;18242:45;;;;18303:18;;;18296:34;;;18346:18;;;18339:34;;;23937:24:0;;18180:19:1;;23937:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;23937:24:0;;-1:-1:-1;;23937:24:0;;;-1:-1:-1;;;;;;;23976:20:0;;23972:103;;24029:1;24033:29;24013:50;;;;;;;23972:103;24095:6;-1:-1:-1;24103:20:0;;-1:-1:-1;22655:1477:0;;;;;;;;:::o;50706:332::-;50851:12;50877;50891:23;50918:6;-1:-1:-1;;;;;50918:19:0;50938:4;50918:25;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50876:67;;;;50961:69;50988:6;50996:7;51005:10;51017:12;51519;51548:7;51544:427;;;51576:17;;51572:290;;-1:-1:-1;;;;;45215:19:0;;;51786:60;;;;-1:-1:-1;;;51786:60:0;;18865:2:1;51786:60:0;;;18847:21:1;18904:2;18884:18;;;18877:30;18943:31;18923:18;;;18916:59;18992:18;;51786:60:0;18663:353:1;51786:60:0;-1:-1:-1;51883:10:0;51876:17;;51544:427;51926:33;51934:10;51946:12;51926:7;:33::i;:::-;51334:644;;;;;;:::o;52520:552::-;52681:17;;:21;52677:388;;52913:10;52907:17;52970:15;52957:10;52953:2;52949:19;52942:44;52677:388;53040:12;53033:20;;-1:-1:-1;;;53033:20:0;;;;;;;;:::i;14:180:1:-;73:6;126:2;114:9;105:7;101:23;97:32;94:52;;;142:1;139;132:12;94:52;-1:-1:-1;165:23:1;;14:180;-1:-1:-1;14:180:1:o;199:173::-;267:20;;-1:-1:-1;;;;;316:31:1;;306:42;;296:70;;362:1;359;352:12;296:70;199:173;;;:::o;377:186::-;436:6;489:2;477:9;468:7;464:23;460:32;457:52;;;505:1;502;495:12;457:52;528:29;547:9;528:29;:::i;750:127::-;811:10;806:3;802:20;799:1;792:31;842:4;839:1;832:15;866:4;863:1;856:15;882:718;924:5;977:3;970:4;962:6;958:17;954:27;944:55;;995:1;992;985:12;944:55;1031:6;1018:20;1057:18;1094:2;1090;1087:10;1084:36;;;1100:18;;:::i;:::-;1175:2;1169:9;1143:2;1229:13;;-1:-1:-1;;1225:22:1;;;1249:2;1221:31;1217:40;1205:53;;;1273:18;;;1293:22;;;1270:46;1267:72;;;1319:18;;:::i;:::-;1359:10;1355:2;1348:22;1394:2;1386:6;1379:18;1440:3;1433:4;1428:2;1420:6;1416:15;1412:26;1409:35;1406:55;;;1457:1;1454;1447:12;1406:55;1521:2;1514:4;1506:6;1502:17;1495:4;1487:6;1483:17;1470:54;1568:1;1561:4;1556:2;1548:6;1544:15;1540:26;1533:37;1588:6;1579:15;;;;;;882:718;;;;:::o;1605:394::-;1682:6;1690;1743:2;1731:9;1722:7;1718:23;1714:32;1711:52;;;1759:1;1756;1749:12;1711:52;1782:29;1801:9;1782:29;:::i;:::-;1772:39;;1862:2;1851:9;1847:18;1834:32;1889:18;1881:6;1878:30;1875:50;;;1921:1;1918;1911:12;1875:50;1944:49;1985:7;1976:6;1965:9;1961:22;1944:49;:::i;:::-;1934:59;;;1605:394;;;;;:::o;2371:1109::-;2530:6;2538;2546;2554;2562;2570;2578;2586;2594;2602;2655:3;2643:9;2634:7;2630:23;2626:33;2623:53;;;2672:1;2669;2662:12;2623:53;2708:9;2695:23;2685:33;;2765:2;2754:9;2750:18;2737:32;2727:42;;2788:38;2822:2;2811:9;2807:18;2788:38;:::i;:::-;2778:48;;2845:38;2879:2;2868:9;2864:18;2845:38;:::i;:::-;2835:48;;2930:3;2919:9;2915:19;2902:33;2892:43;;2982:3;2971:9;2967:19;2954:33;2944:43;;3006:39;3040:3;3029:9;3025:19;3006:39;:::i;:::-;2996:49;;3092:3;3081:9;3077:19;3064:33;3054:43;;3148:3;3137:9;3133:19;3120:33;3172:18;3213:2;3205:6;3202:14;3199:34;;;3229:1;3226;3219:12;3199:34;3252:49;3293:7;3284:6;3273:9;3269:22;3252:49;:::i;:::-;3242:59;;3354:3;3343:9;3339:19;3326:33;3310:49;;3384:2;3374:8;3371:16;3368:36;;;3400:1;3397;3390:12;3368:36;;3423:51;3466:7;3455:8;3444:9;3440:24;3423:51;:::i;:::-;3413:61;;;2371:1109;;;;;;;;;;;;;:::o;3693:752::-;3807:6;3815;3823;3831;3839;3892:3;3880:9;3871:7;3867:23;3863:33;3860:53;;;3909:1;3906;3899:12;3860:53;3932:29;3951:9;3932:29;:::i;:::-;3922:39;;4008:2;3997:9;3993:18;3980:32;3970:42;;4059:2;4048:9;4044:18;4031:32;4021:42;;4114:2;4103:9;4099:18;4086:32;4137:18;4178:2;4170:6;4167:14;4164:34;;;4194:1;4191;4184:12;4164:34;4217:49;4258:7;4249:6;4238:9;4234:22;4217:49;:::i;:::-;4207:59;;4319:3;4308:9;4304:19;4291:33;4275:49;;4349:2;4339:8;4336:16;4333:36;;;4365:1;4362;4355:12;4333:36;;4388:51;4431:7;4420:8;4409:9;4405:24;4388:51;:::i;:::-;4378:61;;;3693:752;;;;;;;;:::o;4450:254::-;4518:6;4526;4579:2;4567:9;4558:7;4554:23;4550:32;4547:52;;;4595:1;4592;4585:12;4547:52;4631:9;4618:23;4608:33;;4660:38;4694:2;4683:9;4679:18;4660:38;:::i;:::-;4650:48;;4450:254;;;;;:::o;4709:408::-;4911:2;4893:21;;;4950:2;4930:18;;;4923:30;4989:34;4984:2;4969:18;;4962:62;-1:-1:-1;;;5055:2:1;5040:18;;5033:42;5107:3;5092:19;;4709:408::o;5122:::-;5324:2;5306:21;;;5363:2;5343:18;;;5336:30;5402:34;5397:2;5382:18;;5375:62;-1:-1:-1;;;5468:2:1;5453:18;;5446:42;5520:3;5505:19;;5122:408::o;7361:127::-;7422:10;7417:3;7413:20;7410:1;7403:31;7453:4;7450:1;7443:15;7477:4;7474:1;7467:15;7493:125;7533:4;7561:1;7558;7555:8;7552:34;;;7566:18;;:::i;:::-;-1:-1:-1;7603:9:1;;7493:125::o;8684:348::-;8886:2;8868:21;;;8925:2;8905:18;;;8898:30;8964:26;8959:2;8944:18;;8937:54;9023:2;9008:18;;8684:348::o;9749:258::-;9821:1;9831:113;9845:6;9842:1;9839:13;9831:113;;;9921:11;;;9915:18;9902:11;;;9895:39;9867:2;9860:10;9831:113;;;9962:6;9959:1;9956:13;9953:48;;;-1:-1:-1;;9997:1:1;9979:16;;9972:27;9749:258::o;10012:::-;10054:3;10092:5;10086:12;10119:6;10114:3;10107:19;10135:63;10191:6;10184:4;10179:3;10175:14;10168:4;10161:5;10157:16;10135:63;:::i;:::-;10252:2;10231:15;-1:-1:-1;;10227:29:1;10218:39;;;;10259:4;10214:50;;10012:258;-1:-1:-1;;10012:258:1:o;10275:362::-;10480:2;10469:9;10462:21;10443:4;10500:45;10541:2;10530:9;10526:18;10518:6;10500:45;:::i;:::-;10576:2;10561:18;;10554:34;;;;-1:-1:-1;10619:2:1;10604:18;10597:34;10492:53;10275:362;-1:-1:-1;10275:362:1:o;11345:291::-;11522:6;11511:9;11504:25;11565:2;11560;11549:9;11545:18;11538:30;11485:4;11585:45;11626:2;11615:9;11611:18;11603:6;11585:45;:::i;13023:184::-;13093:6;13146:2;13134:9;13125:7;13121:23;13117:32;13114:52;;;13162:1;13159;13152:12;13114:52;-1:-1:-1;13185:16:1;;13023:184;-1:-1:-1;13023:184:1:o;15148:168::-;15188:7;15254:1;15250;15246:6;15242:14;15239:1;15236:21;15231:1;15224:9;15217:17;15213:45;15210:71;;;15261:18;;:::i;:::-;-1:-1:-1;15301:9:1;;15148:168::o;15321:217::-;15361:1;15387;15377:132;;15431:10;15426:3;15422:20;15419:1;15412:31;15466:4;15463:1;15456:15;15494:4;15491:1;15484:15;15377:132;-1:-1:-1;15523:9:1;;15321:217::o;15907:407::-;16109:2;16091:21;;;16148:2;16128:18;;;16121:30;16187:34;16182:2;16167:18;;16160:62;-1:-1:-1;;;16253:2:1;16238:18;;16231:41;16304:3;16289:19;;15907:407::o;16733:127::-;16794:10;16789:3;16785:20;16782:1;16775:31;16825:4;16822:1;16815:15;16849:4;16846:1;16839:15;18384:274;18513:3;18551:6;18545:13;18567:53;18613:6;18608:3;18601:4;18593:6;18589:17;18567:53;:::i;:::-;18636:16;;;;;18384:274;-1:-1:-1;;18384:274:1:o;19021:220::-;19170:2;19159:9;19152:21;19133:4;19190:45;19231:2;19220:9;19216:18;19208:6;19190:45;:::i
Swarm Source
ipfs://ba984f0ef22bb4b2a5f10fea225f9eff54f8c10ce0fb5748c0f3eb53b655b7dd
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 31 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
Loading...
Loading
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.