Feature Tip: Add private address tag to any address under My Name Tag !
Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
TokenTracker
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 Name:
Outercasts
Compiler Version
v0.8.13+commit.abaa5c0e
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2022-10-17 */ // File: contracts/OutercastsErrors.sol // Creator: base64.tech pragma solidity ^0.8.13; //"Not enough ETH Sent" error NotEnoughETHSent(); //"free claim is not active" error FreeClaimIsNotActive(); //"pre-sale is not active" error PreSaleIsNotActive(); //"free mint sale is not active" error FreeMintIsNotActive(); //"public sale is not active" error PublicSaleIsNotActive(); //"Purchase would exceed max supply" error PurchaseWouldExceedMaxSupply(); //"Mint would exceed maximum allocation of mints for this wallet/mint type" error MintWouldExceedMaxAllocation(); // "Hash was already used" error HashWasAlreadyUsed(); // "Unrecognizable Hash" error UnrecognizeableHash(); // "The caller is another contract" error CallerIsAnotherContract(); // File: contracts/IStakingController.sol // Creator: base64.tech pragma solidity ^0.8.13; /* * Interface for SamuRiseStakingController for use in Samurise contract */ interface IStakingController { function stakeFromTokenContract(uint256 tokenId, address originator) external; } // File: @openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol) pragma solidity ^0.8.0; /** * @title ERC721 token receiver interface * @dev Interface for any contract that wants to support safeTransfers * from ERC721 asset contracts. */ interface IERC721ReceiverUpgradeable { /** * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom} * by `operator` from `from`, this function is called. * * It must return its Solidity selector to confirm the token transfer. * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted. * * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`. */ function onERC721Received( address operator, address from, uint256 tokenId, bytes calldata data ) external returns (bytes4); } // File: @openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol // OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC165 standard, as defined in the * https://eips.ethereum.org/EIPS/eip-165[EIP]. * * Implementers can declare support of contract interfaces, which can then be * queried by others ({ERC165Checker}). * * For an implementation, see {ERC165}. */ interface IERC165Upgradeable { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); } // File: @openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol // OpenZeppelin Contracts (last updated v4.8.0-rc.1) (token/ERC721/IERC721.sol) pragma solidity ^0.8.0; /** * @dev Required interface of an ERC721 compliant contract. */ interface IERC721Upgradeable is IERC165Upgradeable { /** * @dev Emitted when `tokenId` token is transferred from `from` to `to`. */ event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token. */ event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets. */ event ApprovalForAll(address indexed owner, address indexed operator, bool approved); /** * @dev Returns the number of tokens in ``owner``'s account. */ function balanceOf(address owner) external view returns (uint256 balance); /** * @dev Returns the owner of the `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function ownerOf(uint256 tokenId) external view returns (address owner); /** * @dev Safely transfers `tokenId` token from `from` to `to`. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom( address from, address to, uint256 tokenId, bytes calldata data ) external; /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom( address from, address to, uint256 tokenId ) external; /** * @dev Transfers `tokenId` token from `from` to `to`. * * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721 * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must * understand this adds an external call which potentially creates a reentrancy vulnerability. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * * Emits a {Transfer} event. */ function transferFrom( address from, address to, uint256 tokenId ) external; /** * @dev Gives permission to `to` to transfer `tokenId` token to another account. * The approval is cleared when the token is transferred. * * Only a single account can be approved at a time, so approving the zero address clears previous approvals. * * Requirements: * * - The caller must own the token or be an approved operator. * - `tokenId` must exist. * * Emits an {Approval} event. */ function approve(address to, uint256 tokenId) external; /** * @dev Approve or remove `operator` as an operator for the caller. * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. * * Requirements: * * - The `operator` cannot be the caller. * * Emits an {ApprovalForAll} event. */ function setApprovalForAll(address operator, bool _approved) external; /** * @dev Returns the account approved for `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function getApproved(uint256 tokenId) external view returns (address operator); /** * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`. * * See {setApprovalForAll} */ function isApprovedForAll(address owner, address operator) external view returns (bool); } // File: @openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol // OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol) pragma solidity ^0.8.0; /** * @title ERC-721 Non-Fungible Token Standard, optional metadata extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721MetadataUpgradeable is IERC721Upgradeable { /** * @dev Returns the token collection name. */ function name() external view returns (string memory); /** * @dev Returns the token collection symbol. */ function symbol() external view returns (string memory); /** * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token. */ function tokenURI(uint256 tokenId) external view returns (string memory); } // File: @openzeppelin/contracts-upgradeable/utils/math/MathUpgradeable.sol // OpenZeppelin Contracts (last updated v4.8.0-rc.1) (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) { 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-upgradeable/utils/StringsUpgradeable.sol // OpenZeppelin Contracts (last updated v4.8.0-rc.1) (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 `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); } } // File: @openzeppelin/contracts-upgradeable/utils/cryptography/ECDSAUpgradeable.sol // OpenZeppelin Contracts (last updated v4.8.0-rc.1) (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) { // 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", 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) { return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash)); } } // File: @openzeppelin/contracts-upgradeable/utils/StorageSlotUpgradeable.sol // OpenZeppelin Contracts (last updated v4.7.0) (utils/StorageSlot.sol) 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: * ``` * 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`, and `uint256`._ */ library StorageSlotUpgradeable { struct AddressSlot { address value; } struct BooleanSlot { bool value; } struct Bytes32Slot { bytes32 value; } struct Uint256Slot { uint256 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 } } } // File: @openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol // OpenZeppelin Contracts (last updated v4.8.0-rc.1) (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.0-rc.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 Internal function that returns the initialized version. Returns `_initialized` */ function _getInitializedVersion() internal view returns (uint8) { return _initialized; } /** * @dev Internal function that returns the initialized version. Returns `_initializing` */ function _isInitializing() internal view returns (bool) { return _initializing; } } // File: @openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol // OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol) pragma solidity ^0.8.0; /** * @dev Implementation of the {IERC165} interface. * * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check * for the additional interface id that will be supported. For example: * * ```solidity * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId); * } * ``` * * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation. */ abstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable { function __ERC165_init() internal onlyInitializing { } function __ERC165_init_unchained() internal onlyInitializing { } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IERC165Upgradeable).interfaceId; } /** * @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/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: contracts/ERC721A.sol // Creator: Chiru Labs pragma solidity ^0.8.4; error ApprovalCallerNotOwnerNorApproved(); error ApprovalQueryForNonexistentToken(); error ApproveToCaller(); error ApprovalToCurrentOwner(); error BalanceQueryForZeroAddress(); error MintToZeroAddress(); error MintZeroQuantity(); error OwnerQueryForNonexistentToken(); error TransferCallerNotOwnerNorApproved(); error TransferFromIncorrectOwner(); error TransferToNonERC721ReceiverImplementer(); error TransferToZeroAddress(); error URIQueryForNonexistentToken(); /** * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including * the Metadata extension. Built to optimize for lower gas during batch mints. * * Assumes serials are sequentially minted starting at _startTokenId() (defaults to 0, e.g. 0, 1, 2, 3..). * * Assumes that an owner cannot have more than 2**64 - 1 (max value of uint64) of supply. * * Assumes that the maximum token id cannot exceed 2**256 - 1 (max value of uint256). */ contract ERC721A is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable { using AddressUpgradeable for address; using StringsUpgradeable for uint256; // Compiler will pack this into a single 256bit word. struct TokenOwnership { // The address of the owner. address addr; // Keeps track of the start time of ownership with minimal overhead for tokenomics. uint64 startTimestamp; // Whether the token has been burned. bool burned; } // Compiler will pack this into a single 256bit word. struct AddressData { // Realistically, 2**64-1 is more than enough. uint64 balance; // Keeps track of mint count with minimal overhead for tokenomics. uint64 numberMinted; // Keeps track of burn count with minimal overhead for tokenomics. uint64 numberBurned; // For miscellaneous variable(s) pertaining to the address // (e.g. number of whitelist mint slots used). // If there are multiple variables, please pack them into a uint64. uint64 aux; } // The tokenId of the next token to be minted. uint256 internal _currentIndex; // The number of tokens burned. uint256 internal _burnCounter; // Token name string private _name; // Token symbol string private _symbol; // Mapping from token ID to ownership details // An empty struct value does not necessarily mean the token is unowned. See _ownershipOf implementation for details. mapping(uint256 => TokenOwnership) internal _ownerships; // Mapping owner address to address data mapping(address => AddressData) private _addressData; // Mapping from token ID to approved address mapping(uint256 => address) private _tokenApprovals; // Mapping from owner to operator approvals mapping(address => mapping(address => bool)) private _operatorApprovals; bool private initialized; //constructor(string memory name_, string memory symbol_) { function __ERC721A_initialize(string memory name_, string memory symbol_) internal onlyInitializing{ require(!initialized, "Contract instance has already been initialized"); initialized = true; _name = name_; _symbol = symbol_; _currentIndex = _startTokenId(); } /** * To change the starting tokenId, please override this function. */ function _startTokenId() internal view virtual returns (uint256) { return 0; } /** * @dev Burned tokens are calculated here, use _totalMinted() if you want to count just minted tokens. */ function totalSupply() public view returns (uint256) { // Counter underflow is impossible as _burnCounter cannot be incremented // more than _currentIndex - _startTokenId() times unchecked { return _currentIndex - _burnCounter - _startTokenId(); } } /** * Returns the total amount of tokens minted in the contract. */ function _totalMinted() internal view returns (uint256) { // Counter underflow is impossible as _currentIndex does not decrement, // and it is initialized to _startTokenId() unchecked { return _currentIndex - _startTokenId(); } } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) { return interfaceId == type(IERC721Upgradeable).interfaceId || interfaceId == type(IERC721MetadataUpgradeable).interfaceId || super.supportsInterface(interfaceId); } /** * @dev See {IERC721-balanceOf}. */ function balanceOf(address owner) public view override returns (uint256) { if (owner == address(0)) revert BalanceQueryForZeroAddress(); return uint256(_addressData[owner].balance); } /** * Returns the number of tokens minted by `owner`. */ function _numberMinted(address owner) internal view returns (uint256) { return uint256(_addressData[owner].numberMinted); } /** * Returns the number of tokens burned by or on behalf of `owner`. */ function _numberBurned(address owner) internal view returns (uint256) { return uint256(_addressData[owner].numberBurned); } /** * Returns the auxillary data for `owner`. (e.g. number of whitelist mint slots used). */ function _getAux(address owner) internal view returns (uint64) { return _addressData[owner].aux; } /** * Sets the auxillary data for `owner`. (e.g. number of whitelist mint slots used). * If there are multiple variables, please pack them into a uint64. */ function _setAux(address owner, uint64 aux) internal { _addressData[owner].aux = aux; } /** * Gas spent here starts off proportional to the maximum mint batch size. * It gradually moves to O(1) as tokens get transferred around in the collection over time. */ function _ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) { uint256 curr = tokenId; unchecked { if (_startTokenId() <= curr && curr < _currentIndex) { TokenOwnership memory ownership = _ownerships[curr]; if (!ownership.burned) { if (ownership.addr != address(0)) { return ownership; } // Invariant: // There will always be an ownership that has an address and is not burned // before an ownership that does not have an address and is not burned. // Hence, curr will not underflow. while (true) { curr--; ownership = _ownerships[curr]; if (ownership.addr != address(0)) { return ownership; } } } } } revert OwnerQueryForNonexistentToken(); } /** * @dev See {IERC721-ownerOf}. */ function ownerOf(uint256 tokenId) public view override returns (address) { return _ownershipOf(tokenId).addr; } /** * @dev See {IERC721Metadata-name}. */ function name() public view virtual override returns (string memory) { return _name; } /** * @dev See {IERC721Metadata-symbol}. */ function symbol() public view virtual override returns (string memory) { return _symbol; } /** * @dev See {IERC721Metadata-tokenURI}. */ function tokenURI(uint256 tokenId) public view virtual override returns (string memory) { if (!_exists(tokenId)) revert URIQueryForNonexistentToken(); string memory baseURI = _baseURI(); return bytes(baseURI).length != 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : ''; } /** * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each * token will be the concatenation of the `baseURI` and the `tokenId`. Empty * by default, can be overriden in child contracts. */ function _baseURI() internal view virtual returns (string memory) { return ''; } /** * @dev See {IERC721-approve}. */ function approve(address to, uint256 tokenId) public override { address owner = ERC721A.ownerOf(tokenId); if (to == owner) revert ApprovalToCurrentOwner(); if (_msgSender() != owner && !isApprovedForAll(owner, _msgSender())) { revert ApprovalCallerNotOwnerNorApproved(); } _approve(to, tokenId, owner); } /** * @dev See {IERC721-getApproved}. */ function getApproved(uint256 tokenId) public view override returns (address) { if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken(); return _tokenApprovals[tokenId]; } /** * @dev See {IERC721-setApprovalForAll}. */ function setApprovalForAll(address operator, bool approved) public virtual override { if (operator == _msgSender()) revert ApproveToCaller(); _operatorApprovals[_msgSender()][operator] = approved; emit ApprovalForAll(_msgSender(), operator, approved); } /** * @dev See {IERC721-isApprovedForAll}. */ function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) { return _operatorApprovals[owner][operator]; } /** * @dev See {IERC721-transferFrom}. */ function transferFrom( address from, address to, uint256 tokenId ) public virtual override { _transfer(from, to, tokenId); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom( address from, address to, uint256 tokenId ) public virtual override { safeTransferFrom(from, to, tokenId, ''); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom( address from, address to, uint256 tokenId, bytes memory _data ) public virtual override { _transfer(from, to, tokenId); if (to.isContract() && !_checkContractOnERC721Received(from, to, tokenId, _data)) { revert TransferToNonERC721ReceiverImplementer(); } } /** * @dev Returns whether `tokenId` exists. * * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}. * * Tokens start existing when they are minted (`_mint`), */ function _exists(uint256 tokenId) internal view returns (bool) { return _startTokenId() <= tokenId && tokenId < _currentIndex && !_ownerships[tokenId].burned; } function _safeMint(address to, uint256 quantity) internal { _safeMint(to, quantity, ''); } /** * @dev Safely mints `quantity` tokens and transfers them to `to`. * * Requirements: * * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called for each safe transfer. * - `quantity` must be greater than 0. * * Emits a {Transfer} event. */ function _safeMint( address to, uint256 quantity, bytes memory _data ) internal { _mint(to, quantity, _data, true); } /** * @dev Mints `quantity` tokens and transfers them to `to`. * * Requirements: * * - `to` cannot be the zero address. * - `quantity` must be greater than 0. * * Emits a {Transfer} event. */ function _mint( address to, uint256 quantity, bytes memory _data, bool safe ) internal { uint256 startTokenId = _currentIndex; if (to == address(0)) revert MintToZeroAddress(); if (quantity == 0) revert MintZeroQuantity(); _beforeTokenTransfers(address(0), to, startTokenId, quantity); // Overflows are incredibly unrealistic. // balance or numberMinted overflow if current value of either + quantity > 1.8e19 (2**64) - 1 // updatedIndex overflows if _currentIndex + quantity > 1.2e77 (2**256) - 1 unchecked { _addressData[to].balance += uint64(quantity); _addressData[to].numberMinted += uint64(quantity); _ownerships[startTokenId].addr = to; _ownerships[startTokenId].startTimestamp = uint64(block.timestamp); uint256 updatedIndex = startTokenId; uint256 end = updatedIndex + quantity; if (safe && to.isContract()) { do { emit Transfer(address(0), to, updatedIndex); if (!_checkContractOnERC721Received(address(0), to, updatedIndex++, _data)) { revert TransferToNonERC721ReceiverImplementer(); } } while (updatedIndex != end); // Reentrancy protection if (_currentIndex != startTokenId) revert(); } else { do { emit Transfer(address(0), to, updatedIndex++); } while (updatedIndex != end); } _currentIndex = updatedIndex; } _afterTokenTransfers(address(0), to, startTokenId, quantity); } /** * @dev Transfers `tokenId` from `from` to `to`. * * Requirements: * * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * * Emits a {Transfer} event. */ function _transfer( address from, address to, uint256 tokenId ) private { TokenOwnership memory prevOwnership = _ownershipOf(tokenId); if (prevOwnership.addr != from) revert TransferFromIncorrectOwner(); bool isApprovedOrOwner = (_msgSender() == from || isApprovedForAll(from, _msgSender()) || getApproved(tokenId) == _msgSender()); if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved(); if (to == address(0)) revert TransferToZeroAddress(); _beforeTokenTransfers(from, to, tokenId, 1); // Clear approvals from the previous owner _approve(address(0), tokenId, from); // Underflow of the sender's balance is impossible because we check for // ownership above and the recipient's balance can't realistically overflow. // Counter overflow is incredibly unrealistic as tokenId would have to be 2**256. unchecked { _addressData[from].balance -= 1; _addressData[to].balance += 1; TokenOwnership storage currSlot = _ownerships[tokenId]; currSlot.addr = to; currSlot.startTimestamp = uint64(block.timestamp); // If the ownership slot of tokenId+1 is not explicitly set, that means the transfer initiator owns it. // Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls. uint256 nextTokenId = tokenId + 1; TokenOwnership storage nextSlot = _ownerships[nextTokenId]; if (nextSlot.addr == address(0)) { // This will suffice for checking _exists(nextTokenId), // as a burned slot cannot contain the zero address. if (nextTokenId != _currentIndex) { nextSlot.addr = from; nextSlot.startTimestamp = prevOwnership.startTimestamp; } } } emit Transfer(from, to, tokenId); _afterTokenTransfers(from, to, tokenId, 1); } /** * @dev This is equivalent to _burn(tokenId, false) */ function _burn(uint256 tokenId) internal virtual { _burn(tokenId, false); } /** * @dev Destroys `tokenId`. * The approval is cleared when the token is burned. * * Requirements: * * - `tokenId` must exist. * * Emits a {Transfer} event. */ function _burn(uint256 tokenId, bool approvalCheck) internal virtual { TokenOwnership memory prevOwnership = _ownershipOf(tokenId); address from = prevOwnership.addr; if (approvalCheck) { bool isApprovedOrOwner = (_msgSender() == from || isApprovedForAll(from, _msgSender()) || getApproved(tokenId) == _msgSender()); if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved(); } _beforeTokenTransfers(from, address(0), tokenId, 1); // Clear approvals from the previous owner _approve(address(0), tokenId, from); // Underflow of the sender's balance is impossible because we check for // ownership above and the recipient's balance can't realistically overflow. // Counter overflow is incredibly unrealistic as tokenId would have to be 2**256. unchecked { AddressData storage addressData = _addressData[from]; addressData.balance -= 1; addressData.numberBurned += 1; // Keep track of who burned the token, and the timestamp of burning. TokenOwnership storage currSlot = _ownerships[tokenId]; currSlot.addr = from; currSlot.startTimestamp = uint64(block.timestamp); currSlot.burned = true; // If the ownership slot of tokenId+1 is not explicitly set, that means the burn initiator owns it. // Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls. uint256 nextTokenId = tokenId + 1; TokenOwnership storage nextSlot = _ownerships[nextTokenId]; if (nextSlot.addr == address(0)) { // This will suffice for checking _exists(nextTokenId), // as a burned slot cannot contain the zero address. if (nextTokenId != _currentIndex) { nextSlot.addr = from; nextSlot.startTimestamp = prevOwnership.startTimestamp; } } } emit Transfer(from, address(0), tokenId); _afterTokenTransfers(from, address(0), tokenId, 1); // Overflow not possible, as _burnCounter cannot be exceed _currentIndex times. unchecked { _burnCounter++; } } /** * @dev Approve `to` to operate on `tokenId` * * Emits a {Approval} event. */ function _approve( address to, uint256 tokenId, address owner ) private { _tokenApprovals[tokenId] = to; emit Approval(owner, to, tokenId); } /** * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target contract. * * @param from address representing the previous owner of the given token ID * @param to target address that will receive the tokens * @param tokenId uint256 ID of the token to be transferred * @param _data bytes optional data to send along with the call * @return bool whether the call correctly returned the expected magic value */ function _checkContractOnERC721Received( address from, address to, uint256 tokenId, bytes memory _data ) private returns (bool) { try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) { return retval == IERC721ReceiverUpgradeable(to).onERC721Received.selector; } catch (bytes memory reason) { if (reason.length == 0) { revert TransferToNonERC721ReceiverImplementer(); } else { assembly { revert(add(32, reason), mload(reason)) } } } } /** * @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting. * And also called before burning one token. * * startTokenId - the first token id to be transferred * quantity - the amount to be transferred * * Calling conditions: * * - When `from` and `to` are both non-zero, `from`'s `tokenId` will be * transferred to `to`. * - When `from` is zero, `tokenId` will be minted for `to`. * - When `to` is zero, `tokenId` will be burned by `from`. * - `from` and `to` are never both zero. */ function _beforeTokenTransfers( address from, address to, uint256 startTokenId, uint256 quantity ) internal virtual {} /** * @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes * minting. * And also called after one token has been burned. * * startTokenId - the first token id to be transferred * quantity - the amount to be transferred * * Calling conditions: * * - When `from` and `to` are both non-zero, `from`'s `tokenId` has been * transferred to `to`. * - When `from` is zero, `tokenId` has been minted for `to`. * - When `to` is zero, `tokenId` has been burned by `from`. * - `from` and `to` are never both zero. */ function _afterTokenTransfers( address from, address to, uint256 startTokenId, uint256 quantity ) internal virtual {} } // File: contracts/ERC721NES.sol // Creator: base64.tech pragma solidity ^0.8.13; /** * @dev Extension of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, * that allows for Non Escrow Staking. By calling the stake function on a token, you disable * the ability to transfer the token. By calling the unstake function on a token you re-enable * the ability to transfer the token. * * This implementation extends ERC721A, but can be modified to extend your own ERC721 implementation * or the standard Open Zeppelin version. * * For more details: https://erc721nes.org */ abstract contract ERC721NES is ERC721A { // This is an optional reference to an external contract allows // you to abstract away your staking interface to another contract. // if this variable is set, stake / unstake can only be called from // the stakingController if it is not set stake / unstake can be called // directly on the implementing contract. address public stakingController; // Event published when a token is staked. event Staked(uint256 tokenId); // Event published when a token is unstaked. event Unstaked(uint256 tokenId); // Mapping of tokenId storing its staked status mapping(uint256 => bool) public tokenToIsStaked; /** * @dev sets stakingController, scope of this method is internal, so this defaults * to requiring setting the staking controller contact upon deployment or requires * a public OnlyOwner helper method to be exposed in the implementing contract. */ function _setStakingController(address _stakingController) internal { stakingController = _stakingController; } /** * @dev returns whether a token is currently staked */ function isStaked(uint256 tokenId) public view returns (bool) { return tokenToIsStaked[tokenId]; } /** * @dev marks a token as staked, calling this function * you disable the ability to transfer the token. */ function _stake(uint256 tokenId) internal { require(!isStaked(tokenId), "token is already staked"); tokenToIsStaked[tokenId] = true; emit Staked(tokenId); } /** * @dev marks a token as unstaked. By calling this function * you re-enable the ability to transfer the token. */ function _unstake(uint256 tokenId) internal { require(isStaked(tokenId), "token isn't staked"); tokenToIsStaked[tokenId] = false; emit Unstaked(tokenId); } /** * @dev marks a token as staked, can only be performed by delegated * staking controller contract. By calling this function you * disable the ability to transfer the token. */ function stakeFromController(uint256 tokenId, address originator) public { require( msg.sender == stakingController, "Function can only be called from staking controller contract" ); require( ownerOf(tokenId) == originator, "Originator is not the owner of this token" ); _stake(tokenId); } /** * @dev marks a token as unstaked, can only be performed delegated * staking controller contract. By calling this function you * re-enable the ability to transfer the token. */ function unstakeFromController(uint256 tokenId, address originator) public { require( msg.sender == stakingController, "Function can only be called from staking controller contract" ); require( ownerOf(tokenId) == originator, "Originator is not the owner of this token" ); _unstake(tokenId); } /** * @dev perform safe mint and stake */ function _safemintAndStake(address to, uint256 quantity) internal { uint256 startTokenId = _currentIndex; for (uint256 i = 0; i < quantity; i++) { startTokenId++; tokenToIsStaked[startTokenId] = true; } _safeMint(to, quantity, ""); } /** * @dev perform mint and stake */ function _mintAndStake(address to, uint256 quantity) internal { uint256 startTokenId = _currentIndex; for (uint256 i = 0; i < quantity; i++) { startTokenId++; tokenToIsStaked[startTokenId] = true; } _mint(to, quantity, "", false); } /** * @dev overrides transferFrom to prevent transfer if token is staked */ function transferFrom( address from, address to, uint256 tokenId ) public override { require( isStaked(tokenId) == false, "You can not transfer a staked token" ); super.transferFrom(from, to, tokenId); } /** * @dev overrides safeTransferFrom to prevent transfer if token is staked */ function safeTransferFrom( address from, address to, uint256 tokenId ) public override { require( isStaked(tokenId) == false, "You can not transfer a staked token" ); super.safeTransferFrom(from, to, tokenId, ""); } /** * @dev overrides safeTransferFrom to prevent transfer if token is staked */ function safeTransferFrom( address from, address to, uint256 tokenId, bytes memory _data ) public override { require( isStaked(tokenId) == false, "You can not transfer a staked token" ); super.safeTransferFrom(from, to, tokenId, _data); } } // 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: @openzeppelin/contracts-upgradeable/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/contracts-upgradeable/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/contracts-upgradeable/proxy/ERC1967/ERC1967UpgradeUpgradeable.sol // OpenZeppelin Contracts (last updated v4.5.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._ * * @custom:oz-upgrades-unsafe-allow delegatecall */ abstract contract ERC1967UpgradeUpgradeable is Initializable { 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 Emitted when the implementation is upgraded. */ event Upgraded(address indexed implementation); /** * @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) { _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 Emitted when the admin account has changed. */ event AdminChanged(address previousAdmin, address newAdmin); /** * @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 Emitted when the beacon is upgraded. */ event BeaconUpgraded(address indexed beacon); /** * @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) { _functionDelegateCall(IBeaconUpgradeable(newBeacon).implementation(), data); } } /** * @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) private returns (bytes memory) { require(AddressUpgradeable.isContract(target), "Address: delegate call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.delegatecall(data); return AddressUpgradeable.verifyCallResult(success, returndata, "Address: low-level delegate call failed"); } /** * @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/proxy/utils/UUPSUpgradeable.sol // OpenZeppelin Contracts (last updated v4.8.0-rc.1) (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. */ function upgradeTo(address newImplementation) external 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. */ function upgradeToAndCall(address newImplementation, bytes memory data) external 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: contracts/Outercasts.sol // Creator: base64.tech pragma solidity ^0.8.13; contract Outercasts is ERC721NES, OwnableUpgradeable, UUPSUpgradeable { using ECDSAUpgradeable for bytes32; // +1 in these constants used for gas optimization // for use in conditional statements uint256 public constant TOTAL_MAX_SUPPLY = 5555 + 1; uint256 public constant TOTAL_MAX_FREEMINTS = 1300 + 1; uint256 public constant MAX_FREE_MINT_PER_WALLET = 1 + 1; uint256 public constant MAX_LAUNCHLIST_MINT_PER_WALLET = 3 + 1; uint256 public constant MAX_PUBLIC_MINT_PER_WALLET = 3 + 1; // allocation reserved for team uint256 public constant TEAM_ALLOCATION = 600; // ENUM to determine which mint phase we are performing enum MintType{ INACTIVE, PRESALE_MINT, PUBLIC_MINT } // Price for presale / public mint uint256 public constant TOKEN_PRICE = .025 ether; // Public key used to verify signatures address public signatureVerifier; // Sales state MintType public saleState; // Provenance hash string public provenanceHash; // Map to track used hashes mapping(bytes32 => bool) public usedHashes; // Maps to track number minted for each sale state mapping(address => uint256) public numberFreeMinted; mapping(address => uint256) public numberPreSaleMinted; mapping(address => uint256) public numberPublicMinted; string private _baseTokenURI; bool private initialized; function initialize() public initializer { require(!initialized, "Contract instance has already been initialized"); initialized = true; __Ownable_init_unchained(); __ERC721A_initialize("OUTERCASTS", "Outercasts"); __UUPSUpgradeable_init_unchained(); saleState = MintType.INACTIVE; } /* FUNCTION MODIFIERS */ modifier callerIsUser() { if(tx.origin != msg.sender) revert CallerIsAnotherContract(); _; } modifier validatePreSaleActive() { if(saleState != MintType.PRESALE_MINT) revert PreSaleIsNotActive(); _; } modifier validatePublicSaleActive() { if(saleState != MintType.PUBLIC_MINT) revert PublicSaleIsNotActive(); _; } modifier correctAmountSent(uint256 _quantity) { if(!(msg.value >= TOKEN_PRICE * _quantity)) revert NotEnoughETHSent(); _; } modifier underMaxSupply(uint256 _quantity) { if(!(_totalMinted() + _quantity < TOTAL_MAX_SUPPLY - TOTAL_MAX_FREEMINTS)) revert PurchaseWouldExceedMaxSupply(); _; } modifier underMaxFreeMintSupply(uint256 _quantity) { if(!(_totalMinted() + _quantity < TOTAL_MAX_SUPPLY)) revert PurchaseWouldExceedMaxSupply(); _; } modifier numberMintedUnderAllocation(uint256 _currentNumberOfMints, uint256 _quantity, uint256 _allowance) { uint256 totalQuantity = _currentNumberOfMints + _quantity; if(!(totalQuantity < _allowance)) revert MintWouldExceedMaxAllocation(); _; } /* MINT FUNCTIONS */ function freeMint(bytes memory _signature, uint256 _nonce, bool _toStake) external callerIsUser validatePreSaleActive underMaxFreeMintSupply(1) numberMintedUnderAllocation(numberFreeMinted[msg.sender], 1, MAX_FREE_MINT_PER_WALLET) { _outercastsMint(_signature, 1, _nonce, MintType.PRESALE_MINT, _toStake); numberFreeMinted[msg.sender] += 1; } function preSaleMint(bytes memory _signature, uint256 _quantity, uint256 _nonce, bool _toStake) external payable callerIsUser validatePreSaleActive underMaxSupply(_quantity) numberMintedUnderAllocation(numberPreSaleMinted[msg.sender], _quantity, MAX_LAUNCHLIST_MINT_PER_WALLET) correctAmountSent(_quantity) { _outercastsMint(_signature, _quantity, _nonce, MintType.PRESALE_MINT, _toStake); numberPreSaleMinted[msg.sender] += _quantity; } function publicMint(bytes memory _signature, uint256 _quantity, uint256 _nonce, bool _toStake) external payable callerIsUser validatePublicSaleActive underMaxSupply(_quantity) numberMintedUnderAllocation(numberPublicMinted[msg.sender], _quantity, MAX_PUBLIC_MINT_PER_WALLET) correctAmountSent(_quantity) { _outercastsMint(_signature, _quantity, _nonce, MintType.PUBLIC_MINT, _toStake); numberPublicMinted[msg.sender] += _quantity; } function _outercastsMint(bytes memory _signature, uint256 _quantity, uint256 _nonce, MintType mintType, bool _toStake) private { bytes32 messageHash = hashMessage(msg.sender, _nonce, mintType); uint256 startIndex = _currentIndex; if(messageHash.recover(_signature) != signatureVerifier) revert UnrecognizeableHash(); if(usedHashes[messageHash] == true) revert HashWasAlreadyUsed(); usedHashes[messageHash] = true; _mint(msg.sender, _quantity, "", false); if(_toStake) { for(uint256 i = startIndex; i < startIndex + _quantity; i++) { IStakingController(stakingController).stakeFromTokenContract(i, msg.sender); } } } /* INTERNAL FUNCTIONS */ function _baseURI() internal view virtual override returns (string memory) { return _baseTokenURI; } /** * Sets external staking controller contract to be used to control staking */ function setStakingController(address _stakingController) public onlyOwner { _setStakingController(_stakingController); } /* UTILITY FUNCTIONS */ function numberMinted(address owner) public view returns (uint256) { return _numberMinted(owner); } function getOwnershipData(uint256 tokenId) external view returns (TokenOwnership memory) { return _ownershipOf(tokenId); } function hashMessage(address _sender, uint256 _nonce, MintType mintType) public pure returns (bytes32) { bytes32 hash = keccak256( abi.encodePacked( "\x19Ethereum Signed Message:\n32", keccak256(abi.encodePacked(_sender, _nonce, uint256(mintType))) ) ); return hash; } /* OWNER FUNCTIONS */ function ownerMint(uint256 _numberToMint) external onlyOwner underMaxFreeMintSupply(_numberToMint) { _mint(msg.sender, _numberToMint, "", false); } function ownerMintAndStake(uint256 _numberToMint) external onlyOwner underMaxFreeMintSupply(_numberToMint) { uint256 startIndex = _currentIndex; _mint(msg.sender, _numberToMint, "", false); for(uint256 i = startIndex; i < startIndex + _numberToMint; i++) { IStakingController(stakingController).stakeFromTokenContract(i, msg.sender); } } function teamAllocationMint() external onlyOwner underMaxFreeMintSupply(TEAM_ALLOCATION) { _mint(msg.sender, TEAM_ALLOCATION, "", false); } function ownerMintToAddress(address _recipient, uint256 _numberToMint) external onlyOwner underMaxFreeMintSupply(_numberToMint) { _mint(_recipient, _numberToMint, "", false); } function setProvenanceHash(string memory _provenanceHash) public onlyOwner { provenanceHash = _provenanceHash; } function setBaseURI(string calldata baseURI) external onlyOwner { _baseTokenURI = baseURI; } function withdraw() public payable onlyOwner { // This will pay Jordan 3% of the initial sale. (bool js, ) = payable(0x65D38b601d386f72DBc767995F47b2B136d45521).call{value: address(this).balance * 3 / 100}(""); require(js); // This will payout the owner 97% of the contract balance. (bool os, ) = payable(owner()).call{value: address(this).balance}(""); require(os); } function setSignatureVerifier(address _signatureVerifier) external onlyOwner { signatureVerifier = _signatureVerifier; } function setPublicSaleActive() external onlyOwner { saleState = MintType.PUBLIC_MINT; } function setPreSaleActive() external onlyOwner { saleState = MintType.PRESALE_MINT; } function pauseMint() external onlyOwner { saleState = MintType.INACTIVE; } function _authorizeUpgrade(address) internal override onlyOwner {} }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"ApprovalQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"ApprovalToCurrentOwner","type":"error"},{"inputs":[],"name":"ApproveToCaller","type":"error"},{"inputs":[],"name":"BalanceQueryForZeroAddress","type":"error"},{"inputs":[],"name":"CallerIsAnotherContract","type":"error"},{"inputs":[],"name":"HashWasAlreadyUsed","type":"error"},{"inputs":[],"name":"MintToZeroAddress","type":"error"},{"inputs":[],"name":"MintWouldExceedMaxAllocation","type":"error"},{"inputs":[],"name":"MintZeroQuantity","type":"error"},{"inputs":[],"name":"NotEnoughETHSent","type":"error"},{"inputs":[],"name":"OwnerQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"PreSaleIsNotActive","type":"error"},{"inputs":[],"name":"PublicSaleIsNotActive","type":"error"},{"inputs":[],"name":"PurchaseWouldExceedMaxSupply","type":"error"},{"inputs":[],"name":"TransferCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"TransferFromIncorrectOwner","type":"error"},{"inputs":[],"name":"TransferToNonERC721ReceiverImplementer","type":"error"},{"inputs":[],"name":"TransferToZeroAddress","type":"error"},{"inputs":[],"name":"URIQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"UnrecognizeableHash","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":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","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":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Staked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Unstaked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"implementation","type":"address"}],"name":"Upgraded","type":"event"},{"inputs":[],"name":"MAX_FREE_MINT_PER_WALLET","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_LAUNCHLIST_MINT_PER_WALLET","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_PUBLIC_MINT_PER_WALLET","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TEAM_ALLOCATION","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TOKEN_PRICE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TOTAL_MAX_FREEMINTS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TOTAL_MAX_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"_signature","type":"bytes"},{"internalType":"uint256","name":"_nonce","type":"uint256"},{"internalType":"bool","name":"_toStake","type":"bool"}],"name":"freeMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getOwnershipData","outputs":[{"components":[{"internalType":"address","name":"addr","type":"address"},{"internalType":"uint64","name":"startTimestamp","type":"uint64"},{"internalType":"bool","name":"burned","type":"bool"}],"internalType":"struct ERC721A.TokenOwnership","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_sender","type":"address"},{"internalType":"uint256","name":"_nonce","type":"uint256"},{"internalType":"enum Outercasts.MintType","name":"mintType","type":"uint8"}],"name":"hashMessage","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"isStaked","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"numberFreeMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"numberMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"numberPreSaleMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"numberPublicMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_numberToMint","type":"uint256"}],"name":"ownerMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_numberToMint","type":"uint256"}],"name":"ownerMintAndStake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_recipient","type":"address"},{"internalType":"uint256","name":"_numberToMint","type":"uint256"}],"name":"ownerMintToAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pauseMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"_signature","type":"bytes"},{"internalType":"uint256","name":"_quantity","type":"uint256"},{"internalType":"uint256","name":"_nonce","type":"uint256"},{"internalType":"bool","name":"_toStake","type":"bool"}],"name":"preSaleMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"provenanceHash","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"proxiableUUID","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"_signature","type":"bytes"},{"internalType":"uint256","name":"_quantity","type":"uint256"},{"internalType":"uint256","name":"_nonce","type":"uint256"},{"internalType":"bool","name":"_toStake","type":"bool"}],"name":"publicMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"saleState","outputs":[{"internalType":"enum Outercasts.MintType","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"setPreSaleActive","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_provenanceHash","type":"string"}],"name":"setProvenanceHash","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"setPublicSaleActive","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_signatureVerifier","type":"address"}],"name":"setSignatureVerifier","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_stakingController","type":"address"}],"name":"setStakingController","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"signatureVerifier","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"address","name":"originator","type":"address"}],"name":"stakeFromController","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stakingController","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"teamAllocationMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"tokenToIsStaked","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"address","name":"originator","type":"address"}],"name":"unstakeFromController","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":"bytes32","name":"","type":"bytes32"}],"name":"usedHashes","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"payable","type":"function"}]
Contract Creation Code
60a06040523060805234801561001457600080fd5b50608051613a4e61004c60003960008181610dc701528181610e070152818161100901528181611049015261122c0152613a4e6000f3fe6080604052600436106103805760003560e01c80639231ab2a116101d1578063c8d5ed6811610102578063e5a51952116100a0578063f19e75d41161006f578063f19e75d414610a58578063f2fde38b14610a78578063fd99cbed14610a98578063fde919f614610aae57600080fd5b8063e5a5195214610993578063e66ab47d146109c1578063e8831b02146109e1578063e985e9c514610a0f57600080fd5b8063d2d8cb67116100dc578063d2d8cb6714610925578063d402602914610940578063dc33e68114610953578063e08a66051461097357600080fd5b8063c8d5ed6814610464578063cd85cdb5146108f0578063d1cbffd41461090557600080fd5b8063a96533e91161016f578063b88d4fde11610149578063b88d4fde1461086b578063baa51f861461088b578063c6ab67a3146108bb578063c87b56dd146108d057600080fd5b8063a96533e9146107ea578063aef18bf71461081a578063b38166721461084b57600080fd5b80639a350251116101ab5780639a350251146107755780639aaf21f414610795578063a22cb465146107b5578063a6eb27e2146107d557600080fd5b80639231ab2a146106dc57806394a16bda1461073257806395d89b411461076057600080fd5b806342842e0e116102b65780636352211e11610254578063715018a611610223578063715018a61461067f5780638129fc1c14610694578063819ab792146106a95780638da5cb5b146106be57600080fd5b80636352211e1461060457806365b1de201461062457806370a082311461063a578063713e6a091461065a57600080fd5b806352d1902d1161029057806352d1902d1461058057806355f804b314610595578063592109da146105b5578063603f4d52146105d557600080fd5b806342842e0e1461053a5780634f1ef2861461055a57806351a503e31461056d57600080fd5b806318160ddd1161032357806332dc4d76116102fd57806332dc4d76146104e75780633659cfe6146104fd5780633ccfd60b1461051d5780633e11ab3f1461052557600080fd5b806318160ddd1461049957806320fe418a146104b257806323b872dd146104c757600080fd5b8063081812fc1161035f578063081812fc1461040a578063095ea7b3146104425780630c92fa1214610464578063109695231461047957600080fd5b8062240b6b1461038557806301ffc9a7146103b857806306fdde03146103e8575b600080fd5b34801561039157600080fd5b506103a56103a0366004613108565b610acf565b6040519081526020015b60405180910390f35b3480156103c457600080fd5b506103d86103d3366004613162565b610b7f565b60405190151581526020016103af565b3480156103f457600080fd5b506103fd610bd1565b6040516103af91906131d7565b34801561041657600080fd5b5061042a6104253660046131ea565b610c63565b6040516001600160a01b0390911681526020016103af565b34801561044e57600080fd5b5061046261045d366004613203565b610ca7565b005b34801561047057600080fd5b506103a5600481565b34801561048557600080fd5b506104626104943660046132b8565b610d34565b3480156104a557600080fd5b50606654606554036103a5565b3480156104be57600080fd5b50610462610d54565b3480156104d357600080fd5b506104626104e2366004613300565b610d7a565b3480156104f357600080fd5b506103a561051581565b34801561050957600080fd5b5061046261051836600461333c565b610dbd565b610462610e9c565b34801561053157600080fd5b50610462610f92565b34801561054657600080fd5b50610462610555366004613300565b610fb5565b610462610568366004613377565b610fff565b61046261057b3660046133d4565b6110cb565b34801561058c57600080fd5b506103a561121f565b3480156105a157600080fd5b506104626105b0366004613434565b6112d2565b3480156105c157600080fd5b506104626105d03660046134a5565b6112e7565b3480156105e157600080fd5b50610105546105f790600160a01b900460ff1681565b6040516103af91906134e7565b34801561061057600080fd5b5061042a61061f3660046131ea565b611358565b34801561063057600080fd5b506103a56115b481565b34801561064657600080fd5b506103a561065536600461333c565b61136a565b34801561066657600080fd5b50606d5461042a9061010090046001600160a01b031681565b34801561068b57600080fd5b506104626113b8565b3480156106a057600080fd5b506104626113cc565b3480156106b557600080fd5b50610462611573565b3480156106ca57600080fd5b50606f546001600160a01b031661042a565b3480156106e857600080fd5b506106fc6106f73660046131ea565b6115d1565b6040805182516001600160a01b031681526020808401516001600160401b031690820152918101511515908201526060016103af565b34801561073e57600080fd5b506103a561074d36600461333c565b6101096020526000908152604090205481565b34801561076c57600080fd5b506103fd6115f7565b34801561078157600080fd5b506104626107903660046134a5565b611606565b3480156107a157600080fd5b506104626107b0366004613203565b611677565b3480156107c157600080fd5b506104626107d036600461350f565b6116d1565b3480156107e157600080fd5b506103a5600281565b3480156107f657600080fd5b506103d86108053660046131ea565b606e6020526000908152604090205460ff1681565b34801561082657600080fd5b506103d86108353660046131ea565b6101076020526000908152604090205460ff1681565b34801561085757600080fd5b506104626108663660046131ea565b611766565b34801561087757600080fd5b50610462610886366004613539565b61185b565b34801561089757600080fd5b506103d86108a63660046131ea565b6000908152606e602052604090205460ff1690565b3480156108c757600080fd5b506103fd611896565b3480156108dc57600080fd5b506103fd6108eb3660046131ea565b611925565b3480156108fc57600080fd5b506104626119a8565b34801561091157600080fd5b506104626109203660046135a0565b6119cb565b34801561093157600080fd5b506103a56658d15e1762800081565b61046261094e3660046133d4565b611ae4565b34801561095f57600080fd5b506103a561096e36600461333c565b611c27565b34801561097f57600080fd5b5061046261098e36600461333c565b611c55565b34801561099f57600080fd5b506103a56109ae36600461333c565b6101086020526000908152604090205481565b3480156109cd57600080fd5b506104626109dc36600461333c565b611c80565b3480156109ed57600080fd5b506103a56109fc36600461333c565b61010a6020526000908152604090205481565b348015610a1b57600080fd5b506103d8610a2a3660046135f6565b6001600160a01b039182166000908152606c6020908152604080832093909416825291909152205460ff1690565b348015610a6457600080fd5b50610462610a733660046131ea565b611cab565b348015610a8457600080fd5b50610462610a9336600461333c565b611d05565b348015610aa457600080fd5b506103a561025881565b348015610aba57600080fd5b506101055461042a906001600160a01b031681565b6000808484846002811115610ae657610ae66134d1565b60405160609390931b6bffffffffffffffffffffffff191660208401526034830191909152605482015260740160408051601f198184030181529082905280516020918201207f19457468657265756d205369676e6564204d6573736167653a0a33320000000091830191909152603c820152605c0160408051601f1981840301815291905280516020909101209150505b9392505050565b60006001600160e01b031982166380ac58cd60e01b1480610bb057506001600160e01b03198216635b5e139f60e01b145b80610bcb57506301ffc9a760e01b6001600160e01b03198316145b92915050565b606060678054610be090613620565b80601f0160208091040260200160405190810160405280929190818152602001828054610c0c90613620565b8015610c595780601f10610c2e57610100808354040283529160200191610c59565b820191906000526020600020905b815481529060010190602001808311610c3c57829003601f168201915b5050505050905090565b6000610c6e82611d7b565b610c8b576040516333d1c03960e21b815260040160405180910390fd5b506000908152606b60205260409020546001600160a01b031690565b6000610cb282611358565b9050806001600160a01b0316836001600160a01b031603610ce65760405163250fdee360e21b815260040160405180910390fd5b336001600160a01b03821614801590610d065750610d048133610a2a565b155b15610d24576040516367d9dca160e11b815260040160405180910390fd5b610d2f838383611da7565b505050565b610d3c611e03565b8051610d5090610106906020840190612fdf565b5050565b610d5c611e03565b61010580546001919060ff60a01b1916600160a01b835b0217905550565b6000818152606e602052604090205460ff1615610db25760405162461bcd60e51b8152600401610da99061365a565b60405180910390fd5b610d2f838383611e5d565b6001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000163003610e055760405162461bcd60e51b8152600401610da99061369d565b7f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316610e4e6000805160206139d2833981519152546001600160a01b031690565b6001600160a01b031614610e745760405162461bcd60e51b8152600401610da9906136e9565b610e7d81611e68565b60408051600080825260208201909252610e9991839190611e70565b50565b610ea4611e03565b60007365d38b601d386f72dbc767995f47b2b136d455216064610ec847600361374b565b610ed2919061376a565b604051600081818185875af1925050503d8060008114610f0e576040519150601f19603f3d011682016040523d82523d6000602084013e610f13565b606091505b5050905080610f2157600080fd5b6000610f35606f546001600160a01b031690565b6001600160a01b03164760405160006040518083038185875af1925050503d8060008114610f7f576040519150601f19603f3d011682016040523d82523d6000602084013e610f84565b606091505b5050905080610d5057600080fd5b610f9a611e03565b61010580546002919060ff60a01b1916600160a01b83610d73565b6000818152606e602052604090205460ff1615610fe45760405162461bcd60e51b8152600401610da99061365a565b610d2f83838360405180602001604052806000815250611fdb565b6001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001630036110475760405162461bcd60e51b8152600401610da99061369d565b7f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03166110906000805160206139d2833981519152546001600160a01b031690565b6001600160a01b0316146110b65760405162461bcd60e51b8152600401610da9906136e9565b6110bf82611e68565b610d5082826001611e70565b3233146110eb576040516307a5349360e51b815260040160405180910390fd5b600161010554600160a01b900460ff16600281111561110c5761110c6134d1565b1461112a57604051632eb0b9b560e01b815260040160405180910390fd5b826111396105156115b461378c565b8161114360655490565b61114d91906137a3565b1061116b57604051633c63ed6d60e01b815260040160405180910390fd5b336000908152610109602052604081205490859060049061118c83856137a3565b90508181106111ae576040516370e6f7a960e11b815260040160405180910390fd5b876111c0816658d15e1762800061374b565b3410156111e05760405163434f4a1f60e01b815260040160405180910390fd5b6111ee8a8a8a60018b612026565b3360009081526101096020526040812080548b929061120e9084906137a3565b909155505050505050505050505050565b6000306001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016146112bf5760405162461bcd60e51b815260206004820152603860248201527f555550535570677261646561626c653a206d757374206e6f742062652063616c60448201527f6c6564207468726f7567682064656c656761746563616c6c00000000000000006064820152608401610da9565b506000805160206139d283398151915290565b6112da611e03565b610d2f61010b8383613063565b606d5461010090046001600160a01b031633146113165760405162461bcd60e51b8152600401610da9906137bb565b806001600160a01b031661132983611358565b6001600160a01b03161461134f5760405162461bcd60e51b8152600401610da990613818565b610d5082612180565b60006113638261221b565b5192915050565b60006001600160a01b038216611393576040516323d3ad8160e21b815260040160405180910390fd5b506001600160a01b03166000908152606a60205260409020546001600160401b031690565b6113c0611e03565b6113ca6000612335565b565b600054610100900460ff16158080156113ec5750600054600160ff909116105b806114065750303b158015611406575060005460ff166001145b6114695760405162461bcd60e51b815260206004820152602e60248201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160448201526d191e481a5b9a5d1a585b1a5e995960921b6064820152608401610da9565b6000805460ff19166001179055801561148c576000805461ff0019166101001790555b61010c5460ff16156114b05760405162461bcd60e51b8152600401610da990613861565b61010c805460ff191660011790556114c6612387565b6115146040518060400160405280600a8152602001694f55544552434153545360b01b8152506040518060400160405280600a8152602001694f75746572636173747360b01b8152506123b7565b61151c61243f565b610105805460ff60a01b191690558015610e99576000805461ff0019169055604051600181527f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498906020015b60405180910390a150565b61157b611e03565b6102586115b48161158b60655490565b61159591906137a3565b106115b357604051633c63ed6d60e01b815260040160405180910390fd5b610e9933610258604051806020016040528060008152506000612466565b6040805160608101825260008082526020820181905291810191909152610bcb8261221b565b606060688054610be090613620565b606d5461010090046001600160a01b031633146116355760405162461bcd60e51b8152600401610da9906137bb565b806001600160a01b031661164883611358565b6001600160a01b03161461166e5760405162461bcd60e51b8152600401610da990613818565b610d5082612635565b61167f611e03565b806115b48161168d60655490565b61169791906137a3565b106116b557604051633c63ed6d60e01b815260040160405180910390fd5b610d2f8383604051806020016040528060008152506000612466565b336001600160a01b038316036116fa5760405163b06307db60e01b815260040160405180910390fd5b336000818152606c602090815260408083206001600160a01b03871680855290835292819020805460ff191686151590811790915590519081529192917f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31910160405180910390a35050565b61176e611e03565b806115b48161177c60655490565b61178691906137a3565b106117a457604051633c63ed6d60e01b815260040160405180910390fd5b600060655490506117c73384604051806020016040528060008152506000612466565b805b6117d384836137a3565b81101561185557606d5460405163f39254e760e01b8152600481018390523360248201526101009091046001600160a01b03169063f39254e790604401600060405180830381600087803b15801561182a57600080fd5b505af115801561183e573d6000803e3d6000fd5b50505050808061184d906138af565b9150506117c9565b50505050565b6000828152606e602052604090205460ff161561188a5760405162461bcd60e51b8152600401610da99061365a565b61185584848484611fdb565b61010680546118a490613620565b80601f01602080910402602001604051908101604052809291908181526020018280546118d090613620565b801561191d5780601f106118f25761010080835404028352916020019161191d565b820191906000526020600020905b81548152906001019060200180831161190057829003601f168201915b505050505081565b606061193082611d7b565b61194d57604051630a14c4b560e41b815260040160405180910390fd5b60006119576126df565b905080516000036119775760405180602001604052806000815250610b78565b80611981846126ef565b6040516020016119929291906138c8565b6040516020818303038152906040529392505050565b6119b0611e03565b61010580546000919060ff60a01b1916600160a01b83610d73565b3233146119eb576040516307a5349360e51b815260040160405180910390fd5b600161010554600160a01b900460ff166002811115611a0c57611a0c6134d1565b14611a2a57604051632eb0b9b560e01b815260040160405180910390fd5b60016115b481611a3960655490565b611a4391906137a3565b10611a6157604051633c63ed6d60e01b815260040160405180910390fd5b336000908152610108602052604081205490600190600290611a8383856137a3565b9050818110611aa5576040516370e6f7a960e11b815260040160405180910390fd5b611ab48860018960018a612026565b33600090815261010860205260408120805460019290611ad59084906137a3565b90915550505050505050505050565b323314611b04576040516307a5349360e51b815260040160405180910390fd5b600261010554600160a01b900460ff166002811115611b2557611b256134d1565b14611b435760405163e707b04f60e01b815260040160405180910390fd5b82611b526105156115b461378c565b81611b5c60655490565b611b6691906137a3565b10611b8457604051633c63ed6d60e01b815260040160405180910390fd5b33600090815261010a6020526040812054908590600490611ba583856137a3565b9050818110611bc7576040516370e6f7a960e11b815260040160405180910390fd5b87611bd9816658d15e1762800061374b565b341015611bf95760405163434f4a1f60e01b815260040160405180910390fd5b611c078a8a8a60028b612026565b33600090815261010a6020526040812080548b929061120e9084906137a3565b6001600160a01b0381166000908152606a6020526040812054600160401b90046001600160401b0316610bcb565b611c5d611e03565b61010580546001600160a01b0319166001600160a01b0392909216919091179055565b611c88611e03565b606d8054610100600160a81b0319166101006001600160a01b0384160217905550565b611cb3611e03565b806115b481611cc160655490565b611ccb91906137a3565b10611ce957604051633c63ed6d60e01b815260040160405180910390fd5b610d503383604051806020016040528060008152506000612466565b611d0d611e03565b6001600160a01b038116611d725760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b6064820152608401610da9565b610e9981612335565b600060655482108015610bcb575050600090815260696020526040902054600160e01b900460ff161590565b6000828152606b602052604080822080546001600160a01b0319166001600160a01b0387811691821790925591518593918516917f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92591a4505050565b606f546001600160a01b031633146113ca5760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65726044820152606401610da9565b610d2f838383612781565b610e99611e03565b7f4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd91435460ff1615611ea357610d2f8361296c565b826001600160a01b03166352d1902d6040518163ffffffff1660e01b8152600401602060405180830381865afa925050508015611efd575060408051601f3d908101601f19168201909252611efa918101906138f7565b60015b611f605760405162461bcd60e51b815260206004820152602e60248201527f45524331393637557067726164653a206e657720696d706c656d656e7461746960448201526d6f6e206973206e6f74205555505360901b6064820152608401610da9565b6000805160206139d28339815191528114611fcf5760405162461bcd60e51b815260206004820152602960248201527f45524331393637557067726164653a20756e737570706f727465642070726f786044820152681a58589b195555525160ba1b6064820152608401610da9565b50610d2f838383612a08565b611fe6848484612781565b6001600160a01b0383163b15158015612008575061200684848484612a2d565b155b15611855576040516368d2bf6b60e11b815260040160405180910390fd5b6000612033338585610acf565b60655461010554919250906001600160a01b03166120518389612b19565b6001600160a01b031614612078576040516348b7127560e01b815260040160405180910390fd5b6000828152610107602052604090205460ff1615156001036120ad57604051631061109160e21b815260040160405180910390fd5b600082815261010760209081526040808320805460ff19166001179055805191820190528181526120e19133918991612466565b821561217757805b6120f387836137a3565b81101561217557606d5460405163f39254e760e01b8152600481018390523360248201526101009091046001600160a01b03169063f39254e790604401600060405180830381600087803b15801561214a57600080fd5b505af115801561215e573d6000803e3d6000fd5b50505050808061216d906138af565b9150506120e9565b505b50505050505050565b6000818152606e602052604090205460ff166121d35760405162461bcd60e51b81526020600482015260126024820152711d1bdad95b881a5cdb89dd081cdd185ad95960721b6044820152606401610da9565b6000818152606e602052604090819020805460ff19169055517f11725367022c3ff288940f4b5473aa61c2da6a24af7363a1128ee2401e8983b2906115689083815260200190565b60408051606081018252600080825260208201819052918101919091528160655481101561231c57600081815260696020908152604091829020825160608101845290546001600160a01b0381168252600160a01b81046001600160401b031692820192909252600160e01b90910460ff1615159181018290529061231a5780516001600160a01b0316156122b1579392505050565b5060001901600081815260696020908152604091829020825160608101845290546001600160a01b038116808352600160a01b82046001600160401b031693830193909352600160e01b900460ff1615159281019290925215612315579392505050565b6122b1565b505b604051636f96cda160e11b815260040160405180910390fd5b606f80546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b600054610100900460ff166123ae5760405162461bcd60e51b8152600401610da990613910565b6113ca33612335565b600054610100900460ff166123de5760405162461bcd60e51b8152600401610da990613910565b606d5460ff16156124015760405162461bcd60e51b8152600401610da990613861565b606d805460ff191660011790558151612421906067906020850190612fdf565b508051612435906068906020840190612fdf565b5060006065555050565b600054610100900460ff166113ca5760405162461bcd60e51b8152600401610da990613910565b6065546001600160a01b03851661248f57604051622e076360e81b815260040160405180910390fd5b836000036124b05760405163b562e8dd60e01b815260040160405180910390fd5b6001600160a01b0385166000818152606a6020908152604080832080546fffffffffffffffffffffffffffffffff1981166001600160401b038083168c018116918217600160401b67ffffffffffffffff1990941690921783900481168c01811690920217909155858452606990925290912080546001600160e01b031916909217600160a01b42909216919091021790558080850183801561255c57506001600160a01b0387163b15155b156125e4575b60405182906001600160a01b038916906000907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908290a46125ad6000888480600101955088612a2d565b6125ca576040516368d2bf6b60e11b815260040160405180910390fd5b8082036125625782606554146125df57600080fd5b612629565b5b6040516001830192906001600160a01b038916906000907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908290a48082036125e5575b506065555b5050505050565b6000818152606e602052604090205460ff16156126945760405162461bcd60e51b815260206004820152601760248201527f746f6b656e20697320616c7265616479207374616b65640000000000000000006044820152606401610da9565b6000818152606e602052604090819020805460ff19166001179055517feebbaa86c348cb664e392b180fd0ff2e1998af9fa833ef69a778cb0b42d3ca27906115689083815260200190565b606061010b8054610be090613620565b606060006126fc83612b3d565b60010190506000816001600160401b0381111561271b5761271b61322d565b6040519080825280601f01601f191660200182016040528015612745576020820181803683370190505b5090508181016020015b600019016f181899199a1a9b1b9c1cb0b131b232b360811b600a86061a8153600a850494508461274f57509392505050565b600061278c8261221b565b9050836001600160a01b031681600001516001600160a01b0316146127c35760405162a1148160e81b815260040160405180910390fd5b6000336001600160a01b03861614806127e157506127e18533610a2a565b806127fc5750336127f184610c63565b6001600160a01b0316145b90508061281c57604051632ce44b5f60e11b815260040160405180910390fd5b6001600160a01b03841661284357604051633a954ecd60e21b815260040160405180910390fd5b61284f60008487611da7565b6001600160a01b038581166000908152606a60209081526040808320805467ffffffffffffffff198082166001600160401b0392831660001901831617909255898616808652838620805493841693831660019081018416949094179055898652606990945282852080546001600160e01b031916909417600160a01b4290921691909102178355870180845292208054919390911661292357606554821461292357805460208601516001600160401b0316600160a01b026001600160e01b03199091166001600160a01b038a16171781555b50505082846001600160a01b0316866001600160a01b03167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef60405160405180910390a461262e565b6001600160a01b0381163b6129d95760405162461bcd60e51b815260206004820152602d60248201527f455243313936373a206e657720696d706c656d656e746174696f6e206973206e60448201526c1bdd08184818dbdb9d1c9858dd609a1b6064820152608401610da9565b6000805160206139d283398151915280546001600160a01b0319166001600160a01b0392909216919091179055565b612a1183612c15565b600082511180612a1e5750805b15610d2f576118558383612c55565b604051630a85bd0160e11b81526000906001600160a01b0385169063150b7a0290612a6290339089908890889060040161395b565b6020604051808303816000875af1925050508015612a9d575060408051601f3d908101601f19168201909252612a9a91810190613998565b60015b612afb573d808015612acb576040519150601f19603f3d011682016040523d82523d6000602084013e612ad0565b606091505b508051600003612af3576040516368d2bf6b60e11b815260040160405180910390fd5b805181602001fd5b6001600160e01b031916630a85bd0160e11b1490505b949350505050565b6000806000612b288585612d49565b91509150612b3581612d8e565b509392505050565b60008072184f03e93ff9f4daa797ed6e38ed64bf6a1f0160401b8310612b7c5772184f03e93ff9f4daa797ed6e38ed64bf6a1f0160401b830492506040015b6d04ee2d6d415b85acef81000000008310612ba8576d04ee2d6d415b85acef8100000000830492506020015b662386f26fc100008310612bc657662386f26fc10000830492506010015b6305f5e1008310612bde576305f5e100830492506008015b6127108310612bf257612710830492506004015b60648310612c04576064830492506002015b600a8310610bcb5760010192915050565b612c1e8161296c565b6040516001600160a01b038216907fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b90600090a250565b60606001600160a01b0383163b612cbd5760405162461bcd60e51b815260206004820152602660248201527f416464726573733a2064656c65676174652063616c6c20746f206e6f6e2d636f6044820152651b9d1c9858dd60d21b6064820152608401610da9565b600080846001600160a01b031684604051612cd891906139b5565b600060405180830381855af49150503d8060008114612d13576040519150601f19603f3d011682016040523d82523d6000602084013e612d18565b606091505b5091509150612d4082826040518060600160405280602781526020016139f260279139612ed8565b95945050505050565b6000808251604103612d7f5760208301516040840151606085015160001a612d7387828585612ef1565b94509450505050612d87565b506000905060025b9250929050565b6000816004811115612da257612da26134d1565b03612daa5750565b6001816004811115612dbe57612dbe6134d1565b03612e0b5760405162461bcd60e51b815260206004820152601860248201527f45434453413a20696e76616c6964207369676e617475726500000000000000006044820152606401610da9565b6002816004811115612e1f57612e1f6134d1565b03612e6c5760405162461bcd60e51b815260206004820152601f60248201527f45434453413a20696e76616c6964207369676e6174757265206c656e677468006044820152606401610da9565b6003816004811115612e8057612e806134d1565b03610e995760405162461bcd60e51b815260206004820152602260248201527f45434453413a20696e76616c6964207369676e6174757265202773272076616c604482015261756560f01b6064820152608401610da9565b60608315612ee7575081610b78565b610b788383612fb5565b6000807f7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0831115612f285750600090506003612fac565b6040805160008082526020820180845289905260ff881692820192909252606081018690526080810185905260019060a0016020604051602081039080840390855afa158015612f7c573d6000803e3d6000fd5b5050604051601f1901519150506001600160a01b038116612fa557600060019250925050612fac565b9150600090505b94509492505050565b815115612fc55781518083602001fd5b8060405162461bcd60e51b8152600401610da991906131d7565b828054612feb90613620565b90600052602060002090601f01602090048101928261300d5760008555613053565b82601f1061302657805160ff1916838001178555613053565b82800160010185558215613053579182015b82811115613053578251825591602001919060010190613038565b5061305f9291506130d7565b5090565b82805461306f90613620565b90600052602060002090601f0160209004810192826130915760008555613053565b82601f106130aa5782800160ff19823516178555613053565b82800160010185558215613053579182015b828111156130535782358255916020019190600101906130bc565b5b8082111561305f57600081556001016130d8565b80356001600160a01b038116811461310357600080fd5b919050565b60008060006060848603121561311d57600080fd5b613126846130ec565b92506020840135915060408401356003811061314157600080fd5b809150509250925092565b6001600160e01b031981168114610e9957600080fd5b60006020828403121561317457600080fd5b8135610b788161314c565b60005b8381101561319a578181015183820152602001613182565b838111156118555750506000910152565b600081518084526131c381602086016020860161317f565b601f01601f19169290920160200192915050565b602081526000610b7860208301846131ab565b6000602082840312156131fc57600080fd5b5035919050565b6000806040838503121561321657600080fd5b61321f836130ec565b946020939093013593505050565b634e487b7160e01b600052604160045260246000fd5b60006001600160401b038084111561325d5761325d61322d565b604051601f8501601f19908116603f011681019082821181831017156132855761328561322d565b8160405280935085815286868601111561329e57600080fd5b858560208301376000602087830101525050509392505050565b6000602082840312156132ca57600080fd5b81356001600160401b038111156132e057600080fd5b8201601f810184136132f157600080fd5b612b1184823560208401613243565b60008060006060848603121561331557600080fd5b61331e846130ec565b925061332c602085016130ec565b9150604084013590509250925092565b60006020828403121561334e57600080fd5b610b78826130ec565b600082601f83011261336857600080fd5b610b7883833560208501613243565b6000806040838503121561338a57600080fd5b613393836130ec565b915060208301356001600160401b038111156133ae57600080fd5b6133ba85828601613357565b9150509250929050565b8035801515811461310357600080fd5b600080600080608085870312156133ea57600080fd5b84356001600160401b0381111561340057600080fd5b61340c87828801613357565b9450506020850135925060408501359150613429606086016133c4565b905092959194509250565b6000806020838503121561344757600080fd5b82356001600160401b038082111561345e57600080fd5b818501915085601f83011261347257600080fd5b81358181111561348157600080fd5b86602082850101111561349357600080fd5b60209290920196919550909350505050565b600080604083850312156134b857600080fd5b823591506134c8602084016130ec565b90509250929050565b634e487b7160e01b600052602160045260246000fd5b602081016003831061350957634e487b7160e01b600052602160045260246000fd5b91905290565b6000806040838503121561352257600080fd5b61352b836130ec565b91506134c8602084016133c4565b6000806000806080858703121561354f57600080fd5b613558856130ec565b9350613566602086016130ec565b92506040850135915060608501356001600160401b0381111561358857600080fd5b61359487828801613357565b91505092959194509250565b6000806000606084860312156135b557600080fd5b83356001600160401b038111156135cb57600080fd5b6135d786828701613357565b935050602084013591506135ed604085016133c4565b90509250925092565b6000806040838503121561360957600080fd5b613612836130ec565b91506134c8602084016130ec565b600181811c9082168061363457607f821691505b60208210810361365457634e487b7160e01b600052602260045260246000fd5b50919050565b60208082526023908201527f596f752063616e206e6f74207472616e736665722061207374616b656420746f60408201526235b2b760e91b606082015260800190565b6020808252602c908201527f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060408201526b19195b1959d85d1958d85b1b60a21b606082015260800190565b6020808252602c908201527f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060408201526b6163746976652070726f787960a01b606082015260800190565b634e487b7160e01b600052601160045260246000fd5b600081600019048311821515161561376557613765613735565b500290565b60008261378757634e487b7160e01b600052601260045260246000fd5b500490565b60008282101561379e5761379e613735565b500390565b600082198211156137b6576137b6613735565b500190565b6020808252603c908201527f46756e6374696f6e2063616e206f6e6c792062652063616c6c65642066726f6d60408201527f207374616b696e6720636f6e74726f6c6c657220636f6e747261637400000000606082015260800190565b60208082526029908201527f4f726967696e61746f72206973206e6f7420746865206f776e6572206f6620746040820152683434b9903a37b5b2b760b91b606082015260800190565b6020808252602e908201527f436f6e747261637420696e7374616e63652068617320616c726561647920626560408201526d195b881a5b9a5d1a585b1a5e995960921b606082015260800190565b6000600182016138c1576138c1613735565b5060010190565b600083516138da81846020880161317f565b8351908301906138ee81836020880161317f565b01949350505050565b60006020828403121561390957600080fd5b5051919050565b6020808252602b908201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960408201526a6e697469616c697a696e6760a81b606082015260800190565b6001600160a01b038581168252841660208201526040810183905260806060820181905260009061398e908301846131ab565b9695505050505050565b6000602082840312156139aa57600080fd5b8151610b788161314c565b600082516139c781846020870161317f565b919091019291505056fe360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc416464726573733a206c6f772d6c6576656c2064656c65676174652063616c6c206661696c6564a264697066735822122033dfc38dd01fb615d7b276fa9c526d36c0df6ba506ac424259506664864d528b64736f6c634300080d0033
Deployed Bytecode
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
Deployed Bytecode Sourcemap
100094:8719:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;106157:370;;;;;;;;;;-1:-1:-1;106157:370:0;;;;;:::i;:::-;;:::i;:::-;;;754:25:1;;;742:2;727:18;106157:370:0;;;;;;;;58942:349;;;;;;;;;;-1:-1:-1;58942:349:0;;;;;:::i;:::-;;:::i;:::-;;;1341:14:1;;1334:22;1316:41;;1304:2;1289:18;58942:349:0;1176:187:1;62099:100:0;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;63602:204::-;;;;;;;;;;-1:-1:-1;63602:204:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;2468:32:1;;;2450:51;;2438:2;2423:18;63602:204:0;2304:203:1;63165:371:0;;;;;;;;;;-1:-1:-1;63165:371:0;;;;;:::i;:::-;;:::i;:::-;;100498:62;;;;;;;;;;;;100555:5;100498:62;;107605:126;;;;;;;;;;-1:-1:-1;107605:126:0;;;;;:::i;:::-;;:::i;58191:303::-;;;;;;;;;;-1:-1:-1;58445:12:0;;58429:13;;:28;58191:303;;108542:99;;;;;;;;;;;;;:::i;81452:295::-;;;;;;;;;;-1:-1:-1;81452:295:0;;;;;:::i;:::-;;:::i;100372:54::-;;;;;;;;;;;;100418:8;100372:54;;98510:200;;;;;;;;;;-1:-1:-1;98510:200:0;;;;;:::i;:::-;;:::i;107855:405::-;;;:::i;108433:101::-;;;;;;;;;;;;;:::i;81852:305::-;;;;;;;;;;-1:-1:-1;81852:305:0;;;;;:::i;:::-;;:::i;98969:225::-;;;;;;:::i;:::-;;:::i;103591:524::-;;;;;;:::i;:::-;;:::i;98188:133::-;;;;;;;;;;;;;:::i;107739:106::-;;;;;;;;;;-1:-1:-1;107739:106:0;;;;;:::i;:::-;;:::i;80216:397::-;;;;;;;;;;-1:-1:-1;80216:397:0;;;;;:::i;:::-;;:::i;101057:25::-;;;;;;;;;;-1:-1:-1;101057:25:0;;;;-1:-1:-1;;;101057:25:0;;;;;;;;;;;;;:::i;61907:125::-;;;;;;;;;;-1:-1:-1;61907:125:0;;;;;:::i;:::-;;:::i;100313:51::-;;;;;;;;;;;;100356:8;100313:51;;59355:206;;;;;;;;;;-1:-1:-1;59355:206:0;;;;;:::i;:::-;;:::i;77785:32::-;;;;;;;;;;-1:-1:-1;77785:32:0;;;;;;;-1:-1:-1;;;;;77785:32:0;;;84704:103;;;;;;;;;;;;;:::i;101541:341::-;;;;;;;;;;;;;:::i;107198:167::-;;;;;;;;;;;;;:::i;84056:87::-;;;;;;;;;;-1:-1:-1;84129:6:0;;-1:-1:-1;;;;;84129:6:0;84056:87;;105981:168;;;;;;;;;;-1:-1:-1;105981:168:0;;;;;:::i;:::-;;:::i;:::-;;;;7588:13:1;;-1:-1:-1;;;;;7584:39:1;7566:58;;7684:4;7672:17;;;7666:24;-1:-1:-1;;;;;7662:49:1;7640:20;;;7633:79;7770:17;;;7764:24;7757:32;7750:40;7728:20;;;7721:70;7554:2;7539:18;105981:168:0;7356:441:1;101350:54:0;;;;;;;;;;-1:-1:-1;101350:54:0;;;;;:::i;:::-;;;;;;;;;;;;;;62268:104;;;;;;;;;;;;;:::i;79603:393::-;;;;;;;;;;-1:-1:-1;79603:393:0;;;;;:::i;:::-;;:::i;107375:222::-;;;;;;;;;;-1:-1:-1;107375:222:0;;;;;:::i;:::-;;:::i;63878:287::-;;;;;;;;;;-1:-1:-1;63878:287:0;;;;;:::i;:::-;;:::i;100434:56::-;;;;;;;;;;;;100485:5;100434:56;;78053:47;;;;;;;;;;-1:-1:-1;78053:47:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;101185:42;;;;;;;;;;-1:-1:-1;101185:42:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;106765:425;;;;;;;;;;-1:-1:-1;106765:425:0;;;;;:::i;:::-;;:::i;82262:339::-;;;;;;;;;;-1:-1:-1;82262:339:0;;;;;:::i;:::-;;:::i;78600:112::-;;;;;;;;;;-1:-1:-1;78600:112:0;;;;;:::i;:::-;78656:4;78680:24;;;:15;:24;;;;;;;;;78600:112;101115:28;;;;;;;;;;;;;:::i;62443:318::-;;;;;;;;;;-1:-1:-1;62443:318:0;;;;;:::i;:::-;;:::i;108649:88::-;;;;;;;;;;;;;:::i;103164:419::-;;;;;;;;;;-1:-1:-1;103164:419:0;;;;;:::i;:::-;;:::i;100894:48::-;;;;;;;;;;;;100932:10;100894:48;;104123:521;;;;;;:::i;:::-;;:::i;105860:113::-;;;;;;;;;;-1:-1:-1;105860:113:0;;;;;:::i;:::-;;:::i;108268:157::-;;;;;;;;;;-1:-1:-1;108268:157:0;;;;;:::i;:::-;;:::i;101292:51::-;;;;;;;;;;-1:-1:-1;101292:51:0;;;;;:::i;:::-;;;;;;;;;;;;;;105683:135;;;;;;;;;;-1:-1:-1;105683:135:0;;;;;:::i;:::-;;:::i;101411:53::-;;;;;;;;;;-1:-1:-1;101411:53:0;;;;;:::i;:::-;;;;;;;;;;;;;;64236:164;;;;;;;;;;-1:-1:-1;64236:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;64357:25:0;;;64333:4;64357:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;64236:164;106564:193;;;;;;;;;;-1:-1:-1;106564:193:0;;;;;:::i;:::-;;:::i;84962:201::-;;;;;;;;;;-1:-1:-1;84962:201:0;;;;;:::i;:::-;;:::i;100673:45::-;;;;;;;;;;;;100715:3;100673:45;;100996:32;;;;;;;;;;-1:-1:-1;100996:32:0;;;;-1:-1:-1;;;;;100996:32:0;;;106157:370;106251:7;106271:12;106425:7;106434:6;106450:8;106442:17;;;;;;;;:::i;:::-;106408:52;;9719:2:1;9715:15;;;;-1:-1:-1;;9711:53:1;106408:52:0;;;9699:66:1;9781:12;;;9774:28;;;;9818:12;;;9811:28;9855:12;;106408:52:0;;;-1:-1:-1;;106408:52:0;;;;;;;;;;106398:63;;106408:52;106398:63;;;;10120:66:1;106310:166:0;;;10108:79:1;;;;10203:12;;;10196:28;10240:12;;106310:166:0;;;-1:-1:-1;;106310:166:0;;;;;;;;;106286:201;;106310:166;106286:201;;;;;-1:-1:-1;;106157:370:0;;;;;;:::o;58942:349::-;59066:4;-1:-1:-1;;;;;;59103:51:0;;-1:-1:-1;;;59103:51:0;;:127;;-1:-1:-1;;;;;;;59171:59:0;;-1:-1:-1;;;59171:59:0;59103:127;:180;;;-1:-1:-1;;;;;;;;;;52593:51:0;;;59247:36;59083:200;58942:349;-1:-1:-1;;58942:349:0:o;62099:100::-;62153:13;62186:5;62179:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62099:100;:::o;63602:204::-;63670:7;63695:16;63703:7;63695;:16::i;:::-;63690:64;;63720:34;;-1:-1:-1;;;63720:34:0;;;;;;;;;;;63690:64;-1:-1:-1;63774:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;63774:24:0;;63602:204::o;63165:371::-;63238:13;63254:24;63270:7;63254:15;:24::i;:::-;63238:40;;63299:5;-1:-1:-1;;;;;63293:11:0;:2;-1:-1:-1;;;;;63293:11:0;;63289:48;;63313:24;;-1:-1:-1;;;63313:24:0;;;;;;;;;;;63289:48;53913:10;-1:-1:-1;;;;;63354:21:0;;;;;;:63;;-1:-1:-1;63380:37:0;63397:5;53913:10;64236:164;:::i;63380:37::-;63379:38;63354:63;63350:138;;;63441:35;;-1:-1:-1;;;63441:35:0;;;;;;;;;;;63350:138;63500:28;63509:2;63513:7;63522:5;63500:8;:28::i;:::-;63227:309;63165:371;;:::o;107605:126::-;83942:13;:11;:13::i;:::-;107691:32;;::::1;::::0;:14:::1;::::0;:32:::1;::::0;::::1;::::0;::::1;:::i;:::-;;107605:126:::0;:::o;108542:99::-;83942:13;:11;:13::i;:::-;108600:9:::1;:33:::0;;108612:21:::1;::::0;108600:9;-1:-1:-1;;;;108600:33:0::1;-1:-1:-1::0;;;108612:21:0;108600:33:::1;;;;;;108542:99::o:0;81452:295::-;78656:4;78680:24;;;:15;:24;;;;;;;;81600:26;81578:111;;;;-1:-1:-1;;;81578:111:0;;;;;;;:::i;:::-;;;;;;;;;81702:37;81721:4;81727:2;81731:7;81702:18;:37::i;98510:200::-;-1:-1:-1;;;;;97058:6:0;97041:23;97049:4;97041:23;97033:80;;;;-1:-1:-1;;;97033:80:0;;;;;;;:::i;:::-;97156:6;-1:-1:-1;;;;;97132:30:0;:20;-1:-1:-1;;;;;;;;;;;88840:65:0;-1:-1:-1;;;;;88840:65:0;;88760:153;97132:20;-1:-1:-1;;;;;97132:30:0;;97124:87;;;;-1:-1:-1;;;97124:87:0;;;;;;;:::i;:::-;98594:36:::1;98612:17;98594;:36::i;:::-;98682:12;::::0;;98692:1:::1;98682:12:::0;;;::::1;::::0;::::1;::::0;;;98641:61:::1;::::0;98663:17;;98682:12;98641:21:::1;:61::i;:::-;98510:200:::0;:::o;107855:405::-;83942:13;:11;:13::i;:::-;107963:7:::1;107984:42;108068:3;108040:25;:21;108064:1;108040:25;:::i;:::-;:31;;;;:::i;:::-;107976:100;::::0;::::1;::::0;;;;;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;107962:114;;;108091:2;108083:11;;;::::0;::::1;;108168:7;108189;84129:6:::0;;-1:-1:-1;;;;;84129:6:0;;84056:87;108189:7:::1;-1:-1:-1::0;;;;;108181:21:0::1;108210;108181:55;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;108167:69;;;108251:2;108243:11;;;::::0;::::1;108433:101:::0;83942:13;:11;:13::i;:::-;108494:9:::1;:32:::0;;108506:20:::1;::::0;108494:9;-1:-1:-1;;;;108494:32:0::1;-1:-1:-1::0;;;108506:20:0;108494:32:::1;::::0;81852:305;78656:4;78680:24;;;:15;:24;;;;;;;;82004:26;81982:111;;;;-1:-1:-1;;;81982:111:0;;;;;;;:::i;:::-;82104:45;82127:4;82133:2;82137:7;82104:45;;;;;;;;;;;;:22;:45::i;98969:225::-;-1:-1:-1;;;;;97058:6:0;97041:23;97049:4;97041:23;97033:80;;;;-1:-1:-1;;;97033:80:0;;;;;;;:::i;:::-;97156:6;-1:-1:-1;;;;;97132:30:0;:20;-1:-1:-1;;;;;;;;;;;88840:65:0;-1:-1:-1;;;;;88840:65:0;;88760:153;97132:20;-1:-1:-1;;;;;97132:30:0;;97124:87;;;;-1:-1:-1;;;97124:87:0;;;;;;;:::i;:::-;99087:36:::1;99105:17;99087;:36::i;:::-;99134:52;99156:17;99175:4;99181;99134:21;:52::i;103591:524::-:0;101958:9;101971:10;101958:23;101955:60;;101990:25;;-1:-1:-1;;;101990:25:0;;;;;;;;;;;101955:60;102103:21:::1;102090:9;::::0;-1:-1:-1;;;102090:9:0;::::1;;;:34;::::0;::::1;;;;;;:::i;:::-;;102087:66;;102133:20;;-1:-1:-1::0;;;102133:20:0::1;;;;;;;;;;;102087:66;103794:9:::0;102566:38:::2;100418:8;100356;102566:38;:::i;:::-;102554:9;102537:14;58820:13:::0;;;58587:283;102537:14:::2;:26;;;;:::i;:::-;:67;102532:112;;102614:30;;-1:-1:-1::0;;;102614:30:0::2;;;;;;;;;;;102532:112;103862:10:::3;103842:31;::::0;;;:19:::3;:31;::::0;;;;;;103875:9;;100555:5:::3;::::0;102995:33:::3;103875:9:::0;103842:31;102995:33:::3;:::i;:::-;102971:57;;103060:10;103044:13;:26;103039:71;;103080:30;;-1:-1:-1::0;;;103080:30:0::3;;;;;;;;;;;103039:71;103945:9:::0;102399:23:::4;103945:9:::0;100932:10:::4;102399:23;:::i;:::-;102386:9;:36;;102381:69;;102432:18;;-1:-1:-1::0;;;102432:18:0::4;;;;;;;;;;;102381:69;103973:79:::5;103989:10;104001:9;104012:6;104020:21;104043:8;103973:15;:79::i;:::-;104083:10;104063:31;::::0;;;:19:::5;:31;::::0;;;;:44;;104098:9;;104063:31;:44:::5;::::0;104098:9;;104063:44:::5;:::i;:::-;::::0;;;-1:-1:-1;;;;;;;;;;;;103591:524:0:o;98188:133::-;98266:7;97494:4;-1:-1:-1;;;;;97503:6:0;97486:23;;97478:92;;;;-1:-1:-1;;;97478:92:0;;13212:2:1;97478:92:0;;;13194:21:1;13251:2;13231:18;;;13224:30;13290:34;13270:18;;;13263:62;13361:26;13341:18;;;13334:54;13405:19;;97478:92:0;13010:420:1;97478:92:0;-1:-1:-1;;;;;;;;;;;;98188:133:0;:::o;107739:106::-;83942:13;:11;:13::i;:::-;107814:23:::1;:13;107830:7:::0;;107814:23:::1;:::i;80216:397::-:0;80338:17;;;;;-1:-1:-1;;;;;80338:17:0;80324:10;:31;80302:141;;;;-1:-1:-1;;;80302:141:0;;;;;;;:::i;:::-;80496:10;-1:-1:-1;;;;;80476:30:0;:16;80484:7;80476;:16::i;:::-;-1:-1:-1;;;;;80476:30:0;;80454:121;;;;-1:-1:-1;;;80454:121:0;;;;;;;:::i;:::-;80588:17;80597:7;80588:8;:17::i;61907:125::-;61971:7;61998:21;62011:7;61998:12;:21::i;:::-;:26;;61907:125;-1:-1:-1;;61907:125:0:o;59355:206::-;59419:7;-1:-1:-1;;;;;59443:19:0;;59439:60;;59471:28;;-1:-1:-1;;;59471:28:0;;;;;;;;;;;59439:60;-1:-1:-1;;;;;;59525:19:0;;;;;:12;:19;;;;;:27;-1:-1:-1;;;;;59525:27:0;;59355:206::o;84704:103::-;83942:13;:11;:13::i;:::-;84769:30:::1;84796:1;84769:18;:30::i;:::-;84704:103::o:0;101541:341::-;47969:19;47992:13;;;;;;47991:14;;48039:34;;;;-1:-1:-1;48057:12:0;;48072:1;48057:12;;;;:16;48039:34;48038:108;;;-1:-1:-1;48118:4:0;37625:19;:23;;;48079:66;;-1:-1:-1;48128:12:0;;;;;:17;48079:66;48016:204;;;;-1:-1:-1;;;48016:204:0;;14476:2:1;48016:204:0;;;14458:21:1;14515:2;14495:18;;;14488:30;14554:34;14534:18;;;14527:62;-1:-1:-1;;;14605:18:1;;;14598:44;14659:19;;48016:204:0;14274:410:1;48016:204:0;48231:12;:16;;-1:-1:-1;;48231:16:0;48246:1;48231:16;;;48258:67;;;;48293:13;:20;;-1:-1:-1;;48293:20:0;;;;;48258:67;101602:11:::1;::::0;::::1;;101601:12;101593:71;;;;-1:-1:-1::0;;;101593:71:0::1;;;;;;;:::i;:::-;101675:11;:18:::0;;-1:-1:-1;;101675:18:0::1;101689:4;101675:18;::::0;;101704:26:::1;:24;:26::i;:::-;101741:48;;;;;;;;;;;;;;-1:-1:-1::0;;;101741:48:0::1;;::::0;::::1;;;;;;;;;;;;;-1:-1:-1::0;;;101741:48:0::1;;::::0;:20:::1;:48::i;:::-;101800:34;:32;:34::i;:::-;101845:9;:29:::0;;-1:-1:-1;;;;101845:29:0::1;::::0;;48347:102;;;;48398:5;48382:21;;-1:-1:-1;;48382:21:0;;;48423:14;;-1:-1:-1;15256:36:1;;48423:14:0;;15244:2:1;15229:18;48423:14:0;;;;;;;;47958:498;101541:341::o;107198:167::-;83942:13;:11;:13::i;:::-;100715:3:::1;100356:8;102756:9;102739:14;58820:13:::0;;;58587:283;102739:14:::1;:26;;;;:::i;:::-;:45;102734:90;;102794:30;;-1:-1:-1::0;;;102794:30:0::1;;;;;;;;;;;102734:90;107312:45:::2;107318:10;100715:3;107312:45;;;;;;;;;;;::::0;107351:5:::2;107312;:45::i;105981:168::-:0;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;106120:21:0;106133:7;106120:12;:21::i;62268:104::-;62324:13;62357:7;62350:14;;;;;:::i;79603:393::-;79723:17;;;;;-1:-1:-1;;;;;79723:17:0;79709:10;:31;79687:141;;;;-1:-1:-1;;;79687:141:0;;;;;;;:::i;:::-;79881:10;-1:-1:-1;;;;;79861:30:0;:16;79869:7;79861;:16::i;:::-;-1:-1:-1;;;;;79861:30:0;;79839:121;;;;-1:-1:-1;;;79839:121:0;;;;;;;:::i;:::-;79973:15;79980:7;79973:6;:15::i;107375:222::-;83942:13;:11;:13::i;:::-;107515::::1;100356:8;102756:9;102739:14;58820:13:::0;;;58587:283;102739:14:::1;:26;;;;:::i;:::-;:45;102734:90;;102794:30;;-1:-1:-1::0;;;102794:30:0::1;;;;;;;;;;;102734:90;107546:43:::2;107552:10;107564:13;107546:43;;;;;;;;;;;::::0;107583:5:::2;107546;:43::i;63878:287::-:0;53913:10;-1:-1:-1;;;;;63977:24:0;;;63973:54;;64010:17;;-1:-1:-1;;;64010:17:0;;;;;;;;;;;63973:54;53913:10;64040:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;64040:42:0;;;;;;;;;;;;:53;;-1:-1:-1;;64040:53:0;;;;;;;;;;64109:48;;1316:41:1;;;64040:42:0;;53913:10;64109:48;;1289:18:1;64109:48:0;;;;;;;63878:287;;:::o;106765:425::-;83942:13;:11;:13::i;:::-;106884::::1;100356:8;102756:9;102739:14;58820:13:::0;;;58587:283;102739:14:::1;:26;;;;:::i;:::-;:45;102734:90;;102794:30;;-1:-1:-1::0;;;102794:30:0::1;;;;;;;;;;;102734:90;106915:18:::2;106936:13;;106915:34;;106960:43;106966:10;106978:13;106960:43;;;;;;;;;;;::::0;106997:5:::2;106960;:43::i;:::-;107032:10:::0;107016:167:::2;107048:26;107061:13:::0;107048:10;:26:::2;:::i;:::-;107044:1;:30;107016:167;;;107115:17;::::0;107096:75:::2;::::0;-1:-1:-1;;;107096:75:0;;::::2;::::0;::::2;15477:25:1::0;;;107160:10:0::2;15518:18:1::0;;;15511:60;107115:17:0::2;::::0;;::::2;-1:-1:-1::0;;;;;107115:17:0::2;::::0;107096:60:::2;::::0;15450:18:1;;107096:75:0::2;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;107076:3;;;;;:::i;:::-;;;;107016:167;;;;106904:286;83966:1:::1;106765:425:::0;:::o;82262:339::-;78656:4;78680:24;;;:15;:24;;;;;;;;82443:26;82421:111;;;;-1:-1:-1;;;82421:111:0;;;;;;;:::i;:::-;82545:48;82568:4;82574:2;82578:7;82587:5;82545:22;:48::i;101115:28::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;62443:318::-;62516:13;62547:16;62555:7;62547;:16::i;:::-;62542:59;;62572:29;;-1:-1:-1;;;62572:29:0;;;;;;;;;;;62542:59;62614:21;62638:10;:8;:10::i;:::-;62614:34;;62672:7;62666:21;62691:1;62666:26;:87;;;;;;;;;;;;;;;;;62719:7;62728:18;:7;:16;:18::i;:::-;62702:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;62659:94;62443:318;-1:-1:-1;;;62443:318:0:o;108649:88::-;83942:13;:11;:13::i;:::-;108700:9:::1;:29:::0;;108712:17:::1;::::0;108700:9;-1:-1:-1;;;;108700:29:0::1;-1:-1:-1::0;;;108712:17:0;108700:29:::1;::::0;103164:419;101958:9;101971:10;101958:23;101955:60;;101990:25;;-1:-1:-1;;;101990:25:0;;;;;;;;;;;101955:60;102103:21:::1;102090:9;::::0;-1:-1:-1;;;102090:9:0;::::1;;;:34;::::0;::::1;;;;;;:::i;:::-;;102087:66;;102133:20;;-1:-1:-1::0;;;102133:20:0::1;;;;;;;;;;;102087:66;103345:1:::2;100356:8;102756:9;102739:14;58820:13:::0;;;58587:283;102739:14:::2;:26;;;;:::i;:::-;:45;102734:90;;102794:30;;-1:-1:-1::0;;;102794:30:0::2;;;;;;;;;;;102734:90;103402:10:::3;103385:28;::::0;;;:16:::3;:28;::::0;;;;;;103415:1:::3;::::0;100485:5:::3;::::0;102995:33:::3;103415:1:::0;103385:28;102995:33:::3;:::i;:::-;102971:57;;103060:10;103044:13;:26;103039:71;;103080:30;;-1:-1:-1::0;;;103080:30:0::3;;;;;;;;;;;103039:71;103460::::4;103476:10;103488:1;103491:6;103499:21;103522:8;103460:15;:71::i;:::-;103559:10;103542:28;::::0;;;:16:::4;:28;::::0;;;;:33;;103574:1:::4;::::0;103542:28;:33:::4;::::0;103574:1;;103542:33:::4;:::i;:::-;::::0;;;-1:-1:-1;;;;;;;;;;103164:419:0:o;104123:521::-;101958:9;101971:10;101958:23;101955:60;;101990:25;;-1:-1:-1;;;101990:25:0;;;;;;;;;;;101955:60;102244:20:::1;102231:9;::::0;-1:-1:-1;;;102231:9:0;::::1;;;:33;::::0;::::1;;;;;;:::i;:::-;;102228:68;;102273:23;;-1:-1:-1::0;;;102273:23:0::1;;;;;;;;;;;102228:68;104328:9:::0;102566:38:::2;100418:8;100356;102566:38;:::i;:::-;102554:9;102537:14;58820:13:::0;;;58587:283;102537:14:::2;:26;;;;:::i;:::-;:67;102532:112;;102614:30;;-1:-1:-1::0;;;102614:30:0::2;;;;;;;;;;;102532:112;104396:10:::3;104377:30;::::0;;;:18:::3;:30;::::0;;;;;;104409:9;;100621:5:::3;::::0;102995:33:::3;104409:9:::0;104377:30;102995:33:::3;:::i;:::-;102971:57;;103060:10;103044:13;:26;103039:71;;103080:30;;-1:-1:-1::0;;;103080:30:0::3;;;;;;;;;;;103039:71;104475:9:::0;102399:23:::4;104475:9:::0;100932:10:::4;102399:23;:::i;:::-;102386:9;:36;;102381:69;;102432:18;;-1:-1:-1::0;;;102432:18:0::4;;;;;;;;;;;102381:69;104503:79:::5;104519:10;104531:9;104542:6;104551:20;104573:8;104503:15;:79::i;:::-;104612:10;104593:30;::::0;;;:18:::5;:30;::::0;;;;:43;;104627:9;;104593:30;:43:::5;::::0;104627:9;;104593:43:::5;:::i;105860:113::-:0;-1:-1:-1;;;;;59739:19:0;;105918:7;59739:19;;;:12;:19;;;;;:32;-1:-1:-1;;;59739:32:0;;-1:-1:-1;;;;;59739:32:0;105945:20;59643:137;108268:157;83942:13;:11;:13::i;:::-;108379:17:::1;:38:::0;;-1:-1:-1;;;;;;108379:38:0::1;-1:-1:-1::0;;;;;108379:38:0;;;::::1;::::0;;;::::1;::::0;;108268:157::o;105683:135::-;83942:13;:11;:13::i;:::-;78470:17;:38;;-1:-1:-1;;;;;;78470:38:0;;-1:-1:-1;;;;;78470:38:0;;;;;;98510:200;:::o;106564:193::-;83942:13;:11;:13::i;:::-;106675::::1;100356:8;102756:9;102739:14;58820:13:::0;;;58587:283;102739:14:::1;:26;;;;:::i;:::-;:45;102734:90;;102794:30;;-1:-1:-1::0;;;102794:30:0::1;;;;;;;;;;;102734:90;106706:43:::2;106712:10;106724:13;106706:43;;;;;;;;;;;::::0;106743:5:::2;106706;:43::i;84962:201::-:0;83942:13;:11;:13::i;:::-;-1:-1:-1;;;;;85051:22:0;::::1;85043:73;;;::::0;-1:-1:-1;;;85043:73:0;;16399:2:1;85043:73:0::1;::::0;::::1;16381:21:1::0;16438:2;16418:18;;;16411:30;16477:34;16457:18;;;16450:62;-1:-1:-1;;;16528:18:1;;;16521:36;16574:19;;85043:73:0::1;16197:402:1::0;85043:73:0::1;85127:28;85146:8;85127:18;:28::i;65588:187::-:0;65645:4;65709:13;;65699:7;:23;65669:98;;;;-1:-1:-1;;65740:20:0;;;;:11;:20;;;;;:27;-1:-1:-1;;;65740:27:0;;;;65739:28;;65588:187::o;73758:196::-;73873:24;;;;:15;:24;;;;;;:29;;-1:-1:-1;;;;;;73873:29:0;-1:-1:-1;;;;;73873:29:0;;;;;;;;;73918:28;;73873:24;;73918:28;;;;;;;73758:196;;;:::o;84221:132::-;84129:6;;-1:-1:-1;;;;;84129:6:0;53913:10;84285:23;84277:68;;;;-1:-1:-1;;;84277:68:0;;16806:2:1;84277:68:0;;;16788:21:1;;;16825:18;;;16818:30;16884:34;16864:18;;;16857:62;16936:18;;84277:68:0;16604:356:1;64467:170:0;64601:28;64611:4;64617:2;64621:7;64601:9;:28::i;108744:66::-;83942:13;:11;:13::i;90178:992::-;88131:66;90632:59;;;90628:535;;;90708:37;90727:17;90708:18;:37::i;90628:535::-;90811:17;-1:-1:-1;;;;;90782:61:0;;:63;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;90782:63:0;;;;;;;;-1:-1:-1;;90782:63:0;;;;;;;;;;;;:::i;:::-;;;90778:306;;91012:56;;-1:-1:-1;;;91012:56:0;;17356:2:1;91012:56:0;;;17338:21:1;17395:2;17375:18;;;17368:30;17434:34;17414:18;;;17407:62;-1:-1:-1;;;17485:18:1;;;17478:44;17539:19;;91012:56:0;17154:410:1;90778:306:0;-1:-1:-1;;;;;;;;;;;90896:28:0;;90888:82;;;;-1:-1:-1;;;90888:82:0;;17771:2:1;90888:82:0;;;17753:21:1;17810:2;17790:18;;;17783:30;17849:34;17829:18;;;17822:62;-1:-1:-1;;;17900:18:1;;;17893:39;17949:19;;90888:82:0;17569:405:1;90888:82:0;90846:140;91098:53;91116:17;91135:4;91141:9;91098:17;:53::i;64964:369::-;65131:28;65141:4;65147:2;65151:7;65131:9;:28::i;:::-;-1:-1:-1;;;;;65174:13:0;;37625:19;:23;;65174:76;;;;;65194:56;65225:4;65231:2;65235:7;65244:5;65194:30;:56::i;:::-;65193:57;65174:76;65170:156;;;65274:40;;-1:-1:-1;;;65274:40:0;;;;;;;;;;;104652:767;104806:19;104828:41;104840:10;104852:6;104860:8;104828:11;:41::i;:::-;104901:13;;104965:17;;104806:63;;-1:-1:-1;104901:13:0;-1:-1:-1;;;;;104965:17:0;104930:31;104806:63;104950:10;104930:19;:31::i;:::-;-1:-1:-1;;;;;104930:52:0;;104927:85;;104991:21;;-1:-1:-1;;;104991:21:0;;;;;;;;;;;104927:85;105026:23;;;;:10;:23;;;;;;;;:31;;:23;:31;105023:63;;105066:20;;-1:-1:-1;;;105066:20:0;;;;;;;;;;;105023:63;105099:23;;;;:10;:23;;;;;;;;:30;;-1:-1:-1;;105099:30:0;105125:4;105099:30;;;105142:39;;;;;;;;;;;;105148:10;;105160:9;;105142:5;:39::i;:::-;105205:8;105202:210;;;105246:10;105230:171;105262:22;105275:9;105262:10;:22;:::i;:::-;105258:1;:26;105230:171;;;105329:17;;105310:75;;-1:-1:-1;;;105310:75:0;;;;;15477:25:1;;;105374:10:0;15518:18:1;;;15511:60;105329:17:0;;;;-1:-1:-1;;;;;105329:17:0;;105310:60;;15450:18:1;;105310:75:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;105286:3;;;;;:::i;:::-;;;;105230:171;;;;105202:210;104795:624;;104652:767;;;;;:::o;79195:189::-;78656:4;78680:24;;;:15;:24;;;;;;;;79250:48;;;;-1:-1:-1;;;79250:48:0;;18181:2:1;79250:48:0;;;18163:21:1;18220:2;18200:18;;;18193:30;-1:-1:-1;;;18239:18:1;;;18232:48;18297:18;;79250:48:0;17979:342:1;79250:48:0;79338:5;79311:24;;;:15;:24;;;;;;;:32;;-1:-1:-1;;79311:32:0;;;79359:17;;;;;79327:7;754:25:1;;742:2;727:18;;608:177;60736:1109:0;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;60847:7:0;60930:13;;60923:4;:20;60892:886;;;60964:31;60998:17;;;:11;:17;;;;;;;;;60964:51;;;;;;;;;-1:-1:-1;;;;;60964:51:0;;;;-1:-1:-1;;;60964:51:0;;-1:-1:-1;;;;;60964:51:0;;;;;;;;-1:-1:-1;;;60964:51:0;;;;;;;;;;;;;;61034:729;;61084:14;;-1:-1:-1;;;;;61084:28:0;;61080:101;;61148:9;60736:1109;-1:-1:-1;;;60736:1109:0:o;61080:101::-;-1:-1:-1;;;61523:6:0;61568:17;;;;:11;:17;;;;;;;;;61556:29;;;;;;;;;-1:-1:-1;;;;;61556:29:0;;;;;-1:-1:-1;;;61556:29:0;;-1:-1:-1;;;;;61556:29:0;;;;;;;;-1:-1:-1;;;61556:29:0;;;;;;;;;;;;;61616:28;61612:109;;61684:9;60736:1109;-1:-1:-1;;;60736:1109:0:o;61612:109::-;61483:261;;;60945:833;60892:886;61806:31;;-1:-1:-1;;;61806:31:0;;;;;;;;;;;85323:191;85416:6;;;-1:-1:-1;;;;;85433:17:0;;;-1:-1:-1;;;;;;85433:17:0;;;;;;;85466:40;;85416:6;;;85433:17;85416:6;;85466:40;;85397:16;;85466:40;85386:128;85323:191;:::o;83704:113::-;50112:13;;;;;;;50104:69;;;;-1:-1:-1;;;50104:69:0;;;;;;;:::i;:::-;83777:32:::1;53913:10:::0;83777:18:::1;:32::i;57556:312::-:0;50112:13;;;;;;;50104:69;;;;-1:-1:-1;;;50104:69:0;;;;;;;:::i;:::-;57675:11:::1;::::0;::::1;;57674:12;57666:71;;;;-1:-1:-1::0;;;57666:71:0::1;;;;;;;:::i;:::-;57748:11;:18:::0;;-1:-1:-1;;57748:18:0::1;57762:4;57748:18;::::0;;57777:13;;::::1;::::0;:5:::1;::::0;:13:::1;::::0;::::1;::::0;::::1;:::i;:::-;-1:-1:-1::0;57801:17:0;;::::1;::::0;:7:::1;::::0;:17:::1;::::0;::::1;::::0;::::1;:::i;:::-;-1:-1:-1::0;58021:7:0;57829:13:::1;:31:::0;-1:-1:-1;;57556:312:0:o;96262:78::-;50112:13;;;;;;;50104:69;;;;-1:-1:-1;;;50104:69:0;;;;;;;:::i;66672:1775::-;66834:13;;-1:-1:-1;;;;;66862:16:0;;66858:48;;66887:19;;-1:-1:-1;;;66887:19:0;;;;;;;;;;;66858:48;66921:8;66933:1;66921:13;66917:44;;66943:18;;-1:-1:-1;;;66943:18:0;;;;;;;;;;;66917:44;-1:-1:-1;;;;;67312:16:0;;;;;;:12;:16;;;;;;;;:44;;-1:-1:-1;;67371:49:0;;-1:-1:-1;;;;;67312:44:0;;;;;;;67371:49;;;-1:-1:-1;;;;;67312:44:0;;;;;;67371:49;;;;;;;;;;;;;;;;67437:25;;;:11;:25;;;;;;:35;;-1:-1:-1;;;;;;67487:66:0;;;;-1:-1:-1;;;67537:15:0;67487:66;;;;;;;;;;67437:25;67634:23;;;67678:4;:23;;;;-1:-1:-1;;;;;;67686:13:0;;37625:19;:23;;67686:15;67674:641;;;67722:314;67753:38;;67778:12;;-1:-1:-1;;;;;67753:38:0;;;67770:1;;67753:38;;67770:1;;67753:38;67819:69;67858:1;67862:2;67866:14;;;;;;67882:5;67819:30;:69::i;:::-;67814:174;;67924:40;;-1:-1:-1;;;67924:40:0;;;;;;;;;;;67814:174;68031:3;68015:12;:19;67722:314;;68117:12;68100:13;;:29;68096:43;;68131:8;;;68096:43;67674:641;;;68180:120;68211:40;;68236:14;;;;;-1:-1:-1;;;;;68211:40:0;;;68228:1;;68211:40;;68228:1;;68211:40;68295:3;68279:12;:19;68180:120;;67674:641;-1:-1:-1;68329:13:0;:28;68379:60;66800:1647;66672:1775;;;;:::o;78855:190::-;78656:4;78680:24;;;:15;:24;;;;;;;;78916:18;78908:54;;;;-1:-1:-1;;;78908:54:0;;18940:2:1;78908:54:0;;;18922:21:1;18979:2;18959:18;;;18952:30;19018:25;18998:18;;;18991:53;19061:18;;78908:54:0;18738:347:1;78908:54:0;78975:24;;;;:15;:24;;;;;;;:31;;-1:-1:-1;;78975:31:0;79002:4;78975:31;;;79022:15;;;;;78991:7;754:25:1;;742:2;727:18;;608:177;105460:114:0;105520:13;105553;105546:20;;;;;:::i;22509:727::-;22565:13;22616:14;22633:28;22655:5;22633:21;:28::i;:::-;22664:1;22633:32;22616:49;;22680:20;22714:6;-1:-1:-1;;;;;22703:18:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;22703:18:0;-1:-1:-1;22680:41:0;-1:-1:-1;22845:28:0;;;22861:2;22845:28;22902:288;-1:-1:-1;;22934:5:0;-1:-1:-1;;;23071:2:0;23060:14;;23055:30;22934:5;23042:44;23132:2;23123:11;;;-1:-1:-1;23153:21:0;22902:288;23153:21;-1:-1:-1;23211:6:0;22509:727;-1:-1:-1;;;22509:727:0:o;68701:2130::-;68816:35;68854:21;68867:7;68854:12;:21::i;:::-;68816:59;;68914:4;-1:-1:-1;;;;;68892:26:0;:13;:18;;;-1:-1:-1;;;;;68892:26:0;;68888:67;;68927:28;;-1:-1:-1;;;68927:28:0;;;;;;;;;;;68888:67;68968:22;53913:10;-1:-1:-1;;;;;68994:20:0;;;;:73;;-1:-1:-1;69031:36:0;69048:4;53913:10;64236:164;:::i;69031:36::-;68994:126;;;-1:-1:-1;53913:10:0;69084:20;69096:7;69084:11;:20::i;:::-;-1:-1:-1;;;;;69084:36:0;;68994:126;68968:153;;69139:17;69134:66;;69165:35;;-1:-1:-1;;;69165:35:0;;;;;;;;;;;69134:66;-1:-1:-1;;;;;69215:16:0;;69211:52;;69240:23;;-1:-1:-1;;;69240:23:0;;;;;;;;;;;69211:52;69384:35;69401:1;69405:7;69414:4;69384:8;:35::i;:::-;-1:-1:-1;;;;;69715:18:0;;;;;;;:12;:18;;;;;;;;:31;;-1:-1:-1;;69715:31:0;;;-1:-1:-1;;;;;69715:31:0;;;-1:-1:-1;;69715:31:0;;;;;;;69761:16;;;;;;;;;:29;;;;;;;;-1:-1:-1;69761:29:0;;;;;;;;;;;69841:20;;;:11;:20;;;;;;69876:18;;-1:-1:-1;;;;;;69909:49:0;;;;-1:-1:-1;;;69942:15:0;69909:49;;;;;;;;;;70232:11;;70292:24;;;;;70335:13;;69841:20;;70292:24;;70335:13;70331:384;;70545:13;;70530:11;:28;70526:174;;70583:20;;70652:28;;;;-1:-1:-1;;;;;70626:54:0;-1:-1:-1;;;70626:54:0;-1:-1:-1;;;;;;70626:54:0;;;-1:-1:-1;;;;;70583:20:0;;70626:54;;;;70526:174;69690:1036;;;70762:7;70758:2;-1:-1:-1;;;;;70743:27:0;70752:4;-1:-1:-1;;;;;70743:27:0;;;;;;;;;;;70781:42;106765:425;89009:284;-1:-1:-1;;;;;37625:19:0;;;89083:106;;;;-1:-1:-1;;;89083:106:0;;19292:2:1;89083:106:0;;;19274:21:1;19331:2;19311:18;;;19304:30;19370:34;19350:18;;;19343:62;-1:-1:-1;;;19421:18:1;;;19414:43;19474:19;;89083:106:0;19090:409:1;89083:106:0;-1:-1:-1;;;;;;;;;;;89200:85:0;;-1:-1:-1;;;;;;89200:85:0;-1:-1:-1;;;;;89200:85:0;;;;;;;;;;89009:284::o;89702:297::-;89845:29;89856:17;89845:10;:29::i;:::-;89903:1;89889:4;:11;:15;:28;;;;89908:9;89889:28;89885:107;;;89934:46;89956:17;89975:4;89934:21;:46::i;74446:689::-;74630:83;;-1:-1:-1;;;74630:83:0;;74609:4;;-1:-1:-1;;;;;74630:47:0;;;;;:83;;53913:10;;74692:4;;74698:7;;74707:5;;74630:83;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;74630:83:0;;;;;;;;-1:-1:-1;;74630:83:0;;;;;;;;;;;;:::i;:::-;;;74626:502;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;74886:6;:13;74903:1;74886:18;74882:235;;74932:40;;-1:-1:-1;;;74932:40:0;;;;;;;;;;;74882:235;75075:6;75069:13;75060:6;75056:2;75052:15;75045:38;74626:502;-1:-1:-1;;;;;;74760:66:0;-1:-1:-1;;;74760:66:0;;-1:-1:-1;74626:502:0;74446:689;;;;;;:::o;28220:231::-;28298:7;28319:17;28338:18;28360:27;28371:4;28377:9;28360:10;:27::i;:::-;28318:69;;;;28398:18;28410:5;28398:11;:18::i;:::-;-1:-1:-1;28434:9:0;28220:231;-1:-1:-1;;;28220:231:0:o;19336:922::-;19389:7;;-1:-1:-1;;;19467:15:0;;19463:102;;-1:-1:-1;;;19503:15:0;;;-1:-1:-1;19547:2:0;19537:12;19463:102;19592:6;19583:5;:15;19579:102;;19628:6;19619:15;;;-1:-1:-1;19663:2:0;19653:12;19579:102;19708:6;19699:5;:15;19695:102;;19744:6;19735:15;;;-1:-1:-1;19779:2:0;19769:12;19695:102;19824:5;19815;:14;19811:99;;19859:5;19850:14;;;-1:-1:-1;19893:1:0;19883:11;19811:99;19937:5;19928;:14;19924:99;;19972:5;19963:14;;;-1:-1:-1;20006:1:0;19996:11;19924:99;20050:5;20041;:14;20037:99;;20085:5;20076:14;;;-1:-1:-1;20119:1:0;20109:11;20037:99;20163:5;20154;:14;20150:66;;20199:1;20189:11;20244:6;19336:922;-1:-1:-1;;19336:922:0:o;89406:155::-;89473:37;89492:17;89473:18;:37::i;:::-;89526:27;;-1:-1:-1;;;;;89526:27:0;;;;;;;;89406:155;:::o;94439:461::-;94522:12;-1:-1:-1;;;;;37625:19:0;;;94547:88;;;;-1:-1:-1;;;94547:88:0;;20454:2:1;94547:88:0;;;20436:21:1;20493:2;20473:18;;;20466:30;20532:34;20512:18;;;20505:62;-1:-1:-1;;;20583:18:1;;;20576:36;20629:19;;94547:88:0;20252:402:1;94547:88:0;94709:12;94723:23;94750:6;-1:-1:-1;;;;;94750:19:0;94770:4;94750:25;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;94708:67;;;;94793:99;94829:7;94838:10;94793:99;;;;;;;;;;;;;;;;;:35;:99::i;:::-;94786:106;94439:461;-1:-1:-1;;;;;94439:461:0:o;26671:747::-;26752:7;26761:12;26790:9;:16;26810:2;26790:22;26786:625;;27134:4;27119:20;;27113:27;27184:4;27169:20;;27163:27;27242:4;27227:20;;27221:27;26829:9;27213:36;27285:25;27296:4;27213:36;27113:27;27163;27285:10;:25::i;:::-;27278:32;;;;;;;;;26786:625;-1:-1:-1;27359:1:0;;-1:-1:-1;27363:35:0;26786:625;26671:747;;;;;:::o;25064:521::-;25142:20;25133:5;:29;;;;;;;;:::i;:::-;;25129:449;;25064:521;:::o;25129:449::-;25240:29;25231:5;:38;;;;;;;;:::i;:::-;;25227:351;;25286:34;;-1:-1:-1;;;25286:34:0;;21140:2:1;25286:34:0;;;21122:21:1;21179:2;21159:18;;;21152:30;21218:26;21198:18;;;21191:54;21262:18;;25286:34:0;20938:348:1;25227:351:0;25351:35;25342:5;:44;;;;;;;;:::i;:::-;;25338:240;;25403:41;;-1:-1:-1;;;25403:41:0;;21493:2:1;25403:41:0;;;21475:21:1;21532:2;21512:18;;;21505:30;21571:33;21551:18;;;21544:61;21622:18;;25403:41:0;21291:355:1;25338:240:0;25475:30;25466:5;:39;;;;;;;;:::i;:::-;;25462:116;;25522:44;;-1:-1:-1;;;25522:44:0;;21853:2:1;25522:44:0;;;21835:21:1;21892:2;21872:18;;;21865:30;21931:34;21911:18;;;21904:62;-1:-1:-1;;;21982:18:1;;;21975:32;22024:19;;25522:44:0;21651:398:1;43740:305:0;43890:12;43919:7;43915:123;;;-1:-1:-1;43950:10:0;43943:17;;43915:123;43993:33;44001:10;44013:12;43993:7;:33::i;29672:1520::-;29803:7;;30737:66;30724:79;;30720:163;;;-1:-1:-1;30836:1:0;;-1:-1:-1;30840:30:0;30820:51;;30720:163;30997:24;;;30980:14;30997:24;;;;;;;;;22281:25:1;;;22354:4;22342:17;;22322:18;;;22315:45;;;;22376:18;;;22369:34;;;22419:18;;;22412:34;;;30997:24:0;;22253:19:1;;30997:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;30997:24:0;;-1:-1:-1;;30997:24:0;;;-1:-1:-1;;;;;;;31036:20:0;;31032:103;;31089:1;31093:29;31073:50;;;;;;;31032:103;31155:6;-1:-1:-1;31163:20:0;;-1:-1:-1;29672:1520:0;;;;;;;;:::o;44053:552::-;44214:17;;:21;44210:388;;44446:10;44440:17;44503:15;44490:10;44486:2;44482:19;44475:44;44210:388;44573:12;44566:20;;-1:-1:-1;;;44566:20:0;;;;;;;;:::i;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14:173:1;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:70;;177:1;174;167:12;111:70;14:173;;;:::o;192:411::-;282:6;290;298;351:2;339:9;330:7;326:23;322:32;319:52;;;367:1;364;357:12;319:52;390:29;409:9;390:29;:::i;:::-;380:39;;466:2;455:9;451:18;438:32;428:42;;520:2;509:9;505:18;492:32;553:1;546:5;543:12;533:40;;569:1;566;559:12;533:40;592:5;582:15;;;192:411;;;;;:::o;790:131::-;-1:-1:-1;;;;;;864:32:1;;854:43;;844:71;;911:1;908;901:12;926:245;984:6;1037:2;1025:9;1016:7;1012:23;1008:32;1005:52;;;1053:1;1050;1043:12;1005:52;1092:9;1079:23;1111:30;1135:5;1111:30;:::i;1368:258::-;1440:1;1450:113;1464:6;1461:1;1458:13;1450:113;;;1540:11;;;1534:18;1521:11;;;1514:39;1486:2;1479:10;1450:113;;;1581:6;1578:1;1575:13;1572:48;;;-1:-1:-1;;1616:1:1;1598:16;;1591:27;1368:258::o;1631:::-;1673:3;1711:5;1705:12;1738:6;1733:3;1726:19;1754:63;1810:6;1803:4;1798:3;1794:14;1787:4;1780:5;1776:16;1754:63;:::i;:::-;1871:2;1850:15;-1:-1:-1;;1846:29:1;1837:39;;;;1878:4;1833:50;;1631:258;-1:-1:-1;;1631:258:1:o;1894:220::-;2043:2;2032:9;2025:21;2006:4;2063:45;2104:2;2093:9;2089:18;2081:6;2063:45;:::i;2119:180::-;2178:6;2231:2;2219:9;2210:7;2206:23;2202:32;2199:52;;;2247:1;2244;2237:12;2199:52;-1:-1:-1;2270:23:1;;2119:180;-1:-1:-1;2119:180:1:o;2512:254::-;2580:6;2588;2641:2;2629:9;2620:7;2616:23;2612:32;2609:52;;;2657:1;2654;2647:12;2609:52;2680:29;2699:9;2680:29;:::i;:::-;2670:39;2756:2;2741:18;;;;2728:32;;-1:-1:-1;;;2512:254:1:o;2953:127::-;3014:10;3009:3;3005:20;3002:1;2995:31;3045:4;3042:1;3035:15;3069:4;3066:1;3059:15;3085:632;3150:5;-1:-1:-1;;;;;3221:2:1;3213:6;3210:14;3207:40;;;3227:18;;:::i;:::-;3302:2;3296:9;3270:2;3356:15;;-1:-1:-1;;3352:24:1;;;3378:2;3348:33;3344:42;3332:55;;;3402:18;;;3422:22;;;3399:46;3396:72;;;3448:18;;:::i;:::-;3488:10;3484:2;3477:22;3517:6;3508:15;;3547:6;3539;3532:22;3587:3;3578:6;3573:3;3569:16;3566:25;3563:45;;;3604:1;3601;3594:12;3563:45;3654:6;3649:3;3642:4;3634:6;3630:17;3617:44;3709:1;3702:4;3693:6;3685;3681:19;3677:30;3670:41;;;;3085:632;;;;;:::o;3722:451::-;3791:6;3844:2;3832:9;3823:7;3819:23;3815:32;3812:52;;;3860:1;3857;3850:12;3812:52;3900:9;3887:23;-1:-1:-1;;;;;3925:6:1;3922:30;3919:50;;;3965:1;3962;3955:12;3919:50;3988:22;;4041:4;4033:13;;4029:27;-1:-1:-1;4019:55:1;;4070:1;4067;4060:12;4019:55;4093:74;4159:7;4154:2;4141:16;4136:2;4132;4128:11;4093:74;:::i;4178:328::-;4255:6;4263;4271;4324:2;4312:9;4303:7;4299:23;4295:32;4292:52;;;4340:1;4337;4330:12;4292:52;4363:29;4382:9;4363:29;:::i;:::-;4353:39;;4411:38;4445:2;4434:9;4430:18;4411:38;:::i;:::-;4401:48;;4496:2;4485:9;4481:18;4468:32;4458:42;;4178:328;;;;;:::o;4511:186::-;4570:6;4623:2;4611:9;4602:7;4598:23;4594:32;4591:52;;;4639:1;4636;4629:12;4591:52;4662:29;4681:9;4662:29;:::i;4702:221::-;4744:5;4797:3;4790:4;4782:6;4778:17;4774:27;4764:55;;4815:1;4812;4805:12;4764:55;4837:80;4913:3;4904:6;4891:20;4884:4;4876:6;4872:17;4837:80;:::i;4928:394::-;5005:6;5013;5066:2;5054:9;5045:7;5041:23;5037:32;5034:52;;;5082:1;5079;5072:12;5034:52;5105:29;5124:9;5105:29;:::i;:::-;5095:39;;5185:2;5174:9;5170:18;5157:32;-1:-1:-1;;;;;5204:6:1;5201:30;5198:50;;;5244:1;5241;5234:12;5198:50;5267:49;5308:7;5299:6;5288:9;5284:22;5267:49;:::i;:::-;5257:59;;;4928:394;;;;;:::o;5327:160::-;5392:20;;5448:13;;5441:21;5431:32;;5421:60;;5477:1;5474;5467:12;5492:525;5584:6;5592;5600;5608;5661:3;5649:9;5640:7;5636:23;5632:33;5629:53;;;5678:1;5675;5668:12;5629:53;5718:9;5705:23;-1:-1:-1;;;;;5743:6:1;5740:30;5737:50;;;5783:1;5780;5773:12;5737:50;5806:49;5847:7;5838:6;5827:9;5823:22;5806:49;:::i;:::-;5796:59;;;5902:2;5891:9;5887:18;5874:32;5864:42;;5953:2;5942:9;5938:18;5925:32;5915:42;;5976:35;6007:2;5996:9;5992:18;5976:35;:::i;:::-;5966:45;;5492:525;;;;;;;:::o;6022:592::-;6093:6;6101;6154:2;6142:9;6133:7;6129:23;6125:32;6122:52;;;6170:1;6167;6160:12;6122:52;6210:9;6197:23;-1:-1:-1;;;;;6280:2:1;6272:6;6269:14;6266:34;;;6296:1;6293;6286:12;6266:34;6334:6;6323:9;6319:22;6309:32;;6379:7;6372:4;6368:2;6364:13;6360:27;6350:55;;6401:1;6398;6391:12;6350:55;6441:2;6428:16;6467:2;6459:6;6456:14;6453:34;;;6483:1;6480;6473:12;6453:34;6528:7;6523:2;6514:6;6510:2;6506:15;6502:24;6499:37;6496:57;;;6549:1;6546;6539:12;6496:57;6580:2;6572:11;;;;;6602:6;;-1:-1:-1;6022:592:1;;-1:-1:-1;;;;6022:592:1:o;6619:254::-;6687:6;6695;6748:2;6736:9;6727:7;6723:23;6719:32;6716:52;;;6764:1;6761;6754:12;6716:52;6800:9;6787:23;6777:33;;6829:38;6863:2;6852:9;6848:18;6829:38;:::i;:::-;6819:48;;6619:254;;;;;:::o;6878:127::-;6939:10;6934:3;6930:20;6927:1;6920:31;6970:4;6967:1;6960:15;6994:4;6991:1;6984:15;7010:341;7155:2;7140:18;;7188:1;7177:13;;7167:144;;7233:10;7228:3;7224:20;7221:1;7214:31;7268:4;7265:1;7258:15;7296:4;7293:1;7286:15;7167:144;7320:25;;;7010:341;:::o;7802:254::-;7867:6;7875;7928:2;7916:9;7907:7;7903:23;7899:32;7896:52;;;7944:1;7941;7934:12;7896:52;7967:29;7986:9;7967:29;:::i;:::-;7957:39;;8015:35;8046:2;8035:9;8031:18;8015:35;:::i;8246:537::-;8341:6;8349;8357;8365;8418:3;8406:9;8397:7;8393:23;8389:33;8386:53;;;8435:1;8432;8425:12;8386:53;8458:29;8477:9;8458:29;:::i;:::-;8448:39;;8506:38;8540:2;8529:9;8525:18;8506:38;:::i;:::-;8496:48;;8591:2;8580:9;8576:18;8563:32;8553:42;;8646:2;8635:9;8631:18;8618:32;-1:-1:-1;;;;;8665:6:1;8662:30;8659:50;;;8705:1;8702;8695:12;8659:50;8728:49;8769:7;8760:6;8749:9;8745:22;8728:49;:::i;:::-;8718:59;;;8246:537;;;;;;;:::o;8788:456::-;8871:6;8879;8887;8940:2;8928:9;8919:7;8915:23;8911:32;8908:52;;;8956:1;8953;8946:12;8908:52;8996:9;8983:23;-1:-1:-1;;;;;9021:6:1;9018:30;9015:50;;;9061:1;9058;9051:12;9015:50;9084:49;9125:7;9116:6;9105:9;9101:22;9084:49;:::i;:::-;9074:59;;;9180:2;9169:9;9165:18;9152:32;9142:42;;9203:35;9234:2;9223:9;9219:18;9203:35;:::i;:::-;9193:45;;8788:456;;;;;:::o;9249:260::-;9317:6;9325;9378:2;9366:9;9357:7;9353:23;9349:32;9346:52;;;9394:1;9391;9384:12;9346:52;9417:29;9436:9;9417:29;:::i;:::-;9407:39;;9465:38;9499:2;9488:9;9484:18;9465:38;:::i;10263:380::-;10342:1;10338:12;;;;10385;;;10406:61;;10460:4;10452:6;10448:17;10438:27;;10406:61;10513:2;10505:6;10502:14;10482:18;10479:38;10476:161;;10559:10;10554:3;10550:20;10547:1;10540:31;10594:4;10591:1;10584:15;10622:4;10619:1;10612:15;10476:161;;10263:380;;;:::o;10648:399::-;10850:2;10832:21;;;10889:2;10869:18;;;10862:30;10928:34;10923:2;10908:18;;10901:62;-1:-1:-1;;;10994:2:1;10979:18;;10972:33;11037:3;11022:19;;10648:399::o;11052:408::-;11254:2;11236:21;;;11293:2;11273:18;;;11266:30;11332:34;11327:2;11312:18;;11305:62;-1:-1:-1;;;11398:2:1;11383:18;;11376:42;11450:3;11435:19;;11052:408::o;11465:::-;11667:2;11649:21;;;11706:2;11686:18;;;11679:30;11745:34;11740:2;11725:18;;11718:62;-1:-1:-1;;;11811:2:1;11796:18;;11789:42;11863:3;11848:19;;11465:408::o;11878:127::-;11939:10;11934:3;11930:20;11927:1;11920:31;11970:4;11967:1;11960:15;11994:4;11991:1;11984:15;12010:168;12050:7;12116:1;12112;12108:6;12104:14;12101:1;12098:21;12093:1;12086:9;12079:17;12075:45;12072:71;;;12123:18;;:::i;:::-;-1:-1:-1;12163:9:1;;12010:168::o;12315:217::-;12355:1;12381;12371:132;;12425:10;12420:3;12416:20;12413:1;12406:31;12460:4;12457:1;12450:15;12488:4;12485:1;12478:15;12371:132;-1:-1:-1;12517:9:1;;12315:217::o;12747:125::-;12787:4;12815:1;12812;12809:8;12806:34;;;12820:18;;:::i;:::-;-1:-1:-1;12857:9:1;;12747:125::o;12877:128::-;12917:3;12948:1;12944:6;12941:1;12938:13;12935:39;;;12954:18;;:::i;:::-;-1:-1:-1;12990:9:1;;12877:128::o;13435:424::-;13637:2;13619:21;;;13676:2;13656:18;;;13649:30;13715:34;13710:2;13695:18;;13688:62;13786:30;13781:2;13766:18;;13759:58;13849:3;13834:19;;13435:424::o;13864:405::-;14066:2;14048:21;;;14105:2;14085:18;;;14078:30;14144:34;14139:2;14124:18;;14117:62;-1:-1:-1;;;14210:2:1;14195:18;;14188:39;14259:3;14244:19;;13864:405::o;14689:410::-;14891:2;14873:21;;;14930:2;14910:18;;;14903:30;14969:34;14964:2;14949:18;;14942:62;-1:-1:-1;;;15035:2:1;15020:18;;15013:44;15089:3;15074:19;;14689:410::o;15582:135::-;15621:3;15642:17;;;15639:43;;15662:18;;:::i;:::-;-1:-1:-1;15709:1:1;15698:13;;15582:135::o;15722:470::-;15901:3;15939:6;15933:13;15955:53;16001:6;15996:3;15989:4;15981:6;15977:17;15955:53;:::i;:::-;16071:13;;16030:16;;;;16093:57;16071:13;16030:16;16127:4;16115:17;;16093:57;:::i;:::-;16166:20;;15722:470;-1:-1:-1;;;;15722:470:1:o;16965:184::-;17035:6;17088:2;17076:9;17067:7;17063:23;17059:32;17056:52;;;17104:1;17101;17094:12;17056:52;-1:-1:-1;17127:16:1;;16965:184;-1:-1:-1;16965:184:1:o;18326:407::-;18528:2;18510:21;;;18567:2;18547:18;;;18540:30;18606:34;18601:2;18586:18;;18579:62;-1:-1:-1;;;18672:2:1;18657:18;;18650:41;18723:3;18708:19;;18326:407::o;19504:489::-;-1:-1:-1;;;;;19773:15:1;;;19755:34;;19825:15;;19820:2;19805:18;;19798:43;19872:2;19857:18;;19850:34;;;19920:3;19915:2;19900:18;;19893:31;;;19698:4;;19941:46;;19967:19;;19959:6;19941:46;:::i;:::-;19933:54;19504:489;-1:-1:-1;;;;;;19504:489:1:o;19998:249::-;20067:6;20120:2;20108:9;20099:7;20095:23;20091:32;20088:52;;;20136:1;20133;20126:12;20088:52;20168:9;20162:16;20187:30;20211:5;20187:30;:::i;20659:274::-;20788:3;20826:6;20820:13;20842:53;20888:6;20883:3;20876:4;20868:6;20864:17;20842:53;:::i;:::-;20911:16;;;;;20659:274;-1:-1:-1;;20659:274:1:o
Swarm Source
ipfs://33dfc38dd01fb615d7b276fa9c526d36c0df6ba506ac424259506664864d528b
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 27 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.