Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
Latest 1 from a total of 1 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
0x60806040 | 18810963 | 221 days ago | IN | 0 ETH | 0.05364388 |
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Contract Name:
CDKDataCommittee
Compiler Version
v0.8.20+commit.a1b79de6
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2023-12-27 */ // SPDX-License-Identifier: AGPL-3.0 // File: @openzeppelin/contracts/utils/math/Math.sol // OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol) pragma solidity ^0.8.0; /** * @dev Standard math utilities missing in the Solidity language. */ library Math { 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) { return prod0 / denominator; } // Make sure the result is less than 2^256. Also prevents denominator == 0. require(denominator > prod1); /////////////////////////////////////////////// // 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 10, 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 * 8) < value ? 1 : 0); } } } // File: @openzeppelin/contracts/utils/Strings.sol // OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol) pragma solidity ^0.8.0; /** * @dev String operations. */ library Strings { 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 = Math.log10(value) + 1; string memory buffer = new string(length); uint256 ptr; /// @solidity memory-safe-assembly assembly { ptr := add(buffer, add(32, length)) } while (true) { ptr--; /// @solidity memory-safe-assembly assembly { mstore8(ptr, byte(mod(value, 10), _SYMBOLS)) } value /= 10; if (value == 0) break; } return buffer; } } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { unchecked { return toHexString(value, Math.log256(value) + 1); } } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length. */ function toHexString(uint256 value, uint256 length) internal pure returns (string memory) { 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); } } // File: @openzeppelin/contracts/utils/cryptography/ECDSA.sol // OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/ECDSA.sol) pragma solidity ^0.8.0; /** * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations. * * These functions can be used to verify that a message was signed by the holder * of the private keys of a given address. */ library ECDSA { enum RecoverError { NoError, InvalidSignature, InvalidSignatureLength, InvalidSignatureS, InvalidSignatureV // 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) { // 32 is the length in bytes of hash, // enforced by the type signature above return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash)); } /** * @dev Returns an Ethereum Signed Message, created from `s`. This * produces hash corresponding to the one signed with the * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] * JSON-RPC method as part of EIP-191. * * See {recover}. */ function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) { return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s)); } /** * @dev Returns an Ethereum Signed Typed Data, created from a * `domainSeparator` and a `structHash`. This produces hash corresponding * to the one signed with the * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`] * JSON-RPC method as part of EIP-712. * * See {recover}. */ function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) { return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash)); } } // File: @openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol // OpenZeppelin Contracts (last updated v4.8.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 * ==== * * [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://diligence.consensys.net/posts/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.5.11/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 Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract. * * _Available since v4.8._ */ function verifyCallResultFromTarget( address target, bool success, bytes memory returndata, string memory errorMessage ) internal view returns (bytes memory) { if (success) { if (returndata.length == 0) { // only check isContract if the call was successful and the return data is empty // otherwise we already know that it was a contract require(isContract(target), "Address: call to non-contract"); } return returndata; } else { _revert(returndata, errorMessage); } } /** * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason or using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal pure returns (bytes memory) { if (success) { return returndata; } else { _revert(returndata, errorMessage); } } function _revert(bytes memory returndata, string memory errorMessage) private pure { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } // File: @openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol // OpenZeppelin Contracts (last updated v4.8.1) (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] * ``` * 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/contracts-upgradeable/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/contracts-upgradeable/access/OwnableUpgradeable.sol // OpenZeppelin Contracts (last updated v4.7.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 anymore. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby removing 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: contracts/interfaces/ICDKDataCommitteeErrors.sol pragma solidity ^0.8.20; interface ICDKDataCommitteeErrors { /** * @dev Thrown when the addres bytes doesn't have the expected length */ error UnexpectedAddrsBytesLength(); /** * @dev Thrown when the setup attempts to register a member with empty URL */ error EmptyURLNotAllowed(); /** * @dev Thrown when the setup register doesn't order the members correctly */ error WrongAddrOrder(); /** * @dev Thrown when the required amount of signatures is greater than the amount of members */ error TooManyRequiredSignatures(); /** * @dev Thrown when the hash of the committee doesn't match with the provided addresses */ error UnexpectedCommitteeHash(); /** * @dev Thrown when the signature of a DA hash doesn't belong to any member of the committee */ error CommitteeAddressDoesntExist(); /** * @dev Thrown when the addresses and signatures byte array length has an unexpected size */ error UnexpectedAddrsAndSignaturesSize(); } // File: contracts/CDKDataCommittee.sol pragma solidity 0.8.20; contract CDKDataCommittee is ICDKDataCommitteeErrors, OwnableUpgradeable { /** * @notice Struct which will store all the data of the committee members * @param url string that represents the URL of the member to be used to access the data * @param addr address of the member that will be used to sign */ struct Member { string url; address addr; } // Size of a signature in bytes uint internal constant _SIGNATURE_SIZE = 65; // Size of an address in bytes uint internal constant _ADDR_SIZE = 20; // Specifies the required amount of signatures from members in the data availability committee uint public requiredAmountOfSignatures; // Hash of the addresses of the committee bytes32 public committeeHash; // Register of the members of the committee Member[] public members; /** * @dev Emitted when the committee is updated * @param committeeHash hash of the addresses of the committee members */ event CommitteeUpdated(bytes32 committeeHash); function initialize() external initializer { // Initialize OZ contracts __Ownable_init_unchained(); } /** * @notice Allows the admin to setup the members of the committee. Note that: * The system will require N / M signatures where N => _requiredAmountOfSignatures and M => urls.length * There must be the same amount of urls than addressess encoded in the addrsBytes * A member is represented by the url and the address contained in urls[i] and addrsBytes[i*_ADDR_SIZE : i*_ADDR_SIZE + _ADDR_SIZE] * @param _requiredAmountOfSignatures Required amount of signatures * @param urls List of urls of the members of the committee * @param addrsBytes Byte array that contains the addressess of the members of the committee */ function setupCommittee( uint _requiredAmountOfSignatures, string[] calldata urls, bytes calldata addrsBytes ) external onlyOwner { uint membersLength = urls.length; if (membersLength < _requiredAmountOfSignatures) { revert TooManyRequiredSignatures(); } if (addrsBytes.length != membersLength * _ADDR_SIZE) { revert UnexpectedAddrsBytesLength(); } delete members; address lastAddr; for (uint i = 0; i < membersLength; i++) { uint currentAddresStartingByte = i * _ADDR_SIZE; address currentMemberAddr = address(bytes20(addrsBytes[ currentAddresStartingByte : currentAddresStartingByte + _ADDR_SIZE ])); if (bytes(urls[i]).length == 0) { revert EmptyURLNotAllowed(); } if (lastAddr >= currentMemberAddr) { revert WrongAddrOrder(); } lastAddr = currentMemberAddr; members.push(Member({ url: urls[i], addr: currentMemberAddr })); } committeeHash = keccak256(addrsBytes); requiredAmountOfSignatures = _requiredAmountOfSignatures; emit CommitteeUpdated(committeeHash); } function getAmountOfMembers() public view returns(uint256) { return members.length; } /** * @notice Verifies that the given signedHash has been signed by requiredAmountOfSignatures committee members * @param signedHash Hash that must have been signed by requiredAmountOfSignatures of committee members * @param signaturesAndAddrs Byte array containing the signatures and all the addresses of the committee in ascending order * [signature 0, ..., signature requiredAmountOfSignatures -1, address 0, ... address N] * note that each ECDSA signatures are used, therefore each one must be 65 bytes */ function verifySignatures( bytes32 signedHash, bytes calldata signaturesAndAddrs ) external view { // pre-check: byte array size uint splitByte = _SIGNATURE_SIZE * requiredAmountOfSignatures; if( signaturesAndAddrs.length < splitByte || (signaturesAndAddrs.length - splitByte) % _ADDR_SIZE != 0 ) { revert UnexpectedAddrsAndSignaturesSize(); } // hash the addresses part of the byte array and check that it's equal to committe hash if ( keccak256(signaturesAndAddrs[splitByte:]) != committeeHash ) { revert UnexpectedCommitteeHash(); } // recover addresses from signatures and check that are part of the committee uint lastAddrIndexUsed; uint addrsLen = (signaturesAndAddrs.length - splitByte) / _ADDR_SIZE; for (uint i = 0; i < requiredAmountOfSignatures; i++) { address currentSigner = ECDSA.recover( signedHash, signaturesAndAddrs[i*_SIGNATURE_SIZE : i*_SIGNATURE_SIZE + _SIGNATURE_SIZE] ); bool currentSignerIsPartOfCommittee = false; for (uint j = lastAddrIndexUsed; j < addrsLen; j++) { uint currentAddresStartingByte = splitByte + j*_ADDR_SIZE; address committeeAddr = address(bytes20(signaturesAndAddrs[ currentAddresStartingByte : currentAddresStartingByte + _ADDR_SIZE ])); if (committeeAddr == currentSigner) { lastAddrIndexUsed = j+1; currentSignerIsPartOfCommittee = true; break; } } if (!currentSignerIsPartOfCommittee) { revert CommitteeAddressDoesntExist(); } } } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[],"name":"CommitteeAddressDoesntExist","type":"error"},{"inputs":[],"name":"EmptyURLNotAllowed","type":"error"},{"inputs":[],"name":"TooManyRequiredSignatures","type":"error"},{"inputs":[],"name":"UnexpectedAddrsAndSignaturesSize","type":"error"},{"inputs":[],"name":"UnexpectedAddrsBytesLength","type":"error"},{"inputs":[],"name":"UnexpectedCommitteeHash","type":"error"},{"inputs":[],"name":"WrongAddrOrder","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"committeeHash","type":"bytes32"}],"name":"CommitteeUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"version","type":"uint8"}],"name":"Initialized","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"},{"inputs":[],"name":"committeeHash","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getAmountOfMembers","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"members","outputs":[{"internalType":"string","name":"url","type":"string"},{"internalType":"address","name":"addr","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"requiredAmountOfSignatures","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_requiredAmountOfSignatures","type":"uint256"},{"internalType":"string[]","name":"urls","type":"string[]"},{"internalType":"bytes","name":"addrsBytes","type":"bytes"}],"name":"setupCommittee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"signedHash","type":"bytes32"},{"internalType":"bytes","name":"signaturesAndAddrs","type":"bytes"}],"name":"verifySignatures","outputs":[],"stateMutability":"view","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
0x608060405234801561001057600080fd5b50600436106100be5760003560e01c80638129fc1c11610076578063c7a823e01161005b578063c7a823e01461015a578063dce1e2b61461016d578063f2fde38b1461017557600080fd5b80638129fc1c1461012a5780638da5cb5b1461013257600080fd5b8063609d4544116100a7578063609d4544146101025780636beedd3914610119578063715018a61461012257600080fd5b8063078fba2a146100c35780635daf08ca146100d8575b600080fd5b6100d66100d1366004610fa9565b610188565b005b6100eb6100e6366004611054565b61048c565b6040516100f992919061106d565b60405180910390f35b61010b60665481565b6040519081526020016100f9565b61010b60655481565b6100d661055e565b6100d6610572565b60335460405173ffffffffffffffffffffffffffffffffffffffff90911681526020016100f9565b6100d66101683660046110f6565b610709565b60675461010b565b6100d6610183366004611142565b61095c565b610190610a10565b82858110156101cb576040517f2e7dcd6e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6101d66014826111ae565b821461020e576040517f2ab6a12900000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b61021a60676000610eb5565b6000805b828110156104305760006102336014836111ae565b905060008682876102456014836111c5565b92610252939291906111d8565b61025b91611202565b60601c90508888848181106102725761027261124a565b90506020028101906102849190611279565b90506000036102bf576040517fb54b70e400000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8073ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff1610610324576040517fd53cfbe000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b809350606760405180604001604052808b8b878181106103465761034661124a565b90506020028101906103589190611279565b8080601f016020809104026020016040519081016040528093929190818152602001838380828437600092018290525093855250505073ffffffffffffffffffffffffffffffffffffffff851660209283015283546001810185559381522081519192600202019081906103cc90826113af565b5060209190910151600190910180547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff90921691909117905550819050610428816114c9565b91505061021e565b508383604051610441929190611501565b6040519081900381206066819055606589905581527f831403fd381b3e6ac875d912ec2eee0e0203d0d29f7b3e0c96fc8f582d6db6579060200160405180910390a150505050505050565b6067818154811061049c57600080fd5b90600052602060002090600202016000915090508060000180546104bf9061130d565b80601f01602080910402602001604051908101604052809291908181526020018280546104eb9061130d565b80156105385780601f1061050d57610100808354040283529160200191610538565b820191906000526020600020905b81548152906001019060200180831161051b57829003601f168201915b5050506001909301549192505073ffffffffffffffffffffffffffffffffffffffff1682565b610566610a10565b6105706000610a91565b565b600054610100900460ff16158080156105925750600054600160ff909116105b806105ac5750303b1580156105ac575060005460ff166001145b61063d576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602e60248201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160448201527f647920696e697469616c697a656400000000000000000000000000000000000060648201526084015b60405180910390fd5b600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00166001179055801561069b57600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff166101001790555b6106a3610b08565b801561070657600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff169055604051600181527f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024989060200160405180910390a15b50565b6000606554604161071a91906111ae565b90508082108061073e575060146107318284611511565b61073b9190611553565b15155b15610775576040517f6b8eec4600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b606654610784838381876111d8565b604051610792929190611501565b6040518091039020146107d1576040517f6b156b2800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60008060146107e08486611511565b6107ea9190611567565b905060005b60655481101561095357600061086a88888861080c6041876111ae565b90604161081981896111ae565b61082391906111c5565b92610830939291906111d8565b8080601f016020809104026020016040519081016040528093929190818152602001838380828437600092019190915250610ba892505050565b90506000845b848110156109065760006108856014836111ae565b61088f90896111c5565b905060008a828b6108a16014836111c5565b926108ae939291906111d8565b6108b791611202565b60601c905073ffffffffffffffffffffffffffffffffffffffff851681036108f1576108e48360016111c5565b9750600193505050610906565b505080806108fe906114c9565b915050610870565b508061093e576040517f8431721300000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5050808061094b906114c9565b9150506107ef565b50505050505050565b610964610a10565b73ffffffffffffffffffffffffffffffffffffffff8116610a07576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201527f64647265737300000000000000000000000000000000000000000000000000006064820152608401610634565b61070681610a91565b60335473ffffffffffffffffffffffffffffffffffffffff163314610570576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65726044820152606401610634565b6033805473ffffffffffffffffffffffffffffffffffffffff8381167fffffffffffffffffffffffff0000000000000000000000000000000000000000831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b600054610100900460ff16610b9f576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602b60248201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960448201527f6e697469616c697a696e670000000000000000000000000000000000000000006064820152608401610634565b61057033610a91565b6000806000610bb78585610bce565b91509150610bc481610c13565b5090505b92915050565b6000808251604103610c045760208301516040840151606085015160001a610bf887828585610dc6565b94509450505050610c0c565b506000905060025b9250929050565b6000816004811115610c2757610c2761157b565b03610c2f5750565b6001816004811115610c4357610c4361157b565b03610caa576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601860248201527f45434453413a20696e76616c6964207369676e617475726500000000000000006044820152606401610634565b6002816004811115610cbe57610cbe61157b565b03610d25576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601f60248201527f45434453413a20696e76616c6964207369676e6174757265206c656e677468006044820152606401610634565b6003816004811115610d3957610d3961157b565b03610706576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602260248201527f45434453413a20696e76616c6964207369676e6174757265202773272076616c60448201527f75650000000000000000000000000000000000000000000000000000000000006064820152608401610634565b6000807f7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0831115610dfd5750600090506003610eac565b6040805160008082526020820180845289905260ff881692820192909252606081018690526080810185905260019060a0016020604051602081039080840390855afa158015610e51573d6000803e3d6000fd5b50506040517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0015191505073ffffffffffffffffffffffffffffffffffffffff8116610ea557600060019250925050610eac565b9150600090505b94509492505050565b508054600082556002029060005260206000209081019061070691905b80821115610f19576000610ee68282610f1d565b506001810180547fffffffffffffffffffffffff0000000000000000000000000000000000000000169055600201610ed2565b5090565b508054610f299061130d565b6000825580601f10610f39575050565b601f01602090049060005260206000209081019061070691905b80821115610f195760008155600101610f53565b60008083601f840112610f7957600080fd5b50813567ffffffffffffffff811115610f9157600080fd5b602083019150836020828501011115610c0c57600080fd5b600080600080600060608688031215610fc157600080fd5b85359450602086013567ffffffffffffffff80821115610fe057600080fd5b818801915088601f830112610ff457600080fd5b81358181111561100357600080fd5b8960208260051b850101111561101857600080fd5b60208301965080955050604088013591508082111561103657600080fd5b5061104388828901610f67565b969995985093965092949392505050565b60006020828403121561106657600080fd5b5035919050565b604081526000835180604084015260005b8181101561109b576020818701810151606086840101520161107e565b5060006060828501015260607fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f83011684010191505073ffffffffffffffffffffffffffffffffffffffff831660208301529392505050565b60008060006040848603121561110b57600080fd5b83359250602084013567ffffffffffffffff81111561112957600080fd5b61113586828701610f67565b9497909650939450505050565b60006020828403121561115457600080fd5b813573ffffffffffffffffffffffffffffffffffffffff8116811461117857600080fd5b9392505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b8082028115828204841417610bc857610bc861117f565b80820180821115610bc857610bc861117f565b600080858511156111e857600080fd5b838611156111f557600080fd5b5050820193919092039150565b7fffffffffffffffffffffffffffffffffffffffff00000000000000000000000081358181169160148510156112425780818660140360031b1b83161692505b505092915050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b60008083357fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe18436030181126112ae57600080fd5b83018035915067ffffffffffffffff8211156112c957600080fd5b602001915036819003821315610c0c57600080fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600181811c9082168061132157607f821691505b60208210810361135a577f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b50919050565b601f8211156113aa57600081815260208120601f850160051c810160208610156113875750805b601f850160051c820191505b818110156113a657828155600101611393565b5050505b505050565b815167ffffffffffffffff8111156113c9576113c96112de565b6113dd816113d7845461130d565b84611360565b602080601f83116001811461143057600084156113fa5750858301515b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600386901b1c1916600185901b1785556113a6565b6000858152602081207fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe08616915b8281101561147d5788860151825594840194600190910190840161145e565b50858210156114b957878501517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600388901b60f8161c191681555b5050505050600190811b01905550565b60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff82036114fa576114fa61117f565b5060010190565b8183823760009101908152919050565b81810381811115610bc857610bc861117f565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601260045260246000fd5b60008261156257611562611524565b500690565b60008261157657611576611524565b500490565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602160045260246000fdfea2646970667358221220a54a2ecac47f39fb27609b998291b1e8046737fbc346d3fc4d56c25e13d40d7e64736f6c63430008140033
Deployed Bytecode Sourcemap
45182:5901:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47079:1387;;;;;;:::i;:::-;;:::i;:::-;;46045:23;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;45959:28;;;;;;;;;2401:25:1;;;2389:2;2374:18;45959:28:0;2255:177:1;45865:38:0;;;;;;42830:103;;;:::i;46276:124::-;;;:::i;42182:87::-;42255:6;;42182:87;;42255:6;;;;2765:74:1;;2753:2;2738:18;42182:87:0;2619:226:1;49132:1948:0;;;;;;:::i;:::-;;:::i;48474:99::-;48551:7;:14;48474:99;;43088:201;;;;;;:::i;:::-;;:::i;47079:1387::-;42068:13;:11;:13::i;:::-;47273:4;47299:44;;::::1;47295:111;;;47367:27;;;;;;;;;;;;;;47295:111;47441:26;45754:2;47441:13:::0;:26:::1;:::i;:::-;47420:47:::0;::::1;47416:115;;47491:28;;;;;;;;;;;;;;47416:115;47543:14;47550:7;;47543:14;:::i;:::-;47568:16;::::0;47595:702:::1;47616:13;47612:1;:17;47595:702;;;47651:30;47684:14;45754:2;47684:1:::0;:14:::1;:::i;:::-;47651:47:::0;-1:-1:-1;47713:25:0::1;47757:10:::0;47651:47;47757:10;47847:38:::1;45754:2;47651:47:::0;47847:38:::1;:::i;:::-;47757:143;;;;;;;:::i;:::-;47749:152;::::0;::::1;:::i;:::-;47741:161;;47713:189;;47927:4;;47932:1;47927:7;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;47921:21;;47946:1;47921:26:::0;47917:94:::1;;47975:20;;;;;;;;;;;;;;47917:94;48041:17;48029:29;;:8;:29;;;48025:93;;48086:16;;;;;;;;;;;;;;48025:93;48143:17;48132:28;;48175:7;48188:96;;;;;;;;48219:4;;48224:1;48219:7;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;48188:96;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;-1:-1:-1;48188:96:0;;;-1:-1:-1;;;48188:96:0::1;::::0;::::1;;::::0;;::::1;::::0;48175:110;;::::1;::::0;::::1;::::0;;;;;;;;;;::::1;;;::::0;;;::::1;::::0;;::::1;:::i;:::-;-1:-1:-1::0;48175:110:0::1;::::0;;;::::1;::::0;::::1;::::0;;::::1;::::0;;;::::1;;::::0;;::::1;::::0;;;::::1;::::0;;-1:-1:-1;47631:3:0;;-1:-1:-1;47631:3:0::1;::::0;::::1;:::i;:::-;;;;47595:702;;;;48333:10;;48323:21;;;;;;;:::i;:::-;;::::0;;;;::::1;::::0;;48307:13:::1;:37:::0;;;48355:26:::1;:56:::0;;;2401:25:1;;48427:31:0::1;::::0;2389:2:1;2374:18;48427:31:0::1;;;;;;;47241:1225;;47079:1387:::0;;;;;:::o;46045:23::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;46045:23:0;;;;;;;-1:-1:-1;;46045:23:0;;;:::o;42830:103::-;42068:13;:11;:13::i;:::-;42895:30:::1;42922:1;42895:18;:30::i;:::-;42830:103::o:0;46276:124::-;35899:19;35922:13;;;;;;35921:14;;35969:34;;;;-1:-1:-1;35987:12:0;;36002:1;35987:12;;;;:16;35969:34;35968:108;;;-1:-1:-1;36048:4:0;25560:19;:23;;;36009:66;;-1:-1:-1;36058:12:0;;;;;:17;36009:66;35946:204;;;;;;;9318:2:1;35946:204:0;;;9300:21:1;9357:2;9337:18;;;9330:30;9396:34;9376:18;;;9369:62;9467:16;9447:18;;;9440:44;9501:19;;35946:204:0;;;;;;;;;36161:12;:16;;;;36176:1;36161:16;;;36188:67;;;;36223:13;:20;;;;;;;;36188:67;46366:26:::1;:24;:26::i;:::-;36281:14:::0;36277:102;;;36328:5;36312:21;;;;;;36353:14;;-1:-1:-1;9683:36:1;;36353:14:0;;9671:2:1;9656:18;36353:14:0;;;;;;;36277:102;35888:498;46276:124::o;49132:1948::-;49302:14;49337:26;;45673:2;49319:44;;;;:::i;:::-;49302:61;-1:-1:-1;49391:37:0;;;;:111;;-1:-1:-1;45754:2:0;49446:37;49474:9;49446:18;:37;:::i;:::-;49445:52;;;;:::i;:::-;:57;;49391:111;49374:208;;;49536:34;;;;;;;;;;;;;;49374:208;49768:13;;49719:30;:18;49738:9;49719:18;;:30;:::i;:::-;49709:41;;;;;;;:::i;:::-;;;;;;;;:72;49691:161;;49815:25;;;;;;;;;;;;;;49691:161;49951:22;;45754:2;50001:37;50029:9;50001:18;:37;:::i;:::-;50000:52;;;;:::i;:::-;49984:68;;50068:6;50063:1010;50084:26;;50080:1;:30;50063:1010;;;50132:21;50156:151;50188:10;50217:18;;50236:17;45673:2;50236:1;:17;:::i;:::-;50217:75;45673:2;50256:17;45673:2;50256:1;:17;:::i;:::-;:35;;;;:::i;:::-;50217:75;;;;;;;:::i;:::-;50156:151;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;50156:13:0;;-1:-1:-1;;;50156:151:0:i;:::-;50132:175;-1:-1:-1;50322:35:0;50394:17;50380:560;50417:8;50413:1;:12;50380:560;;;50451:30;50496:12;45754:2;50496:1;:12;:::i;:::-;50484:24;;:9;:24;:::i;:::-;50451:57;-1:-1:-1;50527:21:0;50567:18;50451:57;50567:18;50657:38;45754:2;50451:57;50657:38;:::i;:::-;50567:147;;;;;;;:::i;:::-;50559:156;;;:::i;:::-;50551:165;;;-1:-1:-1;50739:30:0;;;;;50735:190;;50814:3;:1;50816;50814:3;:::i;:::-;50794:23;;50873:4;50840:37;;50900:5;;;;50735:190;50432:508;;50427:3;;;;;:::i;:::-;;;;50380:560;;;;50959:30;50954:108;;51017:29;;;;;;;;;;;;;;50954:108;50117:956;;50112:3;;;;;:::i;:::-;;;;50063:1010;;;;49252:1828;;;49132:1948;;;:::o;43088:201::-;42068:13;:11;:13::i;:::-;43177:22:::1;::::0;::::1;43169:73;;;::::0;::::1;::::0;;10778:2:1;43169:73:0::1;::::0;::::1;10760:21:1::0;10817:2;10797:18;;;10790:30;10856:34;10836:18;;;10829:62;10927:8;10907:18;;;10900:36;10953:19;;43169:73:0::1;10576:402:1::0;43169:73:0::1;43253:28;43272:8;43253:18;:28::i;42347:132::-:0;42255:6;;42411:23;42255:6;40300:10;42411:23;42403:68;;;;;;;11185:2:1;42403:68:0;;;11167:21:1;;;11204:18;;;11197:30;11263:34;11243:18;;;11236:62;11315:18;;42403:68:0;10983:356:1;43449:191:0;43542:6;;;;43559:17;;;;;;;;;;;43592:40;;43542:6;;;43559:17;43542:6;;43592:40;;43523:16;;43592:40;43512:128;43449:191;:::o;41830:113::-;38042:13;;;;;;;38034:69;;;;;;;11546:2:1;38034:69:0;;;11528:21:1;11585:2;11565:18;;;11558:30;11624:34;11604:18;;;11597:62;11695:13;11675:18;;;11668:41;11726:19;;38034:69:0;11344:407:1;38034:69:0;41903:32:::1;40300:10:::0;41903:18:::1;:32::i;18993:231::-:0;19071:7;19092:17;19111:18;19133:27;19144:4;19150:9;19133:10;:27::i;:::-;19091:69;;;;19171:18;19183:5;19171:11;:18::i;:::-;-1:-1:-1;19207:9:0;-1:-1:-1;18993:231:0;;;;;:::o;17444:747::-;17525:7;17534:12;17563:9;:16;17583:2;17563:22;17559:625;;17907:4;17892:20;;17886:27;17957:4;17942:20;;17936:27;18015:4;18000:20;;17994:27;17602:9;17986:36;18058:25;18069:4;17986:36;17886:27;17936;18058:10;:25::i;:::-;18051:32;;;;;;;;;17559:625;-1:-1:-1;18132:1:0;;-1:-1:-1;18136:35:0;17559:625;17444:747;;;;;:::o;15837:521::-;15915:20;15906:5;:29;;;;;;;;:::i;:::-;;15902:449;;15837:521;:::o;15902:449::-;16013:29;16004:5;:38;;;;;;;;:::i;:::-;;16000:351;;16059:34;;;;;12147:2:1;16059:34:0;;;12129:21:1;12186:2;12166:18;;;12159:30;12225:26;12205:18;;;12198:54;12269:18;;16059:34:0;11945:348:1;16000:351:0;16124:35;16115:5;:44;;;;;;;;:::i;:::-;;16111:240;;16176:41;;;;;12500:2:1;16176:41:0;;;12482:21:1;12539:2;12519:18;;;12512:30;12578:33;12558:18;;;12551:61;12629:18;;16176:41:0;12298:355:1;16111:240:0;16248:30;16239:5;:39;;;;;;;;:::i;:::-;;16235:116;;16295:44;;;;;12860:2:1;16295:44:0;;;12842:21:1;12899:2;12879:18;;;12872:30;12938:34;12918:18;;;12911:62;13009:4;12989:18;;;12982:32;13031:19;;16295:44:0;12658:398:1;20445:1520:0;20576:7;;21510:66;21497:79;;21493:163;;;-1:-1:-1;21609:1:0;;-1:-1:-1;21613:30:0;21593:51;;21493:163;21770:24;;;21753:14;21770:24;;;;;;;;;13288:25:1;;;13361:4;13349:17;;13329:18;;;13322:45;;;;13383:18;;;13376:34;;;13426:18;;;13419:34;;;21770:24:0;;13260:19:1;;21770:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;21770:24:0;;;;;;-1:-1:-1;;21809:20:0;;;21805:103;;21862:1;21866:29;21846:50;;;;;;;21805:103;21928:6;-1:-1:-1;21936:20:0;;-1:-1:-1;20445:1520:0;;;;;;;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;:::i;:::-;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14:347:1;65:8;75:6;129:3;122:4;114:6;110:17;106:27;96:55;;147:1;144;137:12;96:55;-1:-1:-1;170:20:1;;213:18;202:30;;199:50;;;245:1;242;235:12;199:50;282:4;274:6;270:17;258:29;;334:3;327:4;318:6;310;306:19;302:30;299:39;296:59;;;351:1;348;341:12;366:982;493:6;501;509;517;525;578:2;566:9;557:7;553:23;549:32;546:52;;;594:1;591;584:12;546:52;630:9;617:23;607:33;;691:2;680:9;676:18;663:32;714:18;755:2;747:6;744:14;741:34;;;771:1;768;761:12;741:34;809:6;798:9;794:22;784:32;;854:7;847:4;843:2;839:13;835:27;825:55;;876:1;873;866:12;825:55;916:2;903:16;942:2;934:6;931:14;928:34;;;958:1;955;948:12;928:34;1011:7;1006:2;996:6;993:1;989:14;985:2;981:23;977:32;974:45;971:65;;;1032:1;1029;1022:12;971:65;1063:2;1059;1055:11;1045:21;;1085:6;1075:16;;;1144:2;1133:9;1129:18;1116:32;1100:48;;1173:2;1163:8;1160:16;1157:36;;;1189:1;1186;1179:12;1157:36;;1228:60;1280:7;1269:8;1258:9;1254:24;1228:60;:::i;:::-;366:982;;;;-1:-1:-1;366:982:1;;-1:-1:-1;1307:8:1;;1202:86;366:982;-1:-1:-1;;;366:982:1:o;1353:180::-;1412:6;1465:2;1453:9;1444:7;1440:23;1436:32;1433:52;;;1481:1;1478;1471:12;1433:52;-1:-1:-1;1504:23:1;;1353:180;-1:-1:-1;1353:180:1:o;1538:712::-;1715:2;1704:9;1697:21;1678:4;1747:6;1741:13;1790:6;1785:2;1774:9;1770:18;1763:34;1815:1;1825:144;1839:6;1836:1;1833:13;1825:144;;;1952:4;1936:14;;;1932:25;;1926:32;1921:2;1902:17;;;1898:26;1891:68;1854:12;1825:144;;;1829:3;2018:1;2013:2;2004:6;1993:9;1989:22;1985:31;1978:42;2147:2;2077:66;2072:2;2064:6;2060:15;2056:88;2045:9;2041:104;2037:113;2029:121;;;2200:42;2192:6;2188:55;2181:4;2170:9;2166:20;2159:85;1538:712;;;;;:::o;2850:477::-;2929:6;2937;2945;2998:2;2986:9;2977:7;2973:23;2969:32;2966:52;;;3014:1;3011;3004:12;2966:52;3050:9;3037:23;3027:33;;3111:2;3100:9;3096:18;3083:32;3138:18;3130:6;3127:30;3124:50;;;3170:1;3167;3160:12;3124:50;3209:58;3259:7;3250:6;3239:9;3235:22;3209:58;:::i;:::-;2850:477;;3286:8;;-1:-1:-1;3183:84:1;;-1:-1:-1;;;;2850:477:1:o;3332:309::-;3391:6;3444:2;3432:9;3423:7;3419:23;3415:32;3412:52;;;3460:1;3457;3450:12;3412:52;3499:9;3486:23;3549:42;3542:5;3538:54;3531:5;3528:65;3518:93;;3607:1;3604;3597:12;3518:93;3630:5;3332:309;-1:-1:-1;;;3332:309:1:o;3646:184::-;3698:77;3695:1;3688:88;3795:4;3792:1;3785:15;3819:4;3816:1;3809:15;3835:168;3908:9;;;3939;;3956:15;;;3950:22;;3936:37;3926:71;;3977:18;;:::i;4008:125::-;4073:9;;;4094:10;;;4091:36;;;4107:18;;:::i;4138:331::-;4243:9;4254;4296:8;4284:10;4281:24;4278:44;;;4318:1;4315;4308:12;4278:44;4347:6;4337:8;4334:20;4331:40;;;4367:1;4364;4357:12;4331:40;-1:-1:-1;;4393:23:1;;;4438:25;;;;;-1:-1:-1;4138:331:1:o;4474:372::-;4633:66;4595:19;;4717:11;;;;4748:2;4740:11;;4737:103;;;4827:2;4821;4814:3;4810:2;4806:12;4803:1;4799:20;4795:29;4791:2;4787:38;4783:47;4774:56;;4737:103;;;4474:372;;;;:::o;4851:184::-;4903:77;4900:1;4893:88;5000:4;4997:1;4990:15;5024:4;5021:1;5014:15;5040:581;5118:4;5124:6;5184:11;5171:25;5274:66;5263:8;5247:14;5243:29;5239:102;5219:18;5215:127;5205:155;;5356:1;5353;5346:12;5205:155;5383:33;;5435:20;;;-1:-1:-1;5478:18:1;5467:30;;5464:50;;;5510:1;5507;5500:12;5464:50;5543:4;5531:17;;-1:-1:-1;5574:14:1;5570:27;;;5560:38;;5557:58;;;5611:1;5608;5601:12;5626:184;5678:77;5675:1;5668:88;5775:4;5772:1;5765:15;5799:4;5796:1;5789:15;5815:437;5894:1;5890:12;;;;5937;;;5958:61;;6012:4;6004:6;6000:17;5990:27;;5958:61;6065:2;6057:6;6054:14;6034:18;6031:38;6028:218;;6102:77;6099:1;6092:88;6203:4;6200:1;6193:15;6231:4;6228:1;6221:15;6028:218;;5815:437;;;:::o;6383:545::-;6485:2;6480:3;6477:11;6474:448;;;6521:1;6546:5;6542:2;6535:17;6591:4;6587:2;6577:19;6661:2;6649:10;6645:19;6642:1;6638:27;6632:4;6628:38;6697:4;6685:10;6682:20;6679:47;;;-1:-1:-1;6720:4:1;6679:47;6775:2;6770:3;6766:12;6763:1;6759:20;6753:4;6749:31;6739:41;;6830:82;6848:2;6841:5;6838:13;6830:82;;;6893:17;;;6874:1;6863:13;6830:82;;;6834:3;;;6474:448;6383:545;;;:::o;7164:1471::-;7290:3;7284:10;7317:18;7309:6;7306:30;7303:56;;;7339:18;;:::i;:::-;7368:97;7458:6;7418:38;7450:4;7444:11;7418:38;:::i;:::-;7412:4;7368:97;:::i;:::-;7520:4;;7584:2;7573:14;;7601:1;7596:782;;;;8422:1;8439:6;8436:89;;;-1:-1:-1;8491:19:1;;;8485:26;8436:89;7070:66;7061:1;7057:11;;;7053:84;7049:89;7039:100;7145:1;7141:11;;;7036:117;8538:81;;7566:1063;;7596:782;6330:1;6323:14;;;6367:4;6354:18;;7644:66;7632:79;;;7809:236;7823:7;7820:1;7817:14;7809:236;;;7912:19;;;7906:26;7891:42;;8004:27;;;;7972:1;7960:14;;;;7839:19;;7809:236;;;7813:3;8073:6;8064:7;8061:19;8058:261;;;8134:19;;;8128:26;8235:66;8217:1;8213:14;;;8229:3;8209:24;8205:97;8201:102;8186:118;8171:134;;8058:261;-1:-1:-1;;;;;8365:1:1;8349:14;;;8345:22;8332:36;;-1:-1:-1;7164:1471:1:o;8640:195::-;8679:3;8710:66;8703:5;8700:77;8697:103;;8780:18;;:::i;:::-;-1:-1:-1;8827:1:1;8816:13;;8640:195::o;8840:271::-;9023:6;9015;9010:3;8997:33;8979:3;9049:16;;9074:13;;;9049:16;8840:271;-1:-1:-1;8840:271:1:o;9730:128::-;9797:9;;;9818:11;;;9815:37;;;9832:18;;:::i;9863:184::-;9915:77;9912:1;9905:88;10012:4;10009:1;10002:15;10036:4;10033:1;10026:15;10052:112;10084:1;10110;10100:35;;10115:18;;:::i;:::-;-1:-1:-1;10149:9:1;;10052:112::o;10451:120::-;10491:1;10517;10507:35;;10522:18;;:::i;:::-;-1:-1:-1;10556:9:1;;10451:120::o;11756:184::-;11808:77;11805:1;11798:88;11905:4;11902:1;11895:15;11929:4;11926:1;11919:15
Swarm Source
ipfs://a54a2ecac47f39fb27609b998291b1e8046737fbc346d3fc4d56c25e13d40d7e
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 26 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
Loading...
Loading
[ Download: CSV Export ]
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.