ERC-721
Overview
Max Total Supply
100 DECAL
Holders
91
Market
Volume (24H)
N/A
Min Price (24H)
N/A
Max Price (24H)
N/A
Other Info
Token Contract
Balance
1 DECALLoading...
Loading
Loading...
Loading
Loading...
Loading
# | Exchange | Pair | Price | 24H Volume | % Volume |
---|
Contract Name:
xiiixiii_Decal
Compiler Version
v0.8.17+commit.8df45f5f
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2023-09-21 */ // File @openzeppelin/contracts/access/[email protected] // SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol) pragma solidity ^0.8.0; /** * @dev External interface of AccessControl declared to support ERC165 detection. */ interface IAccessControl { /** * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole` * * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite * {RoleAdminChanged} not being emitted signaling this. * * _Available since v3.1._ */ event RoleAdminChanged( bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole ); /** * @dev Emitted when `account` is granted `role`. * * `sender` is the account that originated the contract call, an admin role * bearer except when using {AccessControl-_setupRole}. */ event RoleGranted( bytes32 indexed role, address indexed account, address indexed sender ); /** * @dev Emitted when `account` is revoked `role`. * * `sender` is the account that originated the contract call: * - if using `revokeRole`, it is the admin role bearer * - if using `renounceRole`, it is the role bearer (i.e. `account`) */ event RoleRevoked( bytes32 indexed role, address indexed account, address indexed sender ); /** * @dev Returns `true` if `account` has been granted `role`. */ function hasRole(bytes32 role, address account) external view returns (bool); /** * @dev Returns the admin role that controls `role`. See {grantRole} and * {revokeRole}. * * To change a role's admin, use {AccessControl-_setRoleAdmin}. */ function getRoleAdmin(bytes32 role) external view returns (bytes32); /** * @dev Grants `role` to `account`. * * If `account` had not been already granted `role`, emits a {RoleGranted} * event. * * Requirements: * * - the caller must have ``role``'s admin role. */ function grantRole(bytes32 role, address account) external; /** * @dev Revokes `role` from `account`. * * If `account` had been granted `role`, emits a {RoleRevoked} event. * * Requirements: * * - the caller must have ``role``'s admin role. */ function revokeRole(bytes32 role, address account) external; /** * @dev Revokes `role` from the calling account. * * Roles are often managed via {grantRole} and {revokeRole}: this function's * purpose is to provide a mechanism for accounts to lose their privileges * if they are compromised (such as when a trusted device is misplaced). * * If the calling account had been granted `role`, emits a {RoleRevoked} * event. * * Requirements: * * - the caller must be `account`. */ function renounceRole(bytes32 role, address account) external; } // File @openzeppelin/contracts/utils/[email protected] // 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 Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } } // File @openzeppelin/contracts/utils/introspection/[email protected] // 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 IERC165 { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); } // File @openzeppelin/contracts/utils/introspection/[email protected] // 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 ERC165 is IERC165 { /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface( bytes4 interfaceId ) public view virtual override returns (bool) { return interfaceId == type(IERC165).interfaceId; } } // File @openzeppelin/contracts/utils/math/[email protected] // OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol) pragma solidity ^0.8.0; /** * @dev Standard math utilities missing in the Solidity language. */ library Math { enum Rounding { Down, // Toward negative infinity Up, // Toward infinity Zero // Toward zero } /** * @dev Returns the largest of two numbers. */ function max(uint256 a, uint256 b) internal pure returns (uint256) { return a > b ? a : b; } /** * @dev Returns the smallest of two numbers. */ function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } /** * @dev Returns the average of two numbers. The result is rounded towards * zero. */ function average(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b) / 2 can overflow. return (a & b) + (a ^ b) / 2; } /** * @dev Returns the ceiling of the division of two numbers. * * This differs from standard division with `/` in that it rounds up instead * of rounding down. */ function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b - 1) / b can overflow on addition, so we distribute. return a == 0 ? 0 : (a - 1) / b + 1; } /** * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0 * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) * with further edits by Uniswap Labs also under MIT license. */ function mulDiv( uint256 x, uint256 y, uint256 denominator ) internal pure returns (uint256 result) { unchecked { // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256 // variables such that product = prod1 * 2^256 + prod0. uint256 prod0; // Least significant 256 bits of the product uint256 prod1; // Most significant 256 bits of the product assembly { let mm := mulmod(x, y, not(0)) prod0 := mul(x, y) prod1 := sub(sub(mm, prod0), lt(mm, prod0)) } // Handle non-overflow cases, 256 by 256 division. if (prod1 == 0) { return prod0 / denominator; } // Make sure the result is less than 2^256. Also prevents denominator == 0. require(denominator > prod1); /////////////////////////////////////////////// // 512 by 256 division. /////////////////////////////////////////////// // Make division exact by subtracting the remainder from [prod1 prod0]. uint256 remainder; assembly { // Compute remainder using mulmod. remainder := mulmod(x, y, denominator) // Subtract 256 bit number from 512 bit number. prod1 := sub(prod1, gt(remainder, prod0)) prod0 := sub(prod0, remainder) } // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1. // See https://cs.stackexchange.com/q/138556/92363. // Does not overflow because the denominator cannot be zero at this stage in the function. uint256 twos = denominator & (~denominator + 1); assembly { // Divide denominator by twos. denominator := div(denominator, twos) // Divide [prod1 prod0] by twos. prod0 := div(prod0, twos) // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one. twos := add(div(sub(0, twos), twos), 1) } // Shift in bits from prod1 into prod0. prod0 |= prod1 * twos; // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for // four bits. That is, denominator * inv = 1 mod 2^4. uint256 inverse = (3 * denominator) ^ 2; // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works // in modular arithmetic, doubling the correct bits in each step. inverse *= 2 - denominator * inverse; // inverse mod 2^8 inverse *= 2 - denominator * inverse; // inverse mod 2^16 inverse *= 2 - denominator * inverse; // inverse mod 2^32 inverse *= 2 - denominator * inverse; // inverse mod 2^64 inverse *= 2 - denominator * inverse; // inverse mod 2^128 inverse *= 2 - denominator * inverse; // inverse mod 2^256 // Because the division is now exact we can divide by multiplying with the modular inverse of denominator. // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1 // is no longer required. result = prod0 * inverse; return result; } } /** * @notice Calculates x * y / denominator with full precision, following the selected rounding direction. */ function mulDiv( uint256 x, uint256 y, uint256 denominator, Rounding rounding ) internal pure returns (uint256) { uint256 result = mulDiv(x, y, denominator); if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) { result += 1; } return result; } /** * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down. * * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11). */ function sqrt(uint256 a) internal pure returns (uint256) { if (a == 0) { return 0; } // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target. // // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`. // // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)` // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))` // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)` // // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit. uint256 result = 1 << (log2(a) >> 1); // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128, // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision // into the expected uint128 result. unchecked { result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; return min(result, a / result); } } /** * @notice Calculates sqrt(a), following the selected rounding direction. */ function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = sqrt(a); return result + (rounding == Rounding.Up && result * result < a ? 1 : 0); } } /** * @dev Return the log in base 2, rounded down, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 128; } if (value >> 64 > 0) { value >>= 64; result += 64; } if (value >> 32 > 0) { value >>= 32; result += 32; } if (value >> 16 > 0) { value >>= 16; result += 16; } if (value >> 8 > 0) { value >>= 8; result += 8; } if (value >> 4 > 0) { value >>= 4; result += 4; } if (value >> 2 > 0) { value >>= 2; result += 2; } if (value >> 1 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 2, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log2( uint256 value, Rounding rounding ) internal pure returns (uint256) { unchecked { uint256 result = log2(value); return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0); } } /** * @dev Return the log in base 10, rounded down, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >= 10 ** 64) { value /= 10 ** 64; result += 64; } if (value >= 10 ** 32) { value /= 10 ** 32; result += 32; } if (value >= 10 ** 16) { value /= 10 ** 16; result += 16; } if (value >= 10 ** 8) { value /= 10 ** 8; result += 8; } if (value >= 10 ** 4) { value /= 10 ** 4; result += 4; } if (value >= 10 ** 2) { value /= 10 ** 2; result += 2; } if (value >= 10 ** 1) { result += 1; } } return result; } /** * @dev Return the log in base 10, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log10( uint256 value, Rounding rounding ) internal pure returns (uint256) { unchecked { uint256 result = log10(value); return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0); } } /** * @dev Return the log in base 256, rounded down, of a positive value. * Returns 0 if given 0. * * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string. */ function log256(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 16; } if (value >> 64 > 0) { value >>= 64; result += 8; } if (value >> 32 > 0) { value >>= 32; result += 4; } if (value >> 16 > 0) { value >>= 16; result += 2; } if (value >> 8 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 10, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log256( uint256 value, Rounding rounding ) internal pure returns (uint256) { unchecked { uint256 result = log256(value); return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0); } } } // File @openzeppelin/contracts/utils/[email protected] // OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol) pragma solidity ^0.8.0; /** * @dev String operations. */ library Strings { bytes16 private constant _SYMBOLS = "0123456789abcdef"; uint8 private constant _ADDRESS_LENGTH = 20; /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function toString(uint256 value) internal pure returns (string memory) { unchecked { uint256 length = Math.log10(value) + 1; string memory buffer = new string(length); uint256 ptr; /// @solidity memory-safe-assembly assembly { ptr := add(buffer, add(32, length)) } while (true) { ptr--; /// @solidity memory-safe-assembly assembly { mstore8(ptr, byte(mod(value, 10), _SYMBOLS)) } value /= 10; if (value == 0) break; } return buffer; } } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { unchecked { return toHexString(value, Math.log256(value) + 1); } } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length. */ function toHexString( uint256 value, uint256 length ) internal pure returns (string memory) { bytes memory buffer = new bytes(2 * length + 2); buffer[0] = "0"; buffer[1] = "x"; for (uint256 i = 2 * length + 1; i > 1; --i) { buffer[i] = _SYMBOLS[value & 0xf]; value >>= 4; } require(value == 0, "Strings: hex length insufficient"); return string(buffer); } /** * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation. */ function toHexString(address addr) internal pure returns (string memory) { return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH); } } // File @openzeppelin/contracts/access/[email protected] // OpenZeppelin Contracts (last updated v4.8.0) (access/AccessControl.sol) pragma solidity ^0.8.0; /** * @dev Contract module that allows children to implement role-based access * control mechanisms. This is a lightweight version that doesn't allow enumerating role * members except through off-chain means by accessing the contract event logs. Some * applications may benefit from on-chain enumerability, for those cases see * {AccessControlEnumerable}. * * Roles are referred to by their `bytes32` identifier. These should be exposed * in the external API and be unique. The best way to achieve this is by * using `public constant` hash digests: * * ``` * bytes32 public constant MY_ROLE = keccak256("MY_ROLE"); * ``` * * Roles can be used to represent a set of permissions. To restrict access to a * function call, use {hasRole}: * * ``` * function foo() public { * require(hasRole(MY_ROLE, msg.sender)); * ... * } * ``` * * Roles can be granted and revoked dynamically via the {grantRole} and * {revokeRole} functions. Each role has an associated admin role, and only * accounts that have a role's admin role can call {grantRole} and {revokeRole}. * * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means * that only accounts with this role will be able to grant or revoke other * roles. More complex role relationships can be created by using * {_setRoleAdmin}. * * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to * grant and revoke this role. Extra precautions should be taken to secure * accounts that have been granted it. */ abstract contract AccessControl is Context, IAccessControl, ERC165 { struct RoleData { mapping(address => bool) members; bytes32 adminRole; } mapping(bytes32 => RoleData) private _roles; bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00; /** * @dev Modifier that checks that an account has a specific role. Reverts * with a standardized message including the required role. * * The format of the revert reason is given by the following regular expression: * * /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/ * * _Available since v4.1._ */ modifier onlyRole(bytes32 role) { _checkRole(role); _; } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface( bytes4 interfaceId ) public view virtual override returns (bool) { return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId); } /** * @dev Returns `true` if `account` has been granted `role`. */ function hasRole( bytes32 role, address account ) public view virtual override returns (bool) { return _roles[role].members[account]; } /** * @dev Revert with a standard message if `_msgSender()` is missing `role`. * Overriding this function changes the behavior of the {onlyRole} modifier. * * Format of the revert message is described in {_checkRole}. * * _Available since v4.6._ */ function _checkRole(bytes32 role) internal view virtual { _checkRole(role, _msgSender()); } /** * @dev Revert with a standard message if `account` is missing `role`. * * The format of the revert reason is given by the following regular expression: * * /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/ */ function _checkRole(bytes32 role, address account) internal view virtual { if (!hasRole(role, account)) { revert( string( abi.encodePacked( "AccessControl: account ", Strings.toHexString(account), " is missing role ", Strings.toHexString(uint256(role), 32) ) ) ); } } /** * @dev Returns the admin role that controls `role`. See {grantRole} and * {revokeRole}. * * To change a role's admin, use {_setRoleAdmin}. */ function getRoleAdmin( bytes32 role ) public view virtual override returns (bytes32) { return _roles[role].adminRole; } /** * @dev Grants `role` to `account`. * * If `account` had not been already granted `role`, emits a {RoleGranted} * event. * * Requirements: * * - the caller must have ``role``'s admin role. * * May emit a {RoleGranted} event. */ function grantRole( bytes32 role, address account ) public virtual override onlyRole(getRoleAdmin(role)) { _grantRole(role, account); } /** * @dev Revokes `role` from `account`. * * If `account` had been granted `role`, emits a {RoleRevoked} event. * * Requirements: * * - the caller must have ``role``'s admin role. * * May emit a {RoleRevoked} event. */ function revokeRole( bytes32 role, address account ) public virtual override onlyRole(getRoleAdmin(role)) { _revokeRole(role, account); } /** * @dev Revokes `role` from the calling account. * * Roles are often managed via {grantRole} and {revokeRole}: this function's * purpose is to provide a mechanism for accounts to lose their privileges * if they are compromised (such as when a trusted device is misplaced). * * If the calling account had been revoked `role`, emits a {RoleRevoked} * event. * * Requirements: * * - the caller must be `account`. * * May emit a {RoleRevoked} event. */ function renounceRole(bytes32 role, address account) public virtual override { require( account == _msgSender(), "AccessControl: can only renounce roles for self" ); _revokeRole(role, account); } /** * @dev Grants `role` to `account`. * * If `account` had not been already granted `role`, emits a {RoleGranted} * event. Note that unlike {grantRole}, this function doesn't perform any * checks on the calling account. * * May emit a {RoleGranted} event. * * [WARNING] * ==== * This function should only be called from the constructor when setting * up the initial roles for the system. * * Using this function in any other way is effectively circumventing the admin * system imposed by {AccessControl}. * ==== * * NOTE: This function is deprecated in favor of {_grantRole}. */ function _setupRole(bytes32 role, address account) internal virtual { _grantRole(role, account); } /** * @dev Sets `adminRole` as ``role``'s admin role. * * Emits a {RoleAdminChanged} event. */ function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual { bytes32 previousAdminRole = getRoleAdmin(role); _roles[role].adminRole = adminRole; emit RoleAdminChanged(role, previousAdminRole, adminRole); } /** * @dev Grants `role` to `account`. * * Internal function without access restriction. * * May emit a {RoleGranted} event. */ function _grantRole(bytes32 role, address account) internal virtual { if (!hasRole(role, account)) { _roles[role].members[account] = true; emit RoleGranted(role, account, _msgSender()); } } /** * @dev Revokes `role` from `account`. * * Internal function without access restriction. * * May emit a {RoleRevoked} event. */ function _revokeRole(bytes32 role, address account) internal virtual { if (hasRole(role, account)) { _roles[role].members[account] = false; emit RoleRevoked(role, account, _msgSender()); } } } // File @openzeppelin/contracts/access/[email protected] // 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 Ownable is Context { address private _owner; event OwnershipTransferred( address indexed previousOwner, address indexed newOwner ); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor() { _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); } } // File @openzeppelin/contracts/token/ERC721/[email protected] // OpenZeppelin Contracts (last updated v4.9.0) (token/ERC721/IERC721.sol) pragma solidity ^0.8.0; /** * @dev Required interface of an ERC721 compliant contract. */ interface IERC721 is IERC165 { /** * @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/token/ERC721/extensions/[email protected] // 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 IERC721Metadata is IERC721 { /** * @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/token/ERC721/[email protected] // 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 IERC721Receiver { /** * @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/utils/[email protected] // OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol) pragma solidity ^0.8.1; /** * @dev Collection of functions related to the address type */ library Address { /** * @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 Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall( address target, bytes memory data ) internal returns (bytes memory) { return functionDelegateCall( target, data, "Address: low-level delegate call failed" ); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract. * * _Available since v4.8._ */ function verifyCallResultFromTarget( address target, bool success, bytes memory returndata, string memory errorMessage ) internal view returns (bytes memory) { if (success) { if (returndata.length == 0) { // only check isContract if the call was successful and the return data is empty // otherwise we already know that it was a contract require(isContract(target), "Address: call to non-contract"); } return returndata; } else { _revert(returndata, errorMessage); } } /** * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason or using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal pure returns (bytes memory) { if (success) { return returndata; } else { _revert(returndata, errorMessage); } } function _revert( bytes memory returndata, string memory errorMessage ) private pure { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } // File @openzeppelin/contracts/token/ERC721/[email protected] // OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/ERC721.sol) pragma solidity ^0.8.0; /** * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including * the Metadata extension, but not including the Enumerable extension, which is available separately as * {ERC721Enumerable}. */ contract ERC721 is Context, ERC165, IERC721, IERC721Metadata { using Address for address; using Strings for uint256; // Token name string private _name; // Token symbol string private _symbol; // Mapping from token ID to owner address mapping(uint256 => address) private _owners; // Mapping owner address to token count mapping(address => uint256) private _balances; // 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; /** * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection. */ constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface( bytes4 interfaceId ) public view virtual override(ERC165, IERC165) returns (bool) { return interfaceId == type(IERC721).interfaceId || interfaceId == type(IERC721Metadata).interfaceId || super.supportsInterface(interfaceId); } /** * @dev See {IERC721-balanceOf}. */ function balanceOf( address owner ) public view virtual override returns (uint256) { require(owner != address(0), "ERC721: address zero is not a valid owner"); return _balances[owner]; } /** * @dev See {IERC721-ownerOf}. */ function ownerOf( uint256 tokenId ) public view virtual override returns (address) { address owner = _ownerOf(tokenId); require(owner != address(0), "ERC721: invalid token ID"); return owner; } /** * @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) { _requireMinted(tokenId); 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 overridden in child contracts. */ function _baseURI() internal view virtual returns (string memory) { return ""; } /** * @dev See {IERC721-approve}. */ function approve(address to, uint256 tokenId) public virtual override { address owner = ERC721.ownerOf(tokenId); require(to != owner, "ERC721: approval to current owner"); require( _msgSender() == owner || isApprovedForAll(owner, _msgSender()), "ERC721: approve caller is not token owner or approved for all" ); _approve(to, tokenId); } /** * @dev See {IERC721-getApproved}. */ function getApproved( uint256 tokenId ) public view virtual override returns (address) { _requireMinted(tokenId); return _tokenApprovals[tokenId]; } /** * @dev See {IERC721-setApprovalForAll}. */ function setApprovalForAll( address operator, bool approved ) public virtual override { _setApprovalForAll(_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 { //solhint-disable-next-line max-line-length require( _isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved" ); _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 { require( _isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved" ); _safeTransfer(from, to, tokenId, data); } /** * @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. * * `data` is additional data, it has no specified format and it is sent in call to `to`. * * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g. * implement alternative mechanisms to perform token transfer, such as signature-based. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function _safeTransfer( address from, address to, uint256 tokenId, bytes memory data ) internal virtual { _transfer(from, to, tokenId); require( _checkOnERC721Received(from, to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer" ); } /** * @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist */ function _ownerOf(uint256 tokenId) internal view virtual returns (address) { return _owners[tokenId]; } /** * @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`), * and stop existing when they are burned (`_burn`). */ function _exists(uint256 tokenId) internal view virtual returns (bool) { return _ownerOf(tokenId) != address(0); } /** * @dev Returns whether `spender` is allowed to manage `tokenId`. * * Requirements: * * - `tokenId` must exist. */ function _isApprovedOrOwner( address spender, uint256 tokenId ) internal view virtual returns (bool) { address owner = ERC721.ownerOf(tokenId); return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender); } /** * @dev Safely mints `tokenId` and transfers it to `to`. * * Requirements: * * - `tokenId` must not exist. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function _safeMint(address to, uint256 tokenId) internal virtual { _safeMint(to, tokenId, ""); } /** * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is * forwarded in {IERC721Receiver-onERC721Received} to contract recipients. */ function _safeMint( address to, uint256 tokenId, bytes memory data ) internal virtual { _mint(to, tokenId); require( _checkOnERC721Received(address(0), to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer" ); } /** * @dev Mints `tokenId` and transfers it to `to`. * * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible * * Requirements: * * - `tokenId` must not exist. * - `to` cannot be the zero address. * * Emits a {Transfer} event. */ function _mint(address to, uint256 tokenId) internal virtual { require(to != address(0), "ERC721: mint to the zero address"); require(!_exists(tokenId), "ERC721: token already minted"); _beforeTokenTransfer(address(0), to, tokenId, 1); // Check that tokenId was not minted by `_beforeTokenTransfer` hook require(!_exists(tokenId), "ERC721: token already minted"); unchecked { // Will not overflow unless all 2**256 token ids are minted to the same owner. // Given that tokens are minted one by one, it is impossible in practice that // this ever happens. Might change if we allow batch minting. // The ERC fails to describe this case. _balances[to] += 1; } _owners[tokenId] = to; emit Transfer(address(0), to, tokenId); _afterTokenTransfer(address(0), to, tokenId, 1); } /** * @dev Destroys `tokenId`. * The approval is cleared when the token is burned. * This is an internal function that does not check if the sender is authorized to operate on the token. * * Requirements: * * - `tokenId` must exist. * * Emits a {Transfer} event. */ function _burn(uint256 tokenId) internal virtual { address owner = ERC721.ownerOf(tokenId); _beforeTokenTransfer(owner, address(0), tokenId, 1); // Update ownership in case tokenId was transferred by `_beforeTokenTransfer` hook owner = ERC721.ownerOf(tokenId); // Clear approvals delete _tokenApprovals[tokenId]; unchecked { // Cannot overflow, as that would require more tokens to be burned/transferred // out than the owner initially received through minting and transferring in. _balances[owner] -= 1; } delete _owners[tokenId]; emit Transfer(owner, address(0), tokenId); _afterTokenTransfer(owner, address(0), tokenId, 1); } /** * @dev Transfers `tokenId` from `from` to `to`. * As opposed to {transferFrom}, this imposes no restrictions on msg.sender. * * 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 ) internal virtual { require( ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner" ); require(to != address(0), "ERC721: transfer to the zero address"); _beforeTokenTransfer(from, to, tokenId, 1); // Check that tokenId was not transferred by `_beforeTokenTransfer` hook require( ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner" ); // Clear approvals from the previous owner delete _tokenApprovals[tokenId]; unchecked { // `_balances[from]` cannot overflow for the same reason as described in `_burn`: // `from`'s balance is the number of token held, which is at least one before the current // transfer. // `_balances[to]` could overflow in the conditions described in `_mint`. That would require // all 2**256 token ids to be minted, which in practice is impossible. _balances[from] -= 1; _balances[to] += 1; } _owners[tokenId] = to; emit Transfer(from, to, tokenId); _afterTokenTransfer(from, to, tokenId, 1); } /** * @dev Approve `to` to operate on `tokenId` * * Emits an {Approval} event. */ function _approve(address to, uint256 tokenId) internal virtual { _tokenApprovals[tokenId] = to; emit Approval(ERC721.ownerOf(tokenId), to, tokenId); } /** * @dev Approve `operator` to operate on all of `owner` tokens * * Emits an {ApprovalForAll} event. */ function _setApprovalForAll( address owner, address operator, bool approved ) internal virtual { require(owner != operator, "ERC721: approve to caller"); _operatorApprovals[owner][operator] = approved; emit ApprovalForAll(owner, operator, approved); } /** * @dev Reverts if the `tokenId` has not been minted yet. */ function _requireMinted(uint256 tokenId) internal view virtual { require(_exists(tokenId), "ERC721: invalid token ID"); } /** * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address. * The call is not executed if the target address is not a 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 _checkOnERC721Received( address from, address to, uint256 tokenId, bytes memory data ) private returns (bool) { if (to.isContract()) { try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) { return retval == IERC721Receiver.onERC721Received.selector; } catch (bytes memory reason) { if (reason.length == 0) { revert("ERC721: transfer to non ERC721Receiver implementer"); } else { /// @solidity memory-safe-assembly assembly { revert(add(32, reason), mload(reason)) } } } } else { return true; } } /** * @dev Hook that is called before any token transfer. This includes minting and burning. If {ERC721Consecutive} is * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1. * * Calling conditions: * * - When `from` and `to` are both non-zero, ``from``'s tokens will be transferred to `to`. * - When `from` is zero, the tokens will be minted for `to`. * - When `to` is zero, ``from``'s tokens will be burned. * - `from` and `to` are never both zero. * - `batchSize` is non-zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer( address from, address to, uint256 /* firstTokenId */, uint256 batchSize ) internal virtual { if (batchSize > 1) { if (from != address(0)) { _balances[from] -= batchSize; } if (to != address(0)) { _balances[to] += batchSize; } } } /** * @dev Hook that is called after any token transfer. This includes minting and burning. If {ERC721Consecutive} is * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1. * * Calling conditions: * * - When `from` and `to` are both non-zero, ``from``'s tokens were transferred to `to`. * - When `from` is zero, the tokens were minted for `to`. * - When `to` is zero, ``from``'s tokens were burned. * - `from` and `to` are never both zero. * - `batchSize` is non-zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _afterTokenTransfer( address from, address to, uint256 firstTokenId, uint256 batchSize ) internal virtual {} } // File @openzeppelin/contracts/security/[email protected] // OpenZeppelin Contracts (last updated v4.8.0) (security/ReentrancyGuard.sol) pragma solidity ^0.8.0; /** * @dev Contract module that helps prevent reentrant calls to a function. * * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier * available, which can be applied to functions to make sure there are no nested * (reentrant) calls to them. * * Note that because there is a single `nonReentrant` guard, functions marked as * `nonReentrant` may not call one another. This can be worked around by making * those functions `private`, and then adding `external` `nonReentrant` entry * points to them. * * TIP: If you would like to learn more about reentrancy and alternative ways * to protect against it, check out our blog post * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul]. */ abstract contract ReentrancyGuard { // Booleans are more expensive than uint256 or any type that takes up a full // word because each write operation emits an extra SLOAD to first read the // slot's contents, replace the bits taken up by the boolean, and then write // back. This is the compiler's defense against contract upgrades and // pointer aliasing, and it cannot be disabled. // The values being non-zero value makes deployment a bit more expensive, // but in exchange the refund on every call to nonReentrant will be lower in // amount. Since refunds are capped to a percentage of the total // transaction's gas, it is best to keep them low in cases like this one, to // increase the likelihood of the full refund coming into effect. uint256 private constant _NOT_ENTERED = 1; uint256 private constant _ENTERED = 2; uint256 private _status; constructor() { _status = _NOT_ENTERED; } /** * @dev Prevents a contract from calling itself, directly or indirectly. * Calling a `nonReentrant` function from another `nonReentrant` * function is not supported. It is possible to prevent this from happening * by making the `nonReentrant` function external, and making it call a * `private` function that does the actual work. */ modifier nonReentrant() { _nonReentrantBefore(); _; _nonReentrantAfter(); } function _nonReentrantBefore() private { // On the first call to nonReentrant, _status will be _NOT_ENTERED require(_status != _ENTERED, "ReentrancyGuard: reentrant call"); // Any calls to nonReentrant after this point will fail _status = _ENTERED; } function _nonReentrantAfter() private { // By storing the original value once again, a refund is triggered (see // https://eips.ethereum.org/EIPS/eip-2200) _status = _NOT_ENTERED; } } // File @openzeppelin/contracts/utils/cryptography/[email protected] // OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/MerkleProof.sol) pragma solidity ^0.8.0; /** * @dev These functions deal with verification of Merkle Tree proofs. * * The tree and the proofs can be generated using our * https://github.com/OpenZeppelin/merkle-tree[JavaScript library]. * You will find a quickstart guide in the readme. * * WARNING: You should avoid using leaf values that are 64 bytes long prior to * hashing, or use a hash function other than keccak256 for hashing leaves. * This is because the concatenation of a sorted pair of internal nodes in * the merkle tree could be reinterpreted as a leaf value. * OpenZeppelin's JavaScript library generates merkle trees that are safe * against this attack out of the box. */ library MerkleProof { /** * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree * defined by `root`. For this, a `proof` must be provided, containing * sibling hashes on the branch from the leaf to the root of the tree. Each * pair of leaves and each pair of pre-images are assumed to be sorted. */ function verify( bytes32[] memory proof, bytes32 root, bytes32 leaf ) internal pure returns (bool) { return processProof(proof, leaf) == root; } /** * @dev Calldata version of {verify} * * _Available since v4.7._ */ function verifyCalldata( bytes32[] calldata proof, bytes32 root, bytes32 leaf ) internal pure returns (bool) { return processProofCalldata(proof, leaf) == root; } /** * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt * hash matches the root of the tree. When processing the proof, the pairs * of leafs & pre-images are assumed to be sorted. * * _Available since v4.4._ */ function processProof( bytes32[] memory proof, bytes32 leaf ) internal pure returns (bytes32) { bytes32 computedHash = leaf; for (uint256 i = 0; i < proof.length; i++) { computedHash = _hashPair(computedHash, proof[i]); } return computedHash; } /** * @dev Calldata version of {processProof} * * _Available since v4.7._ */ function processProofCalldata( bytes32[] calldata proof, bytes32 leaf ) internal pure returns (bytes32) { bytes32 computedHash = leaf; for (uint256 i = 0; i < proof.length; i++) { computedHash = _hashPair(computedHash, proof[i]); } return computedHash; } /** * @dev Returns true if the `leaves` can be simultaneously proven to be a part of a merkle tree defined by * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}. * * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details. * * _Available since v4.7._ */ function multiProofVerify( bytes32[] memory proof, bool[] memory proofFlags, bytes32 root, bytes32[] memory leaves ) internal pure returns (bool) { return processMultiProof(proof, proofFlags, leaves) == root; } /** * @dev Calldata version of {multiProofVerify} * * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details. * * _Available since v4.7._ */ function multiProofVerifyCalldata( bytes32[] calldata proof, bool[] calldata proofFlags, bytes32 root, bytes32[] memory leaves ) internal pure returns (bool) { return processMultiProofCalldata(proof, proofFlags, leaves) == root; } /** * @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another * leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false * respectively. * * CAUTION: Not all merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer). * * _Available since v4.7._ */ function processMultiProof( bytes32[] memory proof, bool[] memory proofFlags, bytes32[] memory leaves ) internal pure returns (bytes32 merkleRoot) { // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of // the merkle tree. uint256 leavesLen = leaves.length; uint256 totalHashes = proofFlags.length; // Check proof validity. require( leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof" ); // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop". bytes32[] memory hashes = new bytes32[](totalHashes); uint256 leafPos = 0; uint256 hashPos = 0; uint256 proofPos = 0; // At each step, we compute the next hash using two values: // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we // get the next hash. // - depending on the flag, either another value for the "main queue" (merging branches) or an element from the // `proof` array. for (uint256 i = 0; i < totalHashes; i++) { bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++]; bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++]; hashes[i] = _hashPair(a, b); } if (totalHashes > 0) { return hashes[totalHashes - 1]; } else if (leavesLen > 0) { return leaves[0]; } else { return proof[0]; } } /** * @dev Calldata version of {processMultiProof}. * * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details. * * _Available since v4.7._ */ function processMultiProofCalldata( bytes32[] calldata proof, bool[] calldata proofFlags, bytes32[] memory leaves ) internal pure returns (bytes32 merkleRoot) { // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of // the merkle tree. uint256 leavesLen = leaves.length; uint256 totalHashes = proofFlags.length; // Check proof validity. require( leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof" ); // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop". bytes32[] memory hashes = new bytes32[](totalHashes); uint256 leafPos = 0; uint256 hashPos = 0; uint256 proofPos = 0; // At each step, we compute the next hash using two values: // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we // get the next hash. // - depending on the flag, either another value for the "main queue" (merging branches) or an element from the // `proof` array. for (uint256 i = 0; i < totalHashes; i++) { bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++]; bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++]; hashes[i] = _hashPair(a, b); } if (totalHashes > 0) { return hashes[totalHashes - 1]; } else if (leavesLen > 0) { return leaves[0]; } else { return proof[0]; } } function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) { return a < b ? _efficientHash(a, b) : _efficientHash(b, a); } function _efficientHash( bytes32 a, bytes32 b ) private pure returns (bytes32 value) { /// @solidity memory-safe-assembly assembly { mstore(0x00, a) mstore(0x20, b) value := keccak256(0x00, 0x40) } } } // File contracts/utils/Errors.sol pragma solidity ^0.8.17; error MaxSupplyReached(); error AlreadyMinted(); error NotOnAllowlist(); error CannotMintFromContract(); error NotArtist(); error NoArtist(); error MaxArtistSupplyReached(); error CannotMintZero(); error MaxPublicSupplyReached(); // File contracts/xiiixiii_Decal.sol pragma solidity ^0.8.17; error TokenIdAlreadySet(); /// @author @0x__jj, @llio (Deca) contract xiiixiii_Decal is ERC721, ReentrancyGuard, AccessControl, Ownable { using Address for address; using Strings for *; event ArtistMinted(uint256 numberOfTokens, uint256 remainingArtistSupply); event TokenHashSet(uint256 indexed tokenId, bytes32 indexed tokenHash); mapping(address => bool) public minted; uint256 public totalSupply = 0; uint256 public constant MAX_SUPPLY = 100; bytes32 public merkleRoot; uint256 public artistMaxSupply; uint256 public artistSupply; address public artist; string public baseUri; mapping(uint256 => bytes32) public tokenIdToHash; constructor( string memory _baseUri, address[] memory _admins, uint256 _artistMaxSupply, address _artist ) ERC721("Decal by Michael Connolly", "DECAL") { if (_artistMaxSupply > MAX_SUPPLY) revert MaxSupplyReached(); _grantRole(DEFAULT_ADMIN_ROLE, msg.sender); for (uint256 i = 0; i < _admins.length; i++) { _grantRole(DEFAULT_ADMIN_ROLE, _admins[i]); } baseUri = _baseUri; artistMaxSupply = _artistMaxSupply; artist = _artist; } function setArtist(address _artist) external onlyRole(DEFAULT_ADMIN_ROLE) { artist = _artist; } function setArtistMaxSupply( uint256 _artistMaxSupply ) external onlyRole(DEFAULT_ADMIN_ROLE) { if ((_artistMaxSupply - artistSupply) > (MAX_SUPPLY - totalSupply)) revert MaxArtistSupplyReached(); artistMaxSupply = _artistMaxSupply; } function setMerkleRoot( bytes32 _merkleRoot ) external onlyRole(DEFAULT_ADMIN_ROLE) { merkleRoot = _merkleRoot; } function setBaseUri( string memory _newBaseUri ) external onlyRole(DEFAULT_ADMIN_ROLE) { baseUri = _newBaseUri; } function mint( bytes32[] calldata _merkleProof ) external nonReentrant returns (uint256 tokenId) { if (minted[msg.sender]) revert AlreadyMinted(); if (totalSupply >= MAX_SUPPLY) revert MaxSupplyReached(); if (publicSupplyRemaining() < 1) revert MaxPublicSupplyReached(); if (msg.sender.isContract()) revert CannotMintFromContract(); bytes32 leaf = keccak256(abi.encodePacked(msg.sender)); if (!MerkleProof.verify(_merkleProof, merkleRoot, leaf)) revert NotOnAllowlist(); tokenId = totalSupply; totalSupply++; minted[msg.sender] = true; _storeTokenHash(tokenId); _safeMint(msg.sender, tokenId); } function artistMintForAdmin( uint256 _numberOfTokens ) external nonReentrant onlyRole(DEFAULT_ADMIN_ROLE) { if (_numberOfTokens == 0) revert CannotMintZero(); if (artist == address(0)) revert NoArtist(); uint256 remaining = artistMaxSupply - artistSupply; if (remaining == 0) revert MaxArtistSupplyReached(); _numberOfTokens = uint256(Math.min(_numberOfTokens, remaining)); uint256 tokenId = totalSupply; for (uint256 i = 0; i < _numberOfTokens; i++) { _storeTokenHash(tokenId); _safeMint(artist, tokenId); tokenId++; } artistSupply += _numberOfTokens; totalSupply = tokenId; emit ArtistMinted(_numberOfTokens, remaining); } function artistMint(uint256 _numberOfTokens) external nonReentrant { if (_numberOfTokens == 0) revert CannotMintZero(); if (artist == address(0)) revert NoArtist(); if (msg.sender != artist) revert NotArtist(); uint256 remaining = artistMaxSupply - artistSupply; if (remaining == 0) revert MaxArtistSupplyReached(); _numberOfTokens = uint256(Math.min(_numberOfTokens, remaining)); uint256 tokenId = totalSupply; for (uint256 i = 0; i < _numberOfTokens; i++) { _storeTokenHash(tokenId); _safeMint(msg.sender, tokenId); tokenId++; } artistSupply += _numberOfTokens; totalSupply = tokenId; emit ArtistMinted(_numberOfTokens, remaining); } function publicSupplyRemaining() public view returns (uint256) { return MAX_SUPPLY - totalSupply - (artistMaxSupply - artistSupply); } function artistSupplyRemaining() external view returns (uint256) { return artistMaxSupply - artistSupply; } function tokenURI( uint256 _tokenId ) public view override(ERC721) returns (string memory) { require(_exists(_tokenId), "DECAL: URI query for nonexistent token"); string memory baseURI = _baseURI(); require(bytes(baseURI).length > 0, "baseURI not set"); return string(abi.encodePacked(baseURI, _tokenId.toString())); } function getTokensOfOwner( address owner_ ) external view returns (uint256[] memory) { uint256 tokenCount = balanceOf(owner_); uint256[] memory tokenIds = new uint256[](tokenCount); uint256 seen = 0; for (uint256 i = 0; i < totalSupply; i++) { if (ownerOf(i) == owner_) { tokenIds[seen] = i; seen++; } if (seen == tokenCount) break; } return tokenIds; } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface( bytes4 interfaceId ) public view virtual override(ERC721, AccessControl) returns (bool) { return super.supportsInterface(interfaceId); } function _storeTokenHash(uint256 tokenId) internal { if ( tokenIdToHash[tokenId] != bytes32( 0x0000000000000000000000000000000000000000000000000000000000000000 ) ) revert TokenIdAlreadySet(); // this check might be redundant tokenIdToHash[tokenId] = keccak256( abi.encodePacked(block.number, tokenId, block.timestamp) ); emit TokenHashSet(tokenId, tokenIdToHash[tokenId]); } function _baseURI() internal view override(ERC721) returns (string memory) { return baseUri; } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"string","name":"_baseUri","type":"string"},{"internalType":"address[]","name":"_admins","type":"address[]"},{"internalType":"uint256","name":"_artistMaxSupply","type":"uint256"},{"internalType":"address","name":"_artist","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AlreadyMinted","type":"error"},{"inputs":[],"name":"CannotMintFromContract","type":"error"},{"inputs":[],"name":"CannotMintZero","type":"error"},{"inputs":[],"name":"MaxArtistSupplyReached","type":"error"},{"inputs":[],"name":"MaxPublicSupplyReached","type":"error"},{"inputs":[],"name":"MaxSupplyReached","type":"error"},{"inputs":[],"name":"NoArtist","type":"error"},{"inputs":[],"name":"NotArtist","type":"error"},{"inputs":[],"name":"NotOnAllowlist","type":"error"},{"inputs":[],"name":"TokenIdAlreadySet","type":"error"},{"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":false,"internalType":"uint256","name":"numberOfTokens","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"remainingArtistSupply","type":"uint256"}],"name":"ArtistMinted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":true,"internalType":"bytes32","name":"tokenHash","type":"bytes32"}],"name":"TokenHashSet","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"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"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":[],"name":"artist","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"artistMaxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_numberOfTokens","type":"uint256"}],"name":"artistMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_numberOfTokens","type":"uint256"}],"name":"artistMintForAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"artistSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"artistSupplyRemaining","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseUri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner_","type":"address"}],"name":"getTokensOfOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"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":[],"name":"merkleRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"_merkleProof","type":"bytes32[]"}],"name":"mint","outputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"minted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"publicSupplyRemaining","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"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":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_artist","type":"address"}],"name":"setArtist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_artistMaxSupply","type":"uint256"}],"name":"setArtistMaxSupply","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newBaseUri","type":"string"}],"name":"setBaseUri","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"}],"name":"setMerkleRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"tokenIdToHash","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"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"}]
Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000001000000000000000000000000f92bb2215684c353b4009395061ee7652883c365000000000000000000000000000000000000000000000000000000000000003268747470733a2f2f636c69656e742d6170692e646563612e73797374656d732f646563616c2f6d657461646174612f32362f00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000a57ec3a618b6969a6b1fec2ef4bf54b2afc5ca30
-----Decoded View---------------
Arg [0] : _baseUri (string): https://client-api.deca.systems/decal/metadata/26/
Arg [1] : _admins (address[]): 0xA57ec3a618b6969a6B1fEc2eF4BF54B2AfC5ca30
Arg [2] : _artistMaxSupply (uint256): 1
Arg [3] : _artist (address): 0xf92BB2215684c353B4009395061EE7652883C365
-----Encoded View---------------
9 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000e0
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [3] : 000000000000000000000000f92bb2215684c353b4009395061ee7652883c365
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000032
Arg [5] : 68747470733a2f2f636c69656e742d6170692e646563612e73797374656d732f
Arg [6] : 646563616c2f6d657461646174612f32362f0000000000000000000000000000
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [8] : 000000000000000000000000a57ec3a618b6969a6b1fec2ef4bf54b2afc5ca30
Deployed Bytecode Sourcemap
74169:5758:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;79191:180;;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;79191:180:0;;;;;;;;47824:94;;;:::i;:::-;;;;;;;:::i;75416:262::-;;;;;;:::i;:::-;;:::i;:::-;;49261:171;;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1697:32:1;;;1679:51;;1667:2;1652:18;49261:171:0;1533:203:1;48821:382:0;;;;;;:::i;:::-;;:::i;74507:30::-;;;;;;;;;2324:25:1;;;2312:2;2297:18;74507:30:0;2178:177:1;74462:38:0;;;;;;:::i;:::-;;;;;;;;;;;;;;;;49955:328;;;;;;:::i;:::-;;:::i;23620:135::-;;;;;;:::i;:::-;;:::i;74591:25::-;;;;;;24039:156;;;;;;:::i;:::-;;:::i;74544:40::-;;74581:3;74544:40;;25143:229;;;;;;:::i;:::-;;:::i;50346:165::-;;;;;;:::i;:::-;;:::i;74694:21::-;;;;;-1:-1:-1;;;;;74694:21:0;;;78694:433;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;74750:48::-;;;;;;:::i;:::-;;;;;;;;;;;;;;47546:219;;;;;;:::i;:::-;;:::i;47285:207::-;;;;;;:::i;:::-;;:::i;29085:97::-;;;:::i;74623:30::-;;;;;;75684:129;;;;;;:::i;:::-;;:::i;74660:27::-;;;;;;28473:81;;;:::i;22244:156::-;;;;;;:::i;:::-;;:::i;47979:98::-;;;:::i;74722:21::-;;;:::i;76628:711::-;;;;;;:::i;:::-;;:::i;75819:129::-;;;;;;:::i;:::-;;:::i;21379:49::-;;21424:4;21379:49;;49496:164;;;;;;:::i;:::-;;:::i;78070:142::-;;;:::i;75954:668::-;;;;;;:::i;:::-;;:::i;50574:315::-;;;;;;:::i;:::-;;:::i;77345:719::-;;;;;;:::i;:::-;;:::i;78218:115::-;;;:::i;78339:349::-;;;;;;:::i;:::-;;:::i;75307:103::-;;;;;;:::i;:::-;;:::i;24464:158::-;;;;;;:::i;:::-;;:::i;49723:173::-;;;;;;:::i;:::-;;:::i;29327:191::-;;;;;;:::i;:::-;;:::i;79191:180::-;79309:4;79329:36;79353:11;79329:23;:36::i;:::-;79322:43;79191:180;-1:-1:-1;;79191:180:0:o;47824:94::-;47878:13;47907:5;47900:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47824:94;:::o;75416:262::-;21424:4;21844:16;21424:4;21844:10;:16::i;:::-;75579:11:::1;::::0;75566:24:::1;::::0;74581:3:::1;75566:24;:::i;:::-;75549:12;::::0;75530:31:::1;::::0;:16;:31:::1;:::i;:::-;75529:62;75525:106;;;75607:24;;-1:-1:-1::0;;;75607:24:0::1;;;;;;;;;;;75525:106;-1:-1:-1::0;75638:15:0::1;:34:::0;75416:262::o;49261:171::-;49347:7;49363:23;49378:7;49363:14;:23::i;:::-;-1:-1:-1;49402:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;49402:24:0;;49261:171::o;48821:382::-;48898:13;48914:23;48929:7;48914:14;:23::i;:::-;48898:39;;48958:5;-1:-1:-1;;;;;48952:11:0;:2;-1:-1:-1;;;;;48952:11:0;;48944:57;;;;-1:-1:-1;;;48944:57:0;;8133:2:1;48944:57:0;;;8115:21:1;8172:2;8152:18;;;8145:30;8211:34;8191:18;;;8184:62;-1:-1:-1;;;8262:18:1;;;8255:31;8303:19;;48944:57:0;;;;;;;;;3753:10;-1:-1:-1;;;;;49026:21:0;;;;:62;;-1:-1:-1;49051:37:0;49068:5;3753:10;49723:173;:::i;49051:37::-;49010:157;;;;-1:-1:-1;;;49010:157:0;;8535:2:1;49010:157:0;;;8517:21:1;8574:2;8554:18;;;8547:30;8613:34;8593:18;;;8586:62;8684:31;8664:18;;;8657:59;8733:19;;49010:157:0;8333:425:1;49010:157:0;49176:21;49185:2;49189:7;49176:8;:21::i;:::-;48891:312;48821:382;;:::o;49955:328::-;50136:41;3753:10;50169:7;50136:18;:41::i;:::-;50120:120;;;;-1:-1:-1;;;50120:120:0;;;;;;;:::i;:::-;50249:28;50259:4;50265:2;50269:7;50249:9;:28::i;23620:135::-;23704:7;23727:12;;;:6;:12;;;;;:22;;;;23620:135::o;24039:156::-;24137:18;24150:4;24137:12;:18::i;:::-;21844:16;21855:4;21844:10;:16::i;:::-;24164:25:::1;24175:4;24181:7;24164:10;:25::i;25143:229::-:0;-1:-1:-1;;;;;25243:23:0;;3753:10;25243:23;25227:104;;;;-1:-1:-1;;;25227:104:0;;9379:2:1;25227:104:0;;;9361:21:1;9418:2;9398:18;;;9391:30;9457:34;9437:18;;;9430:62;-1:-1:-1;;;9508:18:1;;;9501:45;9563:19;;25227:104:0;9177:411:1;25227:104:0;25340:26;25352:4;25358:7;25340:11;:26::i;:::-;25143:229;;:::o;50346:165::-;50466:39;50483:4;50489:2;50493:7;50466:39;;;;;;;;;;;;:16;:39::i;78694:433::-;78769:16;78794:18;78815:17;78825:6;78815:9;:17::i;:::-;78794:38;;78839:25;78881:10;-1:-1:-1;;;;;78867:25:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;78867:25:0;;78839:53;;78899:12;78927:9;78922:178;78946:11;;78942:1;:15;78922:178;;;78991:6;-1:-1:-1;;;;;78977:20:0;:10;78985:1;78977:7;:10::i;:::-;-1:-1:-1;;;;;78977:20:0;;78973:82;;79027:1;79010:8;79019:4;79010:14;;;;;;;;:::i;:::-;;;;;;;;;;:18;79039:6;;;;:::i;:::-;;;;78973:82;79063:29;;;79087:5;79063:29;78959:3;;;;:::i;:::-;;;;78922:178;;;-1:-1:-1;79113:8:0;;78694:433;-1:-1:-1;;;;78694:433:0:o;47546:219::-;47628:7;47644:13;47660:17;47669:7;47660:8;:17::i;:::-;47644:33;-1:-1:-1;;;;;;47692:19:0;;47684:56;;;;-1:-1:-1;;;47684:56:0;;;;;;;:::i;47285:207::-;47367:7;-1:-1:-1;;;;;47391:19:0;;47383:73;;;;-1:-1:-1;;;47383:73:0;;10420:2:1;47383:73:0;;;10402:21:1;10459:2;10439:18;;;10432:30;10498:34;10478:18;;;10471:62;-1:-1:-1;;;10549:18:1;;;10542:39;10598:19;;47383:73:0;10218:405:1;47383:73:0;-1:-1:-1;;;;;;47470:16:0;;;;;:9;:16;;;;;;;47285:207::o;29085:97::-;28373:13;:11;:13::i;:::-;29146:30:::1;29173:1;29146:18;:30::i;:::-;29085:97::o:0;75684:129::-;21424:4;21844:16;21424:4;21844:10;:16::i;:::-;-1:-1:-1;75783:10:0::1;:24:::0;75684:129::o;28473:81::-;28542:6;;-1:-1:-1;;;;;28542:6:0;;28473:81::o;22244:156::-;22345:4;22365:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;22365:29:0;;;;;;;;;;;;;;;22244:156::o;47979:98::-;48035:13;48064:7;48057:14;;;;;:::i;74722:21::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;76628:711::-;64100:21;:19;:21::i;:::-;21424:4:::1;21844:16;21424:4:::0;21844:10:::1;:16::i;:::-;76753:15:::2;76772:1;76753:20:::0;76749:49:::2;;76782:16;;-1:-1:-1::0;;;76782:16:0::2;;;;;;;;;;;76749:49;76809:6;::::0;-1:-1:-1;;;;;76809:6:0::2;76805:43;;76838:10;;-1:-1:-1::0;;;76838:10:0::2;;;;;;;;;;;76805:43;76855:17;76893:12;;76875:15;;:30;;;;:::i;:::-;76855:50;;76916:9;76929:1;76916:14:::0;76912:51:::2;;76939:24;;-1:-1:-1::0;;;76939:24:0::2;;;;;;;;;;;76912:51;76996:36;77005:15;77022:9;76996:8;:36::i;:::-;77058:11;::::0;76970:63;;-1:-1:-1;77040:15:0::2;77076:140;77100:15;77096:1;:19;77076:140;;;77131:24;77147:7;77131:15;:24::i;:::-;77174:6;::::0;77164:26:::2;::::0;-1:-1:-1;;;;;77174:6:0::2;77182:7:::0;77164:9:::2;:26::i;:::-;77199:9:::0;::::2;::::0;::::2;:::i;:::-;;;;77117:3;;;;;:::i;:::-;;;;77076:140;;;;77238:15;77222:12;;:31;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;77260:11:0::2;:21:::0;;;77293:40:::2;::::0;;10932:25:1;;;10988:2;10973:18;;10966:34;;;-1:-1:-1;;;;;;;;;;;77293:40:0;10905:18:1;77293:40:0::2;;;;;;;76742:597;;64128:1:::1;64136:20:::0;63570:1;64620:7;:22;64449:199;64136:20;76628:711;:::o;75819:129::-;21424:4;21844:16;21424:4;21844:10;:16::i;:::-;75921:7:::1;:21;75931:11:::0;75921:7;:21:::1;:::i;49496:164::-:0;49602:52;3753:10;49635:8;49645;49602:18;:52::i;78070:142::-;78124:7;78193:12;;78175:15;;:30;;;;:::i;:::-;78160:11;;78147:24;;74581:3;78147:24;:::i;:::-;:59;;;;:::i;:::-;78140:66;;78070:142;:::o;75954:668::-;76042:15;64100:21;:19;:21::i;:::-;76077:10:::1;76070:18;::::0;;;:6:::1;:18;::::0;;;;;::::1;;76066:46;;;76097:15;;-1:-1:-1::0;;;76097:15:0::1;;;;;;;;;;;76066:46;74581:3;76123:11;;:25;76119:56;;76157:18;;-1:-1:-1::0;;;76157:18:0::1;;;;;;;;;;;76119:56;76212:1;76186:23;:21;:23::i;:::-;:27;76182:64;;;76222:24;;-1:-1:-1::0;;;76222:24:0::1;;;;;;;;;;;76182:64;76257:23;:10;:21;:23::i;:::-;76253:60;;;76289:24;;-1:-1:-1::0;;;76289:24:0::1;;;;;;;;;;;76253:60;76345:28;::::0;-1:-1:-1;;;;;;76362:10:0::1;13389:2:1::0;13360:15;13356:45;76345:28:0::1;::::0;::::1;13344:58:1::0;76320:12:0::1;::::0;13418::1;;76345:28:0::1;;;;;;;;;;;;76335:39;;;;;;76320:54;;76386:50;76405:12;;76386:50;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;;76419:10:0::1;::::0;;-1:-1:-1;76431:4:0;;-1:-1:-1;76386:18:0::1;:50::i;:::-;76381:87;;76452:16;;-1:-1:-1::0;;;76452:16:0::1;;;;;;;;;;;76381:87;76485:11;::::0;;;-1:-1:-1;76485:11:0;;76503::::1;:13;76485:11:::0;76503:13:::1;:::i;:::-;::::0;;;-1:-1:-1;;76530:10:0::1;76523:18;::::0;;;:6:::1;:18;::::0;;;;:25;;-1:-1:-1;;76523:25:0::1;76544:4;76523:25;::::0;;76555:24:::1;76571:7:::0;76555:15:::1;:24::i;:::-;76586:30;76596:10;76608:7;76586:9;:30::i;:::-;76059:563;64136:20:::0;63570:1;64620:7;:22;64449:199;50574:315;50734:41;3753:10;50767:7;50734:18;:41::i;:::-;50718:120;;;;-1:-1:-1;;;50718:120:0;;;;;;;:::i;:::-;50845:38;50859:4;50865:2;50869:7;50878:4;50845:13;:38::i;:::-;50574:315;;;;:::o;77345:719::-;64100:21;:19;:21::i;:::-;77423:15:::1;77442:1;77423:20:::0;77419:49:::1;;77452:16;;-1:-1:-1::0;;;77452:16:0::1;;;;;;;;;;;77419:49;77479:6;::::0;-1:-1:-1;;;;;77479:6:0::1;77475:43;;77508:10;;-1:-1:-1::0;;;77508:10:0::1;;;;;;;;;;;77475:43;77543:6;::::0;-1:-1:-1;;;;;77543:6:0::1;77529:10;:20;77525:44;;77558:11;;-1:-1:-1::0;;;77558:11:0::1;;;;;;;;;;;77525:44;77576:17;77614:12;;77596:15;;:30;;;;:::i;:::-;77576:50;;77637:9;77650:1;77637:14:::0;77633:51:::1;;77660:24;;-1:-1:-1::0;;;77660:24:0::1;;;;;;;;;;;77633:51;77717:36;77726:15;77743:9;77717:8;:36::i;:::-;77779:11;::::0;77691:63;;-1:-1:-1;77761:15:0::1;77797:144;77821:15;77817:1;:19;77797:144;;;77852:24;77868:7;77852:15;:24::i;:::-;77885:30;77895:10;77907:7;77885:9;:30::i;:::-;77924:9:::0;::::1;::::0;::::1;:::i;:::-;;;;77838:3;;;;;:::i;:::-;;;;77797:144;;;;77963:15;77947:12;;:31;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;77985:11:0::1;:21:::0;;;78018:40:::1;::::0;;10932:25:1;;;10988:2;10973:18;;10966:34;;;-1:-1:-1;;;;;;;;;;;78018:40:0;10905:18:1;78018:40:0::1;;;;;;;77412:652;;64136:20:::0;63570:1;64620:7;:22;64449:199;78218:115;78274:7;78315:12;;78297:15;;:30;;;;:::i;78339:349::-;78423:13;78453:17;78461:8;78453:7;:17::i;:::-;78445:68;;;;-1:-1:-1;;;78445:68:0;;13643:2:1;78445:68:0;;;13625:21:1;13682:2;13662:18;;;13655:30;13721:34;13701:18;;;13694:62;-1:-1:-1;;;13772:18:1;;;13765:36;13818:19;;78445:68:0;13441:402:1;78445:68:0;78520:21;78544:10;:8;:10::i;:::-;78520:34;;78593:1;78575:7;78569:21;:25;78561:53;;;;-1:-1:-1;;;78561:53:0;;14050:2:1;78561:53:0;;;14032:21:1;14089:2;14069:18;;;14062:30;-1:-1:-1;;;14108:18:1;;;14101:45;14163:18;;78561:53:0;13848:339:1;78561:53:0;78652:7;78661:19;:8;:17;:19::i;:::-;78635:46;;;;;;;;;:::i;:::-;;;;;;;;;;;;;78621:61;;;78339:349;;;:::o;75307:103::-;21424:4;21844:16;21424:4;21844:10;:16::i;:::-;-1:-1:-1;75388:6:0::1;:16:::0;;-1:-1:-1;;;;;;75388:16:0::1;-1:-1:-1::0;;;;;75388:16:0;;;::::1;::::0;;;::::1;::::0;;75307:103::o;24464:158::-;24563:18;24576:4;24563:12;:18::i;:::-;21844:16;21855:4;21844:10;:16::i;:::-;24590:26:::1;24602:4;24608:7;24590:11;:26::i;49723:173::-:0;-1:-1:-1;;;;;49855:25:0;;;49835:4;49855:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;49723:173::o;29327:191::-;28373:13;:11;:13::i;:::-;-1:-1:-1;;;;;29412:22:0;::::1;29404:73;;;::::0;-1:-1:-1;;;29404:73:0;;14895:2:1;29404:73:0::1;::::0;::::1;14877:21:1::0;14934:2;14914:18;;;14907:30;14973:34;14953:18;;;14946:62;-1:-1:-1;;;15024:18:1;;;15017:36;15070:19;;29404:73:0::1;14693:402:1::0;29404:73:0::1;29484:28;29503:8;29484:18;:28::i;21938:222::-:0;22033:4;-1:-1:-1;;;;;;22060:47:0;;-1:-1:-1;;;22060:47:0;;:94;;;22118:36;22142:11;22118:23;:36::i;22686:99::-;22749:30;22760:4;3753:10;22749;:30::i;58522:129::-;58600:16;58608:7;58600;:16::i;:::-;58592:53;;;;-1:-1:-1;;;58592:53:0;;;;;;;:::i;57859:164::-;57930:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;57930:29:0;-1:-1:-1;;;;;57930:29:0;;;;;;;;:24;;57980:23;57930:24;57980:14;:23::i;:::-;-1:-1:-1;;;;;57971:46:0;;;;;;;;;;;57859:164;;:::o;52823:283::-;52931:4;52944:13;52960:23;52975:7;52960:14;:23::i;:::-;52944:39;;53009:5;-1:-1:-1;;;;;52998:16:0;:7;-1:-1:-1;;;;;52998:16:0;;:59;;;;53025:32;53042:5;53049:7;53025:16;:32::i;:::-;52998:101;;;;53092:7;-1:-1:-1;;;;;53068:31:0;:20;53080:7;53068:11;:20::i;:::-;-1:-1:-1;;;;;53068:31:0;;52998:101;52990:110;52823:283;-1:-1:-1;;;;52823:283:0:o;56553:1199::-;56702:4;-1:-1:-1;;;;;56675:31:0;:23;56690:7;56675:14;:23::i;:::-;-1:-1:-1;;;;;56675:31:0;;56659:102;;;;-1:-1:-1;;;56659:102:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;56776:16:0;;56768:65;;;;-1:-1:-1;;;56768:65:0;;15708:2:1;56768:65:0;;;15690:21:1;15747:2;15727:18;;;15720:30;15786:34;15766:18;;;15759:62;-1:-1:-1;;;15837:18:1;;;15830:34;15881:19;;56768:65:0;15506:400:1;56768:65:0;56842:42;56863:4;56869:2;56873:7;56882:1;56842:20;:42::i;:::-;57014:4;-1:-1:-1;;;;;56987:31:0;:23;57002:7;56987:14;:23::i;:::-;-1:-1:-1;;;;;56987:31:0;;56971:102;;;;-1:-1:-1;;;56971:102:0;;;;;;;:::i;:::-;57137:24;;;;:15;:24;;;;;;;;57130:31;;-1:-1:-1;;;;;;57130:31:0;;;;;;-1:-1:-1;;;;;57573:15:0;;;;;;:9;:15;;;;;:20;;-1:-1:-1;;57573:20:0;;;57602:13;;;;;;;;;:18;;57130:31;57602:18;;;57634:16;;;:7;:16;;;;;;:21;;;;;;;;;;57669:27;;57153:7;;-1:-1:-1;;;;;;;;;;;57669:27:0;;48891:312;48821:382;;:::o;26661:216::-;26741:22;26749:4;26755:7;26741;:22::i;:::-;26736:136;;26774:12;;;;:6;:12;;;;;;;;-1:-1:-1;;;;;26774:29:0;;;;;;;;;:36;;-1:-1:-1;;26774:36:0;26806:4;26774:36;;;26851:12;3753:10;;3677:92;26851:12;-1:-1:-1;;;;;26824:40:0;26842:7;-1:-1:-1;;;;;26824:40:0;26836:4;26824:40;;;;;;;;;;26661:216;;:::o;27041:217::-;27121:22;27129:4;27135:7;27121;:22::i;:::-;27117:136;;;27186:5;27154:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;27154:29:0;;;;;;;;;;:37;;-1:-1:-1;;27154:37:0;;;27205:40;3753:10;;27154:12;;27205:40;;27186:5;27205:40;27041:217;;:::o;52144:111::-;52210:7;52233:16;;;:7;:16;;;;;;-1:-1:-1;;;;;52233:16:0;;52144:111::o;28624:126::-;3753:10;28684:7;:5;:7::i;:::-;-1:-1:-1;;;;;28684:23:0;;28676:68;;;;-1:-1:-1;;;28676:68:0;;16113:2:1;28676:68:0;;;16095:21:1;;;16132:18;;;16125:30;16191:34;16171:18;;;16164:62;16243:18;;28676:68:0;15911:356:1;29668:177:0;29757:6;;;-1:-1:-1;;;;;29770:17:0;;;-1:-1:-1;;;;;;29770:17:0;;;;;;;29799:40;;29757:6;;;29770:17;29757:6;;29799:40;;29738:16;;29799:40;29731:114;29668:177;:::o;64168:275::-;63612:1;64294:7;;:19;64286:63;;;;-1:-1:-1;;;64286:63:0;;16474:2:1;64286:63:0;;;16456:21:1;16513:2;16493:18;;;16486:30;16552:33;16532:18;;;16525:61;16603:18;;64286:63:0;16272:355:1;64286:63:0;63612:1;64419:7;:18;64168:275::o;6411:100::-;6469:7;6496:1;6492;:5;:13;;6504:1;6492:13;;;6500:1;6492:13;6485:20;6411:100;-1:-1:-1;;;6411:100:0:o;79377:439::-;79498:66;79447:22;;;:13;:22;;;;;;:126;79435:172;;79588:19;;-1:-1:-1;;;79588:19:0;;;;;;;;;;;79435:172;79690:56;;;79707:12;79690:56;;;16817:19:1;16852:12;;;16845:28;;;79730:15:0;16889:12:1;;;16882:28;16926:12;;79690:56:0;;;-1:-1:-1;;79690:56:0;;;;;;;;;79672:81;;79690:56;79672:81;;;;79647:22;;;;:13;:22;;;;;;:106;;;79672:81;;79661:7;;79765:45;;;79377:439;:::o;53426:104::-;53498:26;53508:2;53512:7;53498:26;;;;;;;;;;;;:9;:26::i;58154:287::-;58291:8;-1:-1:-1;;;;;58282:17:0;:5;-1:-1:-1;;;;;58282:17:0;;58274:55;;;;-1:-1:-1;;;58274:55:0;;17151:2:1;58274:55:0;;;17133:21:1;17190:2;17170:18;;;17163:30;-1:-1:-1;;;17209:18:1;;;17202:55;17274:18;;58274:55:0;16949:349:1;58274:55:0;-1:-1:-1;;;;;58336:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;58336:46:0;;;;;;;;;;58394:41;;540::1;;;58394::0;;513:18:1;58394:41:0;;;;;;;58154:287;;;:::o;37732:308::-;-1:-1:-1;;;;;38011:19:0;;:23;;;37732:308::o;65867:170::-;65978:4;66027;65998:25;66011:5;66018:4;65998:12;:25::i;:::-;:33;;65867:170;-1:-1:-1;;;;65867:170:0:o;51732:306::-;51866:28;51876:4;51882:2;51886:7;51866:9;:28::i;:::-;51917:47;51940:4;51946:2;51950:7;51959:4;51917:22;:47::i;:::-;51901:131;;;;-1:-1:-1;;;51901:131:0;;;;;;;:::i;52550:122::-;52615:4;;52635:17;52644:7;52635:8;:17::i;:::-;-1:-1:-1;;;;;52635:31:0;;;;52550:122;-1:-1:-1;;52550:122:0:o;79822:102::-;79882:13;79911:7;79904:14;;;;;:::i;17730:586::-;17786:13;17827:14;17844:17;17855:5;17844:10;:17::i;:::-;17864:1;17844:21;17827:38;;17874:20;17908:6;-1:-1:-1;;;;;17897:18:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;17897:18:0;-1:-1:-1;17874:41:0;-1:-1:-1;18013:28:0;;;18029:2;18013:28;18058:224;-1:-1:-1;;18082:5:0;-1:-1:-1;;;18193:2:0;18182:14;;18177:30;18082:5;18164:44;18238:2;18229:11;;;-1:-1:-1;18251:21:0;18058:224;18251:21;-1:-1:-1;18297:6:0;17730:586;-1:-1:-1;;;17730:586:0:o;46938:291::-;47050:4;-1:-1:-1;;;;;;47077:40:0;;-1:-1:-1;;;47077:40:0;;:99;;-1:-1:-1;;;;;;;47128:48:0;;-1:-1:-1;;;47128:48:0;47077:99;:146;;;-1:-1:-1;;;;;;;;;;5754:40:0;;;47187:36;5639:161;23059:386;23144:22;23152:4;23158:7;23144;:22::i;:::-;23139:301;;23284:28;23304:7;23284:19;:28::i;:::-;23361:38;23389:4;23396:2;23361:19;:38::i;:::-;23213:199;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;23213:199:0;;;;;;;;;;-1:-1:-1;;;23177:255:0;;;;;;;:::i;60624:342::-;60792:1;60780:9;:13;60776:185;;;-1:-1:-1;;;;;60808:18:0;;;60804:73;;-1:-1:-1;;;;;60839:15:0;;;;;;:9;:15;;;;;:28;;60858:9;;60839:15;:28;;60858:9;;60839:28;:::i;:::-;;;;-1:-1:-1;;60804:73:0;-1:-1:-1;;;;;60889:16:0;;;60885:69;;-1:-1:-1;;;;;60918:13:0;;;;;;:9;:13;;;;;:26;;60935:9;;60918:13;:26;;60935:9;;60918:26;:::i;:::-;;;;-1:-1:-1;;60624:342:0;;;;:::o;53747:279::-;53858:18;53864:2;53868:7;53858:5;:18::i;:::-;53899:53;53930:1;53934:2;53938:7;53947:4;53899:22;:53::i;:::-;53883:137;;;;-1:-1:-1;;;53883:137:0;;;;;;;:::i;66664:287::-;66762:7;66801:4;66762:7;66812:108;66836:5;:12;66832:1;:16;66812:108;;;66879:33;66889:12;66903:5;66909:1;66903:8;;;;;;;;:::i;:::-;;;;;;;66879:9;:33::i;:::-;66864:48;-1:-1:-1;66850:3:0;;;;:::i;:::-;;;;66812:108;;;-1:-1:-1;66933:12:0;66664:287;-1:-1:-1;;;66664:287:0:o;59193:729::-;59329:4;59346:15;:2;-1:-1:-1;;;;;59346:13:0;;:15::i;:::-;59342:575;;;59385:71;;-1:-1:-1;;;59385:71:0;;-1:-1:-1;;;;;59385:36:0;;;;;:71;;3753:10;;59436:4;;59442:7;;59451:4;;59385:71;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;59385:71:0;;;;;;;;-1:-1:-1;;59385:71:0;;;;;;;;;;;;:::i;:::-;;;59372:504;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59611:6;:13;59628:1;59611:18;59607:260;;59644:60;;-1:-1:-1;;;59644:60:0;;;;;;;:::i;59607:260::-;59835:6;59829:13;59820:6;59816:2;59812:15;59805:38;59372:504;-1:-1:-1;;;;;;59506:51:0;-1:-1:-1;;;59506:51:0;;-1:-1:-1;59499:58:0;;59342:575;-1:-1:-1;59905:4:0;59193:729;;;;;;:::o;14973:742::-;15026:7;;-1:-1:-1;;;15090:17:0;;15086:84;;-1:-1:-1;;;15120:17:0;;;-1:-1:-1;15158:2:0;15148:12;15086:84;-1:-1:-1;;;15182:5:0;:17;15178:84;;-1:-1:-1;;;15212:17:0;;;-1:-1:-1;15250:2:0;15240:12;15178:84;15283:8;15274:5;:17;15270:84;;15313:8;15304:17;;;-1:-1:-1;15342:2:0;15332:12;15270:84;15375:7;15366:5;:16;15362:81;;15404:7;15395:16;;;-1:-1:-1;15432:1:0;15422:11;15362:81;15464:7;15455:5;:16;15451:81;;15493:7;15484:16;;;-1:-1:-1;15521:1:0;15511:11;15451:81;15553:7;15544:5;:16;15540:81;;15582:7;15573:16;;;-1:-1:-1;15610:1:0;15600:11;15540:81;15642:7;15633:5;:16;15629:54;;15672:1;15662:11;15703:6;14973:742;-1:-1:-1;;14973:742:0:o;19269:145::-;19327:13;19356:52;-1:-1:-1;;;;;19368:22:0;;17629:2;18700:420;18790:13;18812:19;18844:10;18848:6;18844:1;:10;:::i;:::-;:14;;18857:1;18844:14;:::i;:::-;-1:-1:-1;;;;;18834:25:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;18834:25:0;;18812:47;;-1:-1:-1;;;18866:6:0;18873:1;18866:9;;;;;;;;:::i;:::-;;;;:15;-1:-1:-1;;;;;18866:15:0;;;;;;;;;-1:-1:-1;;;18888:6:0;18895:1;18888:9;;;;;;;;:::i;:::-;;;;:15;-1:-1:-1;;;;;18888:15:0;;;;;;;;-1:-1:-1;18915:9:0;18927:10;18931:6;18927:1;:10;:::i;:::-;:14;;18940:1;18927:14;:::i;:::-;18915:26;;18910:115;18947:1;18943;:5;18910:115;;;-1:-1:-1;;;18985:5:0;18993:3;18985:11;18976:21;;;;;;;:::i;:::-;;;;18964:6;18971:1;18964:9;;;;;;;;:::i;:::-;;;;:33;-1:-1:-1;;;;;18964:33:0;;;;;;;;-1:-1:-1;19016:1:0;19006:11;;;;;18950:3;;;:::i;:::-;;;18910:115;;;-1:-1:-1;19039:10:0;;19031:55;;;;-1:-1:-1;;;19031:55:0;;19935:2:1;19031:55:0;;;19917:21:1;;;19954:18;;;19947:30;20013:34;19993:18;;;19986:62;20065:18;;19031:55:0;19733:356:1;54336:870:0;-1:-1:-1;;;;;54412:16:0;;54404:61;;;;-1:-1:-1;;;54404:61:0;;20296:2:1;54404:61:0;;;20278:21:1;;;20315:18;;;20308:30;20374:34;20354:18;;;20347:62;20426:18;;54404:61:0;20094:356:1;54404:61:0;54481:16;54489:7;54481;:16::i;:::-;54480:17;54472:58;;;;-1:-1:-1;;;54472:58:0;;;;;;;:::i;:::-;54539:48;54568:1;54572:2;54576:7;54585:1;54539:20;:48::i;:::-;54678:16;54686:7;54678;:16::i;:::-;54677:17;54669:58;;;;-1:-1:-1;;;54669:58:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;55042:13:0;;;;;;:9;:13;;;;;;;;:18;;55059:1;55042:18;;;55076:16;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;55076:21:0;;;;;55111:33;55084:7;;55042:13;;-1:-1:-1;;;;;;;;;;;55111:33:0;55042:13;;55111:33;25143:229;;:::o;73322:143::-;73385:7;73412:1;73408;:5;:51;;73554:13;73634:15;;;73664:4;73657:15;;;73705:4;73689:21;;73408:51;;;73554:13;73634:15;;;73664:4;73657:15;;;73705:4;73689:21;;73416:20;73471:251;14:131:1;-1:-1:-1;;;;;;88:32:1;;78:43;;68:71;;135:1;132;125:12;150:245;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;592:250::-;677:1;687:113;701:6;698:1;695:13;687:113;;;777:11;;;771:18;758:11;;;751:39;723:2;716:10;687:113;;;-1:-1:-1;;834:1:1;816:16;;809:27;592:250::o;847:271::-;889:3;927:5;921:12;954:6;949:3;942:19;970:76;1039:6;1032:4;1027:3;1023:14;1016:4;1009:5;1005:16;970:76;:::i;:::-;1100:2;1079:15;-1:-1:-1;;1075:29:1;1066:39;;;;1107:4;1062:50;;847:271;-1:-1:-1;;847:271:1:o;1123:220::-;1272:2;1261:9;1254:21;1235:4;1292:45;1333:2;1322:9;1318:18;1310:6;1292:45;:::i;1348:180::-;1407:6;1460:2;1448:9;1439:7;1435:23;1431:32;1428:52;;;1476:1;1473;1466:12;1428:52;-1:-1:-1;1499:23:1;;1348:180;-1:-1:-1;1348:180:1:o;1741:173::-;1809:20;;-1:-1:-1;;;;;1858:31:1;;1848:42;;1838:70;;1904:1;1901;1894:12;1838:70;1741:173;;;:::o;1919:254::-;1987:6;1995;2048:2;2036:9;2027:7;2023:23;2019:32;2016:52;;;2064:1;2061;2054:12;2016:52;2087:29;2106:9;2087:29;:::i;:::-;2077:39;2163:2;2148:18;;;;2135:32;;-1:-1:-1;;;1919:254:1:o;2360:186::-;2419:6;2472:2;2460:9;2451:7;2447:23;2443:32;2440:52;;;2488:1;2485;2478:12;2440:52;2511:29;2530:9;2511:29;:::i;2551:328::-;2628:6;2636;2644;2697:2;2685:9;2676:7;2672:23;2668:32;2665:52;;;2713:1;2710;2703:12;2665:52;2736:29;2755:9;2736:29;:::i;:::-;2726:39;;2784:38;2818:2;2807:9;2803:18;2784:38;:::i;:::-;2774:48;;2869:2;2858:9;2854:18;2841:32;2831:42;;2551:328;;;;;:::o;3251:254::-;3319:6;3327;3380:2;3368:9;3359:7;3355:23;3351:32;3348:52;;;3396:1;3393;3386:12;3348:52;3432:9;3419:23;3409:33;;3461:38;3495:2;3484:9;3480:18;3461:38;:::i;:::-;3451:48;;3251:254;;;;;:::o;3510:632::-;3681:2;3733:21;;;3803:13;;3706:18;;;3825:22;;;3652:4;;3681:2;3904:15;;;;3878:2;3863:18;;;3652:4;3947:169;3961:6;3958:1;3955:13;3947:169;;;4022:13;;4010:26;;4091:15;;;;4056:12;;;;3983:1;3976:9;3947:169;;;-1:-1:-1;4133:3:1;;3510:632;-1:-1:-1;;;;;;3510:632:1:o;4147:127::-;4208:10;4203:3;4199:20;4196:1;4189:31;4239:4;4236:1;4229:15;4263:4;4260:1;4253:15;4279:632;4344:5;-1:-1:-1;;;;;4404:14:1;;;4401:40;;;4421:18;;:::i;:::-;4496:2;4490:9;4464:2;4550:15;;-1:-1:-1;;4546:24:1;;;4572:2;4542:33;4538:42;4526:55;;;4596:18;;;4616:22;;;4593:46;4590:72;;;4642:18;;:::i;:::-;4682:10;4678:2;4671:22;4711:6;4702:15;;4741:6;4733;4726:22;4781:3;4772:6;4767:3;4763:16;4760:25;4757:45;;;4798:1;4795;4788:12;4757:45;4848:6;4843:3;4836:4;4828:6;4824:17;4811:44;4903:1;4896:4;4887:6;4879;4875:19;4871:30;4864:41;;;;4279:632;;;;;:::o;4916:451::-;4985:6;5038:2;5026:9;5017:7;5013:23;5009:32;5006:52;;;5054:1;5051;5044:12;5006:52;5081:23;;-1:-1:-1;;;;;5116:30:1;;5113:50;;;5159:1;5156;5149:12;5113:50;5182:22;;5235:4;5227:13;;5223:27;-1:-1:-1;5213:55:1;;5264:1;5261;5254:12;5213:55;5287:74;5353:7;5348:2;5335:16;5330:2;5326;5322:11;5287:74;:::i;5372:347::-;5437:6;5445;5498:2;5486:9;5477:7;5473:23;5469:32;5466:52;;;5514:1;5511;5504:12;5466:52;5537:29;5556:9;5537:29;:::i;:::-;5527:39;;5616:2;5605:9;5601:18;5588:32;5663:5;5656:13;5649:21;5642:5;5639:32;5629:60;;5685:1;5682;5675:12;5629:60;5708:5;5698:15;;;5372:347;;;;;:::o;5724:615::-;5810:6;5818;5871:2;5859:9;5850:7;5846:23;5842:32;5839:52;;;5887:1;5884;5877:12;5839:52;5914:23;;-1:-1:-1;;;;;5986:14:1;;;5983:34;;;6013:1;6010;6003:12;5983:34;6051:6;6040:9;6036:22;6026:32;;6096:7;6089:4;6085:2;6081:13;6077:27;6067:55;;6118:1;6115;6108:12;6067:55;6158:2;6145:16;6184:2;6176:6;6173:14;6170:34;;;6200:1;6197;6190:12;6170:34;6253:7;6248:2;6238:6;6235:1;6231:14;6227:2;6223:23;6219:32;6216:45;6213:65;;;6274:1;6271;6264:12;6213:65;6305:2;6297:11;;;;;6327:6;;-1:-1:-1;5724:615:1;;-1:-1:-1;;;;5724:615:1:o;6344:667::-;6439:6;6447;6455;6463;6516:3;6504:9;6495:7;6491:23;6487:33;6484:53;;;6533:1;6530;6523:12;6484:53;6556:29;6575:9;6556:29;:::i;:::-;6546:39;;6604:38;6638:2;6627:9;6623:18;6604:38;:::i;:::-;6594:48;-1:-1:-1;6689:2:1;6674:18;;6661:32;;-1:-1:-1;6744:2:1;6729:18;;6716:32;-1:-1:-1;;;;;6760:30:1;;6757:50;;;6803:1;6800;6793:12;6757:50;6826:22;;6879:4;6871:13;;6867:27;-1:-1:-1;6857:55:1;;6908:1;6905;6898:12;6857:55;6931:74;6997:7;6992:2;6979:16;6974:2;6970;6966:11;6931:74;:::i;:::-;6921:84;;;6344:667;;;;;;;:::o;7016:260::-;7084:6;7092;7145:2;7133:9;7124:7;7120:23;7116:32;7113:52;;;7161:1;7158;7151:12;7113:52;7184:29;7203:9;7184:29;:::i;:::-;7174:39;;7232:38;7266:2;7255:9;7251:18;7232:38;:::i;7281:380::-;7360:1;7356:12;;;;7403;;;7424:61;;7478:4;7470:6;7466:17;7456:27;;7424:61;7531:2;7523:6;7520:14;7500:18;7497:38;7494:161;;7577:10;7572:3;7568:20;7565:1;7558:31;7612:4;7609:1;7602:15;7640:4;7637:1;7630:15;7494:161;;7281:380;;;:::o;7666:127::-;7727:10;7722:3;7718:20;7715:1;7708:31;7758:4;7755:1;7748:15;7782:4;7779:1;7772:15;7798:128;7865:9;;;7886:11;;;7883:37;;;7900:18;;:::i;8763:409::-;8965:2;8947:21;;;9004:2;8984:18;;;8977:30;9043:34;9038:2;9023:18;;9016:62;-1:-1:-1;;;9109:2:1;9094:18;;9087:43;9162:3;9147:19;;8763:409::o;9593:127::-;9654:10;9649:3;9645:20;9642:1;9635:31;9685:4;9682:1;9675:15;9709:4;9706:1;9699:15;9725:135;9764:3;9785:17;;;9782:43;;9805:18;;:::i;:::-;-1:-1:-1;9852:1:1;9841:13;;9725:135::o;9865:348::-;10067:2;10049:21;;;10106:2;10086:18;;;10079:30;-1:-1:-1;;;10140:2:1;10125:18;;10118:54;10204:2;10189:18;;9865:348::o;10628:125::-;10693:9;;;10714:10;;;10711:36;;;10727:18;;:::i;11137:545::-;11239:2;11234:3;11231:11;11228:448;;;11275:1;11300:5;11296:2;11289:17;11345:4;11341:2;11331:19;11415:2;11403:10;11399:19;11396:1;11392:27;11386:4;11382:38;11451:4;11439:10;11436:20;11433:47;;;-1:-1:-1;11474:4:1;11433:47;11529:2;11524:3;11520:12;11517:1;11513:20;11507:4;11503:31;11493:41;;11584:82;11602:2;11595:5;11592:13;11584:82;;;11647:17;;;11628:1;11617:13;11584:82;;;11588:3;;;11137:545;;;:::o;11858:1352::-;11978:10;;-1:-1:-1;;;;;12000:30:1;;11997:56;;;12033:18;;:::i;:::-;12062:97;12152:6;12112:38;12144:4;12138:11;12112:38;:::i;:::-;12106:4;12062:97;:::i;:::-;12214:4;;12278:2;12267:14;;12295:1;12290:663;;;;12997:1;13014:6;13011:89;;;-1:-1:-1;13066:19:1;;;13060:26;13011:89;-1:-1:-1;;11815:1:1;11811:11;;;11807:24;11803:29;11793:40;11839:1;11835:11;;;11790:57;13113:81;;12260:944;;12290:663;11084:1;11077:14;;;11121:4;11108:18;;-1:-1:-1;;12326:20:1;;;12444:236;12458:7;12455:1;12452:14;12444:236;;;12547:19;;;12541:26;12526:42;;12639:27;;;;12607:1;12595:14;;;;12474:19;;12444:236;;;12448:3;12708:6;12699:7;12696:19;12693:201;;;12769:19;;;12763:26;-1:-1:-1;;12852:1:1;12848:14;;;12864:3;12844:24;12840:37;12836:42;12821:58;12806:74;;12693:201;-1:-1:-1;;;;;12940:1:1;12924:14;;;12920:22;12907:36;;-1:-1:-1;11858:1352:1:o;14192:496::-;14371:3;14409:6;14403:13;14425:66;14484:6;14479:3;14472:4;14464:6;14460:17;14425:66;:::i;:::-;14554:13;;14513:16;;;;14576:70;14554:13;14513:16;14623:4;14611:17;;14576:70;:::i;:::-;14662:20;;14192:496;-1:-1:-1;;;;14192:496:1:o;15100:401::-;15302:2;15284:21;;;15341:2;15321:18;;;15314:30;15380:34;15375:2;15360:18;;15353:62;-1:-1:-1;;;15446:2:1;15431:18;;15424:35;15491:3;15476:19;;15100:401::o;17303:414::-;17505:2;17487:21;;;17544:2;17524:18;;;17517:30;17583:34;17578:2;17563:18;;17556:62;-1:-1:-1;;;17649:2:1;17634:18;;17627:48;17707:3;17692:19;;17303:414::o;17854:812::-;-1:-1:-1;;;18260:3:1;18253:38;18235:3;18320:6;18314:13;18336:75;18404:6;18399:2;18394:3;18390:12;18383:4;18375:6;18371:17;18336:75;:::i;:::-;-1:-1:-1;;;18470:2:1;18430:16;;;18462:11;;;18455:40;18520:13;;18542:76;18520:13;18604:2;18596:11;;18589:4;18577:17;;18542:76;:::i;:::-;18638:17;18657:2;18634:26;;17854:812;-1:-1:-1;;;;17854:812:1:o;18671:489::-;-1:-1:-1;;;;;18940:15:1;;;18922:34;;18992:15;;18987:2;18972:18;;18965:43;19039:2;19024:18;;19017:34;;;19087:3;19082:2;19067:18;;19060:31;;;18865:4;;19108:46;;19134:19;;19126:6;19108:46;:::i;:::-;19100:54;18671:489;-1:-1:-1;;;;;;18671:489:1:o;19165:249::-;19234:6;19287:2;19275:9;19266:7;19262:23;19258:32;19255:52;;;19303:1;19300;19293:12;19255:52;19335:9;19329:16;19354:30;19378:5;19354:30;:::i;19419:168::-;19492:9;;;19523;;19540:15;;;19534:22;;19520:37;19510:71;;19561:18;;:::i;19592:136::-;19631:3;19659:5;19649:39;;19668:18;;:::i;:::-;-1:-1:-1;;;19704:18:1;;19592:136::o;20455:352::-;20657:2;20639:21;;;20696:2;20676:18;;;20669:30;-1:-1:-1;;;20730:2:1;20715:18;;20708:58;20798:2;20783:18;;20455:352::o
Swarm Source
ipfs://c6b9d2da97314c8bdb10c6ce747d698cb535605bb8203542dd6624df87340310
Loading...
Loading
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.