ERC-721
Overview
Max Total Supply
1,839 CSC
Holders
1,638
Market
Volume (24H)
N/A
Min Price (24H)
N/A
Max Price (24H)
N/A
Other Info
Token Contract
Balance
1 CSCLoading...
Loading
Loading...
Loading
Loading...
Loading
# | Exchange | Pair | Price | 24H Volume | % Volume |
---|
This contract may be a proxy contract. Click on More Options and select Is this a proxy? to confirm and enable the "Read as Proxy" & "Write as Proxy" tabs.
Contract Name:
Collections
Compiler Version
v0.6.8+commit.0bbfe453
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2020-06-22 */ /* * Crypto stamp Collections Factory * Factory and core ERC721 contract for the Collections of ERC721 and ERC1155 assets, * for example digital-physical collectible postage stamps * * Developed by Capacity Blockchain Solutions GmbH <capacity.at> * for Österreichische Post AG <post.at> */ // File: @openzeppelin/contracts/GSN/Context.sol pragma solidity ^0.6.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 GSN 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. */ contract Context { // Empty internal constructor, to prevent people from mistakenly deploying // an instance of this contract, which should be used via inheritance. constructor () internal { } function _msgSender() internal view virtual returns (address payable) { return msg.sender; } function _msgData() internal view virtual returns (bytes memory) { this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691 return msg.data; } } // File: @openzeppelin/contracts/introspection/IERC165.sol pragma solidity ^0.6.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/token/ERC721/IERC721.sol pragma solidity ^0.6.2; /** * @dev Required interface of an ERC721 compliant contract. */ interface IERC721 is IERC165 { /** * @dev Emitted when `tokenId` token is transfered 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`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * Requirements: * * - `from`, `to` cannot be zero. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be 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: Usage of this method is discouraged, use {safeTransferFrom} whenever possible. * * Requirements: * * - `from`, `to` cannot be zero. * - `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 Returns the account approved for `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function getApproved(uint256 tokenId) external view returns (address operator); /** * @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 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); /** * @dev Safely transfers `tokenId` token from `from` to `to`. * * Requirements: * * - `from`, `to` cannot be zero. * - `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; } // File: @openzeppelin/contracts/token/ERC721/IERC721Metadata.sol pragma solidity ^0.6.2; /** * @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/IERC721Enumerable.sol pragma solidity ^0.6.2; /** * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721Enumerable is IERC721 { /** * @dev Returns the total amount of tokens stored by the contract. */ function totalSupply() external view returns (uint256); /** * @dev Returns a token ID owned by `owner` at a given `index` of its token list. * Use along with {balanceOf} to enumerate all of ``owner``'s tokens. */ function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId); /** * @dev Returns a token ID at a given `index` of all the tokens stored by the contract. * Use along with {totalSupply} to enumerate all tokens. */ function tokenByIndex(uint256 index) external view returns (uint256); } // File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol pragma solidity ^0.6.0; /** * @title ERC721 token receiver interface * @dev Interface for any contract that wants to support safeTransfers * from ERC721 asset contracts. */ abstract contract IERC721Receiver { /** * @notice Handle the receipt of an NFT * @dev The ERC721 smart contract calls this function on the recipient * after a {IERC721-safeTransferFrom}. This function MUST return the function selector, * otherwise the caller will revert the transaction. The selector to be * returned can be obtained as `this.onERC721Received.selector`. This * function MAY throw to revert and reject the transfer. * Note: the ERC721 contract address is always the message sender. * @param operator The address which called `safeTransferFrom` function * @param from The address which previously owned the token * @param tokenId The NFT identifier which is being transferred * @param data Additional data with no specified format * @return bytes4 `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))` */ function onERC721Received(address operator, address from, uint256 tokenId, bytes memory data) public virtual returns (bytes4); } // File: @openzeppelin/contracts/introspection/ERC165.sol pragma solidity ^0.6.0; /** * @dev Implementation of the {IERC165} interface. * * Contracts may inherit from this and call {_registerInterface} to declare * their support of an interface. */ contract ERC165 is IERC165 { /* * bytes4(keccak256('supportsInterface(bytes4)')) == 0x01ffc9a7 */ bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7; /** * @dev Mapping of interface ids to whether or not it's supported. */ mapping(bytes4 => bool) private _supportedInterfaces; constructor () internal { // Derived contracts need only register support for their own interfaces, // we register support for ERC165 itself here _registerInterface(_INTERFACE_ID_ERC165); } /** * @dev See {IERC165-supportsInterface}. * * Time complexity O(1), guaranteed to always use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) public view override returns (bool) { return _supportedInterfaces[interfaceId]; } /** * @dev Registers the contract as an implementer of the interface defined by * `interfaceId`. Support of the actual ERC165 interface is automatic and * registering its interface id is not required. * * See {IERC165-supportsInterface}. * * Requirements: * * - `interfaceId` cannot be the ERC165 invalid interface (`0xffffffff`). */ function _registerInterface(bytes4 interfaceId) internal virtual { require(interfaceId != 0xffffffff, "ERC165: invalid interface id"); _supportedInterfaces[interfaceId] = true; } } // File: @openzeppelin/contracts/math/SafeMath.sol pragma solidity ^0.6.0; /** * @dev Wrappers over Solidity's arithmetic operations with added overflow * checks. * * Arithmetic operations in Solidity wrap on overflow. This can easily result * in bugs, because programmers usually assume that an overflow raises an * error, which is the standard behavior in high level programming languages. * `SafeMath` restores this intuition by reverting the transaction when an * operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. */ library SafeMath { /** * @dev Returns the addition of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `+` operator. * * Requirements: * - Addition cannot overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } /** * @dev Returns the subtraction of two unsigned integers, reverting on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } /** * @dev Returns the multiplication of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `*` operator. * * Requirements: * - Multiplication cannot overflow. */ function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } /** * @dev Returns the integer division of two unsigned integers. Reverts on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } /** * @dev Returns the integer division of two unsigned integers. Reverts with custom message on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * - The divisor cannot be zero. */ function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { // Solidity only automatically asserts when dividing by 0 require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * Reverts when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * Reverts with custom message when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } } // File: @openzeppelin/contracts/utils/Address.sol pragma solidity ^0.6.2; /** * @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 * ==== */ function isContract(address account) internal view returns (bool) { // According to EIP-1052, 0x0 is the value returned for not-yet created accounts // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned // for accounts without code, i.e. `keccak256('')` bytes32 codehash; bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; // solhint-disable-next-line no-inline-assembly assembly { codehash := extcodehash(account) } return (codehash != accountHash && codehash != 0x0); } /** * @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"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success, ) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } } // File: @openzeppelin/contracts/utils/EnumerableSet.sol pragma solidity ^0.6.0; /** * @dev Library for managing * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive * types. * * Sets have the following properties: * * - Elements are added, removed, and checked for existence in constant time * (O(1)). * - Elements are enumerated in O(n). No guarantees are made on the ordering. * * ``` * contract Example { * // Add the library methods * using EnumerableSet for EnumerableSet.AddressSet; * * // Declare a set state variable * EnumerableSet.AddressSet private mySet; * } * ``` * * As of v3.0.0, only sets of type `address` (`AddressSet`) and `uint256` * (`UintSet`) are supported. */ library EnumerableSet { // To implement this library for multiple types with as little code // repetition as possible, we write it in terms of a generic Set type with // bytes32 values. // The Set implementation uses private functions, and user-facing // implementations (such as AddressSet) are just wrappers around the // underlying Set. // This means that we can only create new EnumerableSets for types that fit // in bytes32. struct Set { // Storage of set values bytes32[] _values; // Position of the value in the `values` array, plus 1 because index 0 // means a value is not in the set. mapping (bytes32 => uint256) _indexes; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function _add(Set storage set, bytes32 value) private returns (bool) { if (!_contains(set, value)) { set._values.push(value); // The value is stored at length-1, but we add 1 to all indexes // and use 0 as a sentinel value set._indexes[value] = set._values.length; return true; } else { return false; } } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function _remove(Set storage set, bytes32 value) private returns (bool) { // We read and store the value's index to prevent multiple reads from the same storage slot uint256 valueIndex = set._indexes[value]; if (valueIndex != 0) { // Equivalent to contains(set, value) // To delete an element from the _values array in O(1), we swap the element to delete with the last one in // the array, and then remove the last element (sometimes called as 'swap and pop'). // This modifies the order of the array, as noted in {at}. uint256 toDeleteIndex = valueIndex - 1; uint256 lastIndex = set._values.length - 1; // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement. bytes32 lastvalue = set._values[lastIndex]; // Move the last value to the index where the value to delete is set._values[toDeleteIndex] = lastvalue; // Update the index for the moved value set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based // Delete the slot where the moved value was stored set._values.pop(); // Delete the index for the deleted slot delete set._indexes[value]; return true; } else { return false; } } /** * @dev Returns true if the value is in the set. O(1). */ function _contains(Set storage set, bytes32 value) private view returns (bool) { return set._indexes[value] != 0; } /** * @dev Returns the number of values on the set. O(1). */ function _length(Set storage set) private view returns (uint256) { return set._values.length; } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function _at(Set storage set, uint256 index) private view returns (bytes32) { require(set._values.length > index, "EnumerableSet: index out of bounds"); return set._values[index]; } // AddressSet struct AddressSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(AddressSet storage set, address value) internal returns (bool) { return _add(set._inner, bytes32(uint256(value))); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(AddressSet storage set, address value) internal returns (bool) { return _remove(set._inner, bytes32(uint256(value))); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(AddressSet storage set, address value) internal view returns (bool) { return _contains(set._inner, bytes32(uint256(value))); } /** * @dev Returns the number of values in the set. O(1). */ function length(AddressSet storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(AddressSet storage set, uint256 index) internal view returns (address) { return address(uint256(_at(set._inner, index))); } // UintSet struct UintSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(UintSet storage set, uint256 value) internal returns (bool) { return _add(set._inner, bytes32(value)); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(UintSet storage set, uint256 value) internal returns (bool) { return _remove(set._inner, bytes32(value)); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(UintSet storage set, uint256 value) internal view returns (bool) { return _contains(set._inner, bytes32(value)); } /** * @dev Returns the number of values on the set. O(1). */ function length(UintSet storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(UintSet storage set, uint256 index) internal view returns (uint256) { return uint256(_at(set._inner, index)); } } // File: @openzeppelin/contracts/utils/EnumerableMap.sol pragma solidity ^0.6.0; /** * @dev Library for managing an enumerable variant of Solidity's * https://solidity.readthedocs.io/en/latest/types.html#mapping-types[`mapping`] * type. * * Maps have the following properties: * * - Entries are added, removed, and checked for existence in constant time * (O(1)). * - Entries are enumerated in O(n). No guarantees are made on the ordering. * * ``` * contract Example { * // Add the library methods * using EnumerableMap for EnumerableMap.UintToAddressMap; * * // Declare a set state variable * EnumerableMap.UintToAddressMap private myMap; * } * ``` * * As of v3.0.0, only maps of type `uint256 -> address` (`UintToAddressMap`) are * supported. */ library EnumerableMap { // To implement this library for multiple types with as little code // repetition as possible, we write it in terms of a generic Map type with // bytes32 keys and values. // The Map implementation uses private functions, and user-facing // implementations (such as Uint256ToAddressMap) are just wrappers around // the underlying Map. // This means that we can only create new EnumerableMaps for types that fit // in bytes32. struct MapEntry { bytes32 _key; bytes32 _value; } struct Map { // Storage of map keys and values MapEntry[] _entries; // Position of the entry defined by a key in the `entries` array, plus 1 // because index 0 means a key is not in the map. mapping (bytes32 => uint256) _indexes; } /** * @dev Adds a key-value pair to a map, or updates the value for an existing * key. O(1). * * Returns true if the key was added to the map, that is if it was not * already present. */ function _set(Map storage map, bytes32 key, bytes32 value) private returns (bool) { // We read and store the key's index to prevent multiple reads from the same storage slot uint256 keyIndex = map._indexes[key]; if (keyIndex == 0) { // Equivalent to !contains(map, key) map._entries.push(MapEntry({ _key: key, _value: value })); // The entry is stored at length-1, but we add 1 to all indexes // and use 0 as a sentinel value map._indexes[key] = map._entries.length; return true; } else { map._entries[keyIndex - 1]._value = value; return false; } } /** * @dev Removes a key-value pair from a map. O(1). * * Returns true if the key was removed from the map, that is if it was present. */ function _remove(Map storage map, bytes32 key) private returns (bool) { // We read and store the key's index to prevent multiple reads from the same storage slot uint256 keyIndex = map._indexes[key]; if (keyIndex != 0) { // Equivalent to contains(map, key) // To delete a key-value pair from the _entries array in O(1), we swap the entry to delete with the last one // in the array, and then remove the last entry (sometimes called as 'swap and pop'). // This modifies the order of the array, as noted in {at}. uint256 toDeleteIndex = keyIndex - 1; uint256 lastIndex = map._entries.length - 1; // When the entry to delete is the last one, the swap operation is unnecessary. However, since this occurs // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement. MapEntry storage lastEntry = map._entries[lastIndex]; // Move the last entry to the index where the entry to delete is map._entries[toDeleteIndex] = lastEntry; // Update the index for the moved entry map._indexes[lastEntry._key] = toDeleteIndex + 1; // All indexes are 1-based // Delete the slot where the moved entry was stored map._entries.pop(); // Delete the index for the deleted slot delete map._indexes[key]; return true; } else { return false; } } /** * @dev Returns true if the key is in the map. O(1). */ function _contains(Map storage map, bytes32 key) private view returns (bool) { return map._indexes[key] != 0; } /** * @dev Returns the number of key-value pairs in the map. O(1). */ function _length(Map storage map) private view returns (uint256) { return map._entries.length; } /** * @dev Returns the key-value pair stored at position `index` in the map. O(1). * * Note that there are no guarantees on the ordering of entries inside the * array, and it may change when more entries are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function _at(Map storage map, uint256 index) private view returns (bytes32, bytes32) { require(map._entries.length > index, "EnumerableMap: index out of bounds"); MapEntry storage entry = map._entries[index]; return (entry._key, entry._value); } /** * @dev Returns the value associated with `key`. O(1). * * Requirements: * * - `key` must be in the map. */ function _get(Map storage map, bytes32 key) private view returns (bytes32) { return _get(map, key, "EnumerableMap: nonexistent key"); } /** * @dev Same as {_get}, with a custom error message when `key` is not in the map. */ function _get(Map storage map, bytes32 key, string memory errorMessage) private view returns (bytes32) { uint256 keyIndex = map._indexes[key]; require(keyIndex != 0, errorMessage); // Equivalent to contains(map, key) return map._entries[keyIndex - 1]._value; // All indexes are 1-based } // UintToAddressMap struct UintToAddressMap { Map _inner; } /** * @dev Adds a key-value pair to a map, or updates the value for an existing * key. O(1). * * Returns true if the key was added to the map, that is if it was not * already present. */ function set(UintToAddressMap storage map, uint256 key, address value) internal returns (bool) { return _set(map._inner, bytes32(key), bytes32(uint256(value))); } /** * @dev Removes a value from a set. O(1). * * Returns true if the key was removed from the map, that is if it was present. */ function remove(UintToAddressMap storage map, uint256 key) internal returns (bool) { return _remove(map._inner, bytes32(key)); } /** * @dev Returns true if the key is in the map. O(1). */ function contains(UintToAddressMap storage map, uint256 key) internal view returns (bool) { return _contains(map._inner, bytes32(key)); } /** * @dev Returns the number of elements in the map. O(1). */ function length(UintToAddressMap storage map) internal view returns (uint256) { return _length(map._inner); } /** * @dev Returns the element stored at position `index` in the set. O(1). * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(UintToAddressMap storage map, uint256 index) internal view returns (uint256, address) { (bytes32 key, bytes32 value) = _at(map._inner, index); return (uint256(key), address(uint256(value))); } /** * @dev Returns the value associated with `key`. O(1). * * Requirements: * * - `key` must be in the map. */ function get(UintToAddressMap storage map, uint256 key) internal view returns (address) { return address(uint256(_get(map._inner, bytes32(key)))); } /** * @dev Same as {get}, with a custom error message when `key` is not in the map. */ function get(UintToAddressMap storage map, uint256 key, string memory errorMessage) internal view returns (address) { return address(uint256(_get(map._inner, bytes32(key), errorMessage))); } } // File: @openzeppelin/contracts/utils/Strings.sol pragma solidity ^0.6.0; /** * @dev String operations. */ library Strings { /** * @dev Converts a `uint256` to its ASCII `string` representation. */ function toString(uint256 value) internal pure returns (string memory) { // Inspired by OraclizeAPI's implementation - MIT licence // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol if (value == 0) { return "0"; } uint256 temp = value; uint256 digits; while (temp != 0) { digits++; temp /= 10; } bytes memory buffer = new bytes(digits); uint256 index = digits - 1; temp = value; while (temp != 0) { buffer[index--] = byte(uint8(48 + temp % 10)); temp /= 10; } return string(buffer); } } // File: @openzeppelin/contracts/token/ERC721/ERC721.sol pragma solidity ^0.6.0; /** * @title ERC721 Non-Fungible Token Standard basic implementation * @dev see https://eips.ethereum.org/EIPS/eip-721 */ contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable { using SafeMath for uint256; using Address for address; using EnumerableSet for EnumerableSet.UintSet; using EnumerableMap for EnumerableMap.UintToAddressMap; using Strings for uint256; // Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))` // which can be also obtained as `IERC721Receiver(0).onERC721Received.selector` bytes4 private constant _ERC721_RECEIVED = 0x150b7a02; // Mapping from holder address to their (enumerable) set of owned tokens mapping (address => EnumerableSet.UintSet) private _holderTokens; // Enumerable mapping from token ids to their owners EnumerableMap.UintToAddressMap private _tokenOwners; // 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; // Token name string private _name; // Token symbol string private _symbol; // Optional mapping for token URIs mapping(uint256 => string) private _tokenURIs; // Base URI string private _baseURI; /* * bytes4(keccak256('balanceOf(address)')) == 0x70a08231 * bytes4(keccak256('ownerOf(uint256)')) == 0x6352211e * bytes4(keccak256('approve(address,uint256)')) == 0x095ea7b3 * bytes4(keccak256('getApproved(uint256)')) == 0x081812fc * bytes4(keccak256('setApprovalForAll(address,bool)')) == 0xa22cb465 * bytes4(keccak256('isApprovedForAll(address,address)')) == 0xe985e9c5 * bytes4(keccak256('transferFrom(address,address,uint256)')) == 0x23b872dd * bytes4(keccak256('safeTransferFrom(address,address,uint256)')) == 0x42842e0e * bytes4(keccak256('safeTransferFrom(address,address,uint256,bytes)')) == 0xb88d4fde * * => 0x70a08231 ^ 0x6352211e ^ 0x095ea7b3 ^ 0x081812fc ^ * 0xa22cb465 ^ 0xe985e9c ^ 0x23b872dd ^ 0x42842e0e ^ 0xb88d4fde == 0x80ac58cd */ bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd; /* * bytes4(keccak256('name()')) == 0x06fdde03 * bytes4(keccak256('symbol()')) == 0x95d89b41 * bytes4(keccak256('tokenURI(uint256)')) == 0xc87b56dd * * => 0x06fdde03 ^ 0x95d89b41 ^ 0xc87b56dd == 0x5b5e139f */ bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f; /* * bytes4(keccak256('totalSupply()')) == 0x18160ddd * bytes4(keccak256('tokenOfOwnerByIndex(address,uint256)')) == 0x2f745c59 * bytes4(keccak256('tokenByIndex(uint256)')) == 0x4f6ccce7 * * => 0x18160ddd ^ 0x2f745c59 ^ 0x4f6ccce7 == 0x780e9d63 */ bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63; constructor (string memory name, string memory symbol) public { _name = name; _symbol = symbol; // register the supported interfaces to conform to ERC721 via ERC165 _registerInterface(_INTERFACE_ID_ERC721); _registerInterface(_INTERFACE_ID_ERC721_METADATA); _registerInterface(_INTERFACE_ID_ERC721_ENUMERABLE); } /** * @dev Gets the balance of the specified address. * @param owner address to query the balance of * @return uint256 representing the amount owned by the passed address */ function balanceOf(address owner) public view override returns (uint256) { require(owner != address(0), "ERC721: balance query for the zero address"); return _holderTokens[owner].length(); } /** * @dev Gets the owner of the specified token ID. * @param tokenId uint256 ID of the token to query the owner of * @return address currently marked as the owner of the given token ID */ function ownerOf(uint256 tokenId) public view override returns (address) { return _tokenOwners.get(tokenId, "ERC721: owner query for nonexistent token"); } /** * @dev Gets the token name. * @return string representing the token name */ function name() public view override returns (string memory) { return _name; } /** * @dev Gets the token symbol. * @return string representing the token symbol */ function symbol() public view override returns (string memory) { return _symbol; } /** * @dev Returns the URI for a given token ID. May return an empty string. * * If a base URI is set (via {_setBaseURI}), it is added as a prefix to the * token's own URI (via {_setTokenURI}). * * If there is a base URI but no token URI, the token's ID will be used as * its URI when appending it to the base URI. This pattern for autogenerated * token URIs can lead to large gas savings. * * .Examples * |=== * |`_setBaseURI()` |`_setTokenURI()` |`tokenURI()` * | "" * | "" * | "" * | "" * | "token.uri/123" * | "token.uri/123" * | "token.uri/" * | "123" * | "token.uri/123" * | "token.uri/" * | "" * | "token.uri/<tokenId>" * |=== * * Requirements: * * - `tokenId` must exist. */ function tokenURI(uint256 tokenId) public view override returns (string memory) { require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token"); string memory _tokenURI = _tokenURIs[tokenId]; // If there is no base URI, return the token URI. if (bytes(_baseURI).length == 0) { return _tokenURI; } // If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked). if (bytes(_tokenURI).length > 0) { return string(abi.encodePacked(_baseURI, _tokenURI)); } // If there is a baseURI but no tokenURI, concatenate the tokenID to the baseURI. return string(abi.encodePacked(_baseURI, tokenId.toString())); } /** * @dev Returns the base URI set via {_setBaseURI}. This will be * automatically added as a prefix in {tokenURI} to each token's URI, or * to the token ID if no specific URI is set for that token ID. */ function baseURI() public view returns (string memory) { return _baseURI; } /** * @dev Gets the token ID at a given index of the tokens list of the requested owner. * @param owner address owning the tokens list to be accessed * @param index uint256 representing the index to be accessed of the requested tokens list * @return uint256 token ID at the given index of the tokens list owned by the requested address */ function tokenOfOwnerByIndex(address owner, uint256 index) public view override returns (uint256) { return _holderTokens[owner].at(index); } /** * @dev Gets the total amount of tokens stored by the contract. * @return uint256 representing the total amount of tokens */ function totalSupply() public view override returns (uint256) { // _tokenOwners are indexed by tokenIds, so .length() returns the number of tokenIds return _tokenOwners.length(); } /** * @dev Gets the token ID at a given index of all the tokens in this contract * Reverts if the index is greater or equal to the total number of tokens. * @param index uint256 representing the index to be accessed of the tokens list * @return uint256 token ID at the given index of the tokens list */ function tokenByIndex(uint256 index) public view override returns (uint256) { (uint256 tokenId, ) = _tokenOwners.at(index); return tokenId; } /** * @dev Approves another address to transfer the given token ID * The zero address indicates there is no approved address. * There can only be one approved address per token at a given time. * Can only be called by the token owner or an approved operator. * @param to address to be approved for the given token ID * @param tokenId uint256 ID of the token to be approved */ function approve(address to, uint256 tokenId) public virtual override { address owner = ownerOf(tokenId); require(to != owner, "ERC721: approval to current owner"); require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()), "ERC721: approve caller is not owner nor approved for all" ); _approve(to, tokenId); } /** * @dev Gets the approved address for a token ID, or zero if no address set * Reverts if the token ID does not exist. * @param tokenId uint256 ID of the token to query the approval of * @return address currently approved for the given token ID */ function getApproved(uint256 tokenId) public view override returns (address) { require(_exists(tokenId), "ERC721: approved query for nonexistent token"); return _tokenApprovals[tokenId]; } /** * @dev Sets or unsets the approval of a given operator * An operator is allowed to transfer all tokens of the sender on their behalf. * @param operator operator address to set the approval * @param approved representing the status of the approval to be set */ function setApprovalForAll(address operator, bool approved) public virtual override { require(operator != _msgSender(), "ERC721: approve to caller"); _operatorApprovals[_msgSender()][operator] = approved; emit ApprovalForAll(_msgSender(), operator, approved); } /** * @dev Tells whether an operator is approved by a given owner. * @param owner owner address which you want to query the approval of * @param operator operator address which you want to query the approval of * @return bool whether the given operator is approved by the given owner */ function isApprovedForAll(address owner, address operator) public view override returns (bool) { return _operatorApprovals[owner][operator]; } /** * @dev Transfers the ownership of a given token ID to another address. * Usage of this method is discouraged, use {safeTransferFrom} whenever possible. * Requires the msg.sender to be the owner, approved, or operator. * @param from current owner of the token * @param to address to receive the ownership of the given token ID * @param tokenId uint256 ID of the token to be transferred */ function transferFrom(address from, address to, uint256 tokenId) public virtual override { //solhint-disable-next-line max-line-length require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved"); _transfer(from, to, tokenId); } /** * @dev Safely transfers the ownership of a given token ID to another address * If the target address is a contract, it must implement {IERC721Receiver-onERC721Received}, * which is called upon a safe transfer, and return the magic value * `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise, * the transfer is reverted. * Requires the msg.sender to be the owner, approved, or operator * @param from current owner of the token * @param to address to receive the ownership of the given token ID * @param tokenId uint256 ID of the token to be transferred */ function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override { safeTransferFrom(from, to, tokenId, ""); } /** * @dev Safely transfers the ownership of a given token ID to another address * If the target address is a contract, it must implement {IERC721Receiver-onERC721Received}, * which is called upon a safe transfer, and return the magic value * `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise, * the transfer is reverted. * Requires the _msgSender() to be the owner, approved, or operator * @param from current owner of the token * @param to address to receive the ownership of the given token ID * @param tokenId uint256 ID of the token to be transferred * @param _data bytes data to send along with a safe transfer check */ function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override { require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved"); _safeTransfer(from, to, tokenId, _data); } /** * @dev Safely transfers the ownership of a given token ID to another address * If the target address is a contract, it must implement `onERC721Received`, * which is called upon a safe transfer, and return the magic value * `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise, * the transfer is reverted. * Requires the msg.sender to be the owner, approved, or operator * @param from current owner of the token * @param to address to receive the ownership of the given token ID * @param tokenId uint256 ID of the token to be transferred * @param _data bytes data to send along with a safe transfer check */ 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 whether the specified token exists. * @param tokenId uint256 ID of the token to query the existence of * @return bool whether the token exists */ function _exists(uint256 tokenId) internal view returns (bool) { return _tokenOwners.contains(tokenId); } /** * @dev Returns whether the given spender can transfer a given token ID. * @param spender address of the spender to query * @param tokenId uint256 ID of the token to be transferred * @return bool whether the msg.sender is approved for the given token ID, * is an operator of the owner, or is the owner of the token */ function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) { require(_exists(tokenId), "ERC721: operator query for nonexistent token"); address owner = ownerOf(tokenId); return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender)); } /** * @dev Internal function to safely mint a new token. * Reverts if the given token ID already exists. * If the target address is a contract, it must implement `onERC721Received`, * which is called upon a safe transfer, and return the magic value * `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise, * the transfer is reverted. * @param to The address that will own the minted token * @param tokenId uint256 ID of the token to be minted */ function _safeMint(address to, uint256 tokenId) internal virtual { _safeMint(to, tokenId, ""); } /** * @dev Internal function to safely mint a new token. * Reverts if the given token ID already exists. * If the target address is a contract, it must implement `onERC721Received`, * which is called upon a safe transfer, and return the magic value * `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise, * the transfer is reverted. * @param to The address that will own the minted token * @param tokenId uint256 ID of the token to be minted * @param _data bytes data to send along with a safe transfer check */ 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 Internal function to mint a new token. * Reverts if the given token ID already exists. * @param to The address that will own the minted token * @param tokenId uint256 ID of the token to be minted */ 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); _holderTokens[to].add(tokenId); _tokenOwners.set(tokenId, to); emit Transfer(address(0), to, tokenId); } /** * @dev Internal function to burn a specific token. * Reverts if the token does not exist. * @param tokenId uint256 ID of the token being burned */ function _burn(uint256 tokenId) internal virtual { address owner = ownerOf(tokenId); _beforeTokenTransfer(owner, address(0), tokenId); // Clear approvals _approve(address(0), tokenId); // Clear metadata (if any) if (bytes(_tokenURIs[tokenId]).length != 0) { delete _tokenURIs[tokenId]; } _holderTokens[owner].remove(tokenId); _tokenOwners.remove(tokenId); emit Transfer(owner, address(0), tokenId); } /** * @dev Internal function to transfer ownership of a given token ID to another address. * As opposed to {transferFrom}, this imposes no restrictions on msg.sender. * @param from current owner of the token * @param to address to receive the ownership of the given token ID * @param tokenId uint256 ID of the token to be transferred */ function _transfer(address from, address to, uint256 tokenId) internal virtual { require(ownerOf(tokenId) == from, "ERC721: transfer of token that is not own"); require(to != address(0), "ERC721: transfer to the zero address"); _beforeTokenTransfer(from, to, tokenId); // Clear approvals from the previous owner _approve(address(0), tokenId); _holderTokens[from].remove(tokenId); _holderTokens[to].add(tokenId); _tokenOwners.set(tokenId, to); emit Transfer(from, to, tokenId); } /** * @dev Internal function to set the token URI for a given token. * * Reverts if the token ID does not exist. * * TIP: If all token IDs share a prefix (for example, if your URIs look like * `https://api.myproject.com/token/<id>`), use {_setBaseURI} to store * it and save gas. */ function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual { require(_exists(tokenId), "ERC721Metadata: URI set of nonexistent token"); _tokenURIs[tokenId] = _tokenURI; } /** * @dev Internal function to set the base URI for all token IDs. It is * automatically added as a prefix to the value returned in {tokenURI}, * or to the token ID if {tokenURI} is empty. */ function _setBaseURI(string memory baseURI_) internal virtual { _baseURI = baseURI_; } /** * @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()) { return true; } // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = to.call(abi.encodeWithSelector( IERC721Receiver(to).onERC721Received.selector, _msgSender(), from, tokenId, _data )); if (!success) { if (returndata.length > 0) { // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert("ERC721: transfer to non ERC721Receiver implementer"); } } else { bytes4 retval = abi.decode(returndata, (bytes4)); return (retval == _ERC721_RECEIVED); } } function _approve(address to, uint256 tokenId) private { _tokenApprovals[tokenId] = to; emit Approval(ownerOf(tokenId), to, tokenId); } /** * @dev Hook that is called before any token transfer. This includes minting * and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, ``from``'s `tokenId` will be * transferred to `to`. * - when `from` is zero, `tokenId` will be minted for `to`. * - when `to` is zero, ``from``'s `tokenId` will be burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { } } // File: contracts/ERC721SimpleURI.sol pragma solidity ^0.6.0; /** * @title ERC721 With a nicer simple token URI * @dev see https://eips.ethereum.org/EIPS/eip-721 */ contract ERC721SimpleURI is ERC721 { // Similar to ERC1155 URI() event, but without a token ID. event BaseURI(string value); constructor (string memory name, string memory symbol, string memory baseURI) ERC721(name, symbol) public { _setBaseURI(baseURI); } /** * @dev Internal function to set the base URI for all token IDs. It is * automatically added as a prefix to the value returned in {tokenURI}. */ function _setBaseURI(string memory baseURI_) internal override virtual { super._setBaseURI(baseURI_); emit BaseURI(baseURI()); } } // File: contracts/ENSReverseRegistrarI.sol /* * Interfaces for ENS Reverse Registrar * See https://github.com/ensdomains/ens/blob/master/contracts/ReverseRegistrar.sol for full impl * Also see https://github.com/wealdtech/wealdtech-solidity/blob/master/contracts/ens/ENSReverseRegister.sol * * Use this as follows (registryAddress is the address of the ENS registry to use): * ----- * // This hex value is caclulated by namehash('addr.reverse') * bytes32 public constant ENS_ADDR_REVERSE_NODE = 0x91d1777781884d03a6757a803996e38de2a42967fb37eeaca72729271025a9e2; * function registerReverseENS(address registryAddress, string memory calldata) external { * require(registryAddress != address(0), "need a valid registry"); * address reverseRegistrarAddress = ENSRegistryOwnerI(registryAddress).owner(ENS_ADDR_REVERSE_NODE) * require(reverseRegistrarAddress != address(0), "need a valid reverse registrar"); * ENSReverseRegistrarI(reverseRegistrarAddress).setName(name); * } * ----- * or * ----- * function registerReverseENS(address reverseRegistrarAddress, string memory calldata) external { * require(reverseRegistrarAddress != address(0), "need a valid reverse registrar"); * ENSReverseRegistrarI(reverseRegistrarAddress).setName(name); * } * ----- * ENS deployments can be found at https://docs.ens.domains/ens-deployments * E.g. Etherscan can be used to look up that owner on those contracts. * namehash.hash("addr.reverse") == "0x91d1777781884d03a6757a803996e38de2a42967fb37eeaca72729271025a9e2" * Ropsten: ens.owner(namehash.hash("addr.reverse")) == "0x6F628b68b30Dc3c17f345c9dbBb1E483c2b7aE5c" * Mainnet: ens.owner(namehash.hash("addr.reverse")) == "0x084b1c3C81545d370f3634392De611CaaBFf8148" */ pragma solidity ^0.6.0; interface ENSRegistryOwnerI { function owner(bytes32 node) external view returns (address); } interface ENSReverseRegistrarI { function setName(string calldata name) external returns (bytes32 node); } // File: @openzeppelin/contracts/token/ERC20/IERC20.sol pragma solidity ^0.6.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `recipient`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address recipient, uint256 amount) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256); /** * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns (bool); /** * @dev Moves `amount` tokens from `sender` to `recipient` using the * allowance mechanism. `amount` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); } // File: contracts/CollectionsI.sol pragma solidity ^0.6.0; /** * @dev Outward-facing interface of a Collections contract. */ interface CollectionsI is IERC721 { event NewCollection(address indexed owner, address collectionAddress); /** * @dev Creates a new Collection. */ function create(address _notificationContract, string calldata _ensName, string calldata _ensSubdomainName, address _ensSubdomainRegistrarAddress, address _ensReverseRegistrarAddress) external; /** * @dev Create a collection for a different owner. Only callable by a create controller role. */ function createFor(address payable _newOwner, address _notificationContract, string calldata _ensName, string calldata _ensSubdomainName, address _ensSubdomainRegistrarAddress, address _ensReverseRegistrarAddress) external payable; /** * @dev Removes (burns) an empty Collection. Only the Collection contract itself can call this. */ function burn(uint256 tokenId) external; /** * @dev Returns if a Collection NFT exists for the specified `tokenId`. */ function exists(uint256 tokenId) external view returns (bool); /** * @dev Returns whether the given spender can transfer a given `tokenId`. */ function isApprovedOrOwner(address spender, uint256 tokenId) external view returns (bool); /** * @dev Returns the Collection address for a token ID. */ function collectionAddress(uint256 tokenId) external view returns (address); /** * @dev Returns the token ID for a Collection address. */ function tokenIdForCollection(address collectionAddr) external view returns (uint256 tokenId); } // File: contracts/OZ_ERC1155/IERC1155Receiver.sol pragma solidity ^0.6.0; /** @title ERC-1155 Multi Token Receiver Interface @dev See https://eips.ethereum.org/EIPS/eip-1155 */ interface IERC1155Receiver is IERC165 { /** @dev Handles the receipt of a single ERC1155 token type. This function is called at the end of a `safeTransferFrom` after the balance has been updated. To accept the transfer, this must return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` (i.e. 0xf23a6e61, or its own function selector). @param operator The address which initiated the transfer (i.e. msg.sender) @param from The address which previously owned the token @param id The ID of the token being transferred @param value The amount of tokens being transferred @param data Additional data with no specified format @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed */ function onERC1155Received( address operator, address from, uint256 id, uint256 value, bytes calldata data ) external returns(bytes4); /** @dev Handles the receipt of a multiple ERC1155 token types. This function is called at the end of a `safeBatchTransferFrom` after the balances have been updated. To accept the transfer(s), this must return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` (i.e. 0xbc197c81, or its own function selector). @param operator The address which initiated the batch transfer (i.e. msg.sender) @param from The address which previously owned the token @param ids An array containing ids of each token being transferred (order and length must match values array) @param values An array containing amounts of each token being transferred (order and length must match ids array) @param data Additional data with no specified format @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed */ function onERC1155BatchReceived( address operator, address from, uint256[] calldata ids, uint256[] calldata values, bytes calldata data ) external returns(bytes4); } // File: contracts/CollectionI.sol /* Interface for a single Collection, which is a very lightweight contract that can be the owner of ERC721 tokens. */ pragma solidity ^0.6.0; // Convert to interface once https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2113 is solved. abstract contract CollectionI is IERC165, IERC721Receiver, IERC1155Receiver { /** * @dev True is this is the prototype, false if this is an active (clone/proxy) collection contract. */ bool public isPrototype; /** * @dev The linked Collections factory (the ERC721 contract). */ CollectionsI public collections; /** * @dev The linked notification contract (e.g. achievements). */ address public notificationContract; /** * @dev Initializes a new Collection. Needs to be called by the Collections factory. */ function initialRegister(address _notificationContract, string calldata _ensName, string calldata _ensSubdomainName, address _ensSubdomainRegistrarAddress, address _ensReverseRegistrarAddress) external virtual; /** * @dev Get collection owner from ERC 721 parent (Collections factory). */ function ownerAddress() external view virtual returns (address); /** * @dev Determine if the Collection owns a specific asset. */ function ownsAsset(address _tokenAddress, uint256 _tokenId) external view virtual returns(bool); /** * @dev Get count of owned assets. */ function ownedAssetsCount() external view virtual returns (uint256); /** * @dev Make sure ownership of a certain asset is recorded correctly (added if the collection owns it or removed if it doesn't). */ function syncAssetOwnership(address _tokenAddress, uint256 _tokenId) external virtual; /** * @dev Transfer an owned asset to a new owner (for ERC1155, a single item of that asset). */ function safeTransferTo(address _tokenAddress, uint256 _tokenId, address _to) external virtual; /** * @dev Transfer a certain amount of an owned asset to a new owner (for ERC721, _value is ignored). */ function safeTransferTo(address _tokenAddress, uint256 _tokenId, address _to, uint256 _value) external virtual; /** * @dev Destroy and burn an empty Collection. Can only be called by owner and only on empty collections. */ function destroy() external virtual; /** * @dev Forward calls to external contracts. Can only be called by owner. * Given a contract address and an already-encoded payload (with a function call etc.), * we call that contract with this payload, e.g. to trigger actions in the name of the collection. */ function externalCall(address payable _remoteAddress, bytes calldata _callPayload) external virtual payable; /** * @dev Register ENS name. Can only be called by owner. */ function registerENS(string calldata _name, address _registrarAddress) external virtual; /** * @dev Register Reverse ENS name. Can only be called by owner. */ function registerReverseENS(address _reverseRegistrarAddress, string calldata _name) external virtual; } // File: contracts/Collections.sol /* Implements Collections of ERC 721 tokens, exposed as yet another ERC721 token. */ pragma solidity ^0.6.0; contract Collections is ERC721SimpleURI, CollectionsI { using SafeMath for uint256; address public createControl; address public tokenAssignmentControl; address public forwardCollectionAddress; event NewCollection(address indexed owner, address collectionAddress); event KilledCollection(address indexed owner, address collectionAddress); event CreateControlTransferred(address indexed previousCreateControl, address indexed newCreateControl); event TokenAssignmentControlTransferred(address indexed previousTokenAssignmentControl, address indexed newTokenAssignmentControl); // Collection event - never emitted in this contract but helpful for running our tests. event NotificationContractTransferred(address indexed previousNotificationContract, address indexed newNotificationContract); // TestTracker event - never emitted in this contract but helpful for running our tests. event SeenContractAdded(bool initial); constructor(address _createControl, address _tokenAssignmentControl, address _forwardCollectionAddress) ERC721SimpleURI("Crypto stamp Collections", "CSC", "https://test.crypto.post.at/CSC/meta/") public { createControl = _createControl; tokenAssignmentControl = _tokenAssignmentControl; require(CollectionI(_forwardCollectionAddress).isPrototype(), "_forwardCollectionAddress needs to be a prototype."); forwardCollectionAddress = _forwardCollectionAddress; } modifier onlyCreateControl() { require(msg.sender == createControl, "createControl key required for this function."); _; } modifier onlyTokenAssignmentControl() { require(msg.sender == tokenAssignmentControl, "tokenAssignmentControl key required for this function."); _; } /*** Enable adjusting variables after deployment ***/ function transferTokenAssignmentControl(address _newTokenAssignmentControl) public onlyTokenAssignmentControl { require(_newTokenAssignmentControl != address(0), "tokenAssignmentControl cannot be the zero address."); emit TokenAssignmentControlTransferred(tokenAssignmentControl, _newTokenAssignmentControl); tokenAssignmentControl = _newTokenAssignmentControl; } function transferCreateControl(address _newCreateControl) public onlyCreateControl { require(_newCreateControl != address(0), "createControl cannot be the zero address."); emit CreateControlTransferred(createControl, _newCreateControl); createControl = _newCreateControl; } // Set new base for the token URI. function setBaseURI(string memory _newBaseURI) public onlyCreateControl { _setBaseURI(_newBaseURI); } /*** Manage collections ***/ // Issue a new collection, which will be owned by whoever calls this function. function create(address _notificationContract, string memory _ensName, string memory _ensSubdomainName, address _ensSubdomainRegistrarAddress, address _ensReverseRegistrarAddress) public override { _createCollection(msg.sender, _notificationContract, _ensName, _ensSubdomainName, _ensSubdomainRegistrarAddress, _ensReverseRegistrarAddress); } // Create a collection for a different owner. function createFor(address payable _newOwner, address _notificationContract, string memory _ensName, string memory _ensSubdomainName, address _ensSubdomainRegistrarAddress, address _ensReverseRegistrarAddress) public override payable onlyCreateControl { _createCollection(_newOwner, _notificationContract, _ensName, _ensSubdomainName, _ensSubdomainRegistrarAddress, _ensReverseRegistrarAddress); if (msg.value > 0) { _newOwner.transfer(msg.value); } } function _createCollection(address _newOwner, address _notificationContract, string memory _ensName, string memory _ensSubdomainName, address _ensSubdomainRegistrarAddress, address _ensReverseRegistrarAddress) internal { require(forwardCollectionAddress != address(0), "Set a forward collection first!"); address newCollectionAddress = _cloneContract(forwardCollectionAddress); emit NewCollection(_newOwner, newCollectionAddress); // _safeMint() checks if the recipient can actually receive ERC721 tokens. _safeMint(_newOwner, uint256(newCollectionAddress)); // Now, register notification and ENS. CollectionI(newCollectionAddress).initialRegister(_notificationContract, _ensName, _ensSubdomainName, _ensSubdomainRegistrarAddress, _ensReverseRegistrarAddress); } function _cloneContract(address addressToClone) internal returns (address newCloneAddress) { bytes20 targetBytes = bytes20(addressToClone); // This is using https://eips.ethereum.org/EIPS/eip-1167 - the assembly code comes from // https://github.com/optionality/clone-factory/blob/master/contracts/CloneFactory.sol assembly { let clone := mload(0x40) mstore(clone, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000) mstore(add(clone, 0x14), targetBytes) mstore(add(clone, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000) newCloneAddress := create(0, clone, 0x37) } // We assigned to the "returns" variable, so the return with this is implicit. } // Removes (burns) an empty Collection. function burn(uint256 tokenId) public override { address payable collectionAddress = address(tokenId); require(msg.sender == collectionAddress, "Only the collection itself can burn the token."); // The contract itself checks this, but let's check again to be really sure. require(CollectionI(collectionAddress).ownedAssetsCount() == 0, "Only empty collections can be burned."); address owner = ownerOf(tokenId); _burn(tokenId); emit KilledCollection(owner, collectionAddress); } // Returns whether the specified token exists function exists(uint256 tokenId) public view override returns (bool) { return _exists(tokenId); } // Returns whether the given spender can transfer a given token ID. function isApprovedOrOwner(address spender, uint256 tokenId) public view override returns (bool) { return _isApprovedOrOwner(spender, tokenId); } // Returns the Collection address for a token ID. function collectionAddress(uint256 tokenId) public view override returns (address) { require(_exists(tokenId), "Collection needs to exist."); return address(tokenId); } // Returns the token ID for a Collection address. function tokenIdForCollection(address collectionAddr) public view override returns (uint256) { uint256 tokenId = uint256(collectionAddr); require(_exists(tokenId), "Collection needs to exist."); return tokenId; } /*** Enable reverse ENS registration ***/ // Call this with the address of the reverse registrar for the respecitve network and the ENS name to register. // The reverse registrar can be found as the owner of 'addr.reverse' in the ENS system. // See https://docs.ens.domains/ens-deployments for address of ENS deployments, e.g. Etherscan can be used to look up that owner on those. // namehash.hash("addr.reverse") == "0x91d1777781884d03a6757a803996e38de2a42967fb37eeaca72729271025a9e2" // Ropsten: ens.owner(namehash.hash("addr.reverse")) == "0x6F628b68b30Dc3c17f345c9dbBb1E483c2b7aE5c" // Mainnet: ens.owner(namehash.hash("addr.reverse")) == "0x084b1c3C81545d370f3634392De611CaaBFf8148" function registerReverseENS(address _reverseRegistrarAddress, string calldata _name) external onlyTokenAssignmentControl { require(_reverseRegistrarAddress != address(0), "need a valid reverse registrar"); ENSReverseRegistrarI(_reverseRegistrarAddress).setName(_name); } /*** Make sure currency doesn't get stranded in this contract ***/ // If this contract gets a balance in some ERC20 contract after it's finished, then we can rescue it. function rescueToken(IERC20 _foreignToken, address _to) external onlyTokenAssignmentControl { _foreignToken.transfer(_to, _foreignToken.balanceOf(address(this))); } // If this contract gets a balance in some ERC721 contract after it's finished, then we can rescue it. function approveNFTrescue(IERC721 _foreignNFT, address _to) external onlyTokenAssignmentControl { _foreignNFT.setApprovalForAll(_to, true); } // Make sure this contract cannot receive ETH. receive() external payable { revert("The contract cannot receive ETH payments."); } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address","name":"_createControl","type":"address"},{"internalType":"address","name":"_tokenAssignmentControl","type":"address"},{"internalType":"address","name":"_forwardCollectionAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"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":"string","name":"value","type":"string"}],"name":"BaseURI","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousCreateControl","type":"address"},{"indexed":true,"internalType":"address","name":"newCreateControl","type":"address"}],"name":"CreateControlTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"address","name":"collectionAddress","type":"address"}],"name":"KilledCollection","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"address","name":"collectionAddress","type":"address"}],"name":"NewCollection","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousNotificationContract","type":"address"},{"indexed":true,"internalType":"address","name":"newNotificationContract","type":"address"}],"name":"NotificationContractTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"initial","type":"bool"}],"name":"SeenContractAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousTokenAssignmentControl","type":"address"},{"indexed":true,"internalType":"address","name":"newTokenAssignmentControl","type":"address"}],"name":"TokenAssignmentControlTransferred","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":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC721","name":"_foreignNFT","type":"address"},{"internalType":"address","name":"_to","type":"address"}],"name":"approveNFTrescue","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"collectionAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_notificationContract","type":"address"},{"internalType":"string","name":"_ensName","type":"string"},{"internalType":"string","name":"_ensSubdomainName","type":"string"},{"internalType":"address","name":"_ensSubdomainRegistrarAddress","type":"address"},{"internalType":"address","name":"_ensReverseRegistrarAddress","type":"address"}],"name":"create","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"createControl","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address payable","name":"_newOwner","type":"address"},{"internalType":"address","name":"_notificationContract","type":"address"},{"internalType":"string","name":"_ensName","type":"string"},{"internalType":"string","name":"_ensSubdomainName","type":"string"},{"internalType":"address","name":"_ensSubdomainRegistrarAddress","type":"address"},{"internalType":"address","name":"_ensReverseRegistrarAddress","type":"address"}],"name":"createFor","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"exists","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"forwardCollectionAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"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":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"isApprovedOrOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_reverseRegistrarAddress","type":"address"},{"internalType":"string","name":"_name","type":"string"}],"name":"registerReverseENS","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"_foreignToken","type":"address"},{"internalType":"address","name":"_to","type":"address"}],"name":"rescueToken","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":"string","name":"_newBaseURI","type":"string"}],"name":"setBaseURI","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":[],"name":"tokenAssignmentControl","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"collectionAddr","type":"address"}],"name":"tokenIdForCollection","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":"_newCreateControl","type":"address"}],"name":"transferCreateControl","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":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newTokenAssignmentControl","type":"address"}],"name":"transferTokenAssignmentControl","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]
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)
0000000000000000000000009a5be4f89d483e445716dc1abb7668e56deaa909000000000000000000000000596e620e175c2c37a5f35a41d9f2305a991ffc89000000000000000000000000a09c1152441a71d1bad6691cd65b7b439f79ab98
-----Decoded View---------------
Arg [0] : _createControl (address): 0x9a5Be4f89D483e445716dc1abb7668e56dEAA909
Arg [1] : _tokenAssignmentControl (address): 0x596E620E175C2C37A5f35A41d9F2305A991fFc89
Arg [2] : _forwardCollectionAddress (address): 0xA09C1152441A71d1Bad6691Cd65B7B439F79Ab98
-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 0000000000000000000000009a5be4f89d483e445716dc1abb7668e56deaa909
Arg [1] : 000000000000000000000000596e620e175c2c37a5f35a41d9f2305a991ffc89
Arg [2] : 000000000000000000000000a09c1152441a71d1bad6691cd65b7b439f79ab98
Deployed Bytecode Sourcemap
73423:9384:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;82745:51;;-1:-1:-1;;;82745:51:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;73423:9384;12:1:-1;9;2:12;10852:142:0;;5:9:-1;2:2;;;27:1;24;17:12;2:2;10852:142:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;10852:142:0;-1:-1:-1;;;;;;10852:142:0;;:::i;:::-;;;;;;;;;;;;;;;;;;41840:92;;5:9:-1;2:2;;;27:1;24;17:12;2:2;41840:92:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:100:-1;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;41840:92:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46624:213;;5:9:-1;2:2;;;27:1;24;17:12;2:2;46624:213:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;46624:213:0;;:::i;:::-;;;;-1:-1:-1;;;;;46624:213:0;;;;;;;;;;;;;;76891:631;;;;;;15:3:-1;10;7:12;4:2;;;32:1;29;22:12;4:2;-1:-1;;;;;76891:631:0;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;11:28;;8:2;;;52:1;49;42:12;8:2;76891:631:0;;41:9:-1;34:4;18:14;14:25;11:40;8:2;;;64:1;61;54:12;8:2;76891:631:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;-1:-1;;;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;76891:631:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;76891:631:0;;;;;;;;-1:-1:-1;76891:631:0;;-1:-1:-1;;;;;11:28;;8:2;;;52:1;49;42:12;8:2;76891:631:0;;41:9:-1;34:4;18:14;14:25;11:40;8:2;;;64:1;61;54:12;8:2;76891:631:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;-1:-1;;;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;76891:631:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;76891:631:0;;-1:-1:-1;;;;;;;76891:631:0;;;;;-1:-1:-1;76891:631:0;;;;;;;;;-1:-1:-1;76891:631:0;;-1:-1:-1;76891:631:0:i;:::-;;45941:390;;5:9:-1;2:2;;;27:1;24;17:12;2:2;45941:390:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;;;;;;45941:390:0;;;;;;;;:::i;44797:203::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;44797:203:0;;;:::i;:::-;;;;;;;;;;;;;;;;48372:305;;5:9:-1;2:2;;;27:1;24;17:12;2:2;48372:305:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;;;;;;48372:305:0;;;;;;;;;;;;;;;;;:::i;44484:154::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;44484:154:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;;;;;;44484:154:0;;;;;;;;:::i;49339:151::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;49339:151:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;;;;;;49339:151:0;;;;;;;;;;;;;;;;;:::i;79413:546::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;79413:546:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;79413:546:0;;:::i;80210:159::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;80210:159:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;;;;;;80210:159:0;;;;;;;;:::i;82158:193::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;82158:193:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;;;;;;82158:193:0;;;;;;;;;;:::i;73602:39::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;73602:39:0;;;:::i;80018:111::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;80018:111:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;80018:111:0;;:::i;45346:164::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;45346:164:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;45346:164:0;;:::i;76382:450::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;76382:450:0;;;;;;15:3:-1;10;7:12;4:2;;;32:1;29;22:12;4:2;-1:-1;;;;;76382:450:0;;;;;;;;;;;;;;;-1:-1:-1;;;11:28;;8:2;;;52:1;49;42:12;8:2;76382:450:0;;41:9:-1;34:4;18:14;14:25;11:40;8:2;;;64:1;61;54:12;8:2;76382:450:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;-1:-1;;;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;76382:450:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;76382:450:0;;;;;;;;-1:-1:-1;76382:450:0;;-1:-1:-1;;;;;11:28;;8:2;;;52:1;49;42:12;8:2;76382:450:0;;41:9:-1;34:4;18:14;14:25;11:40;8:2;;;64:1;61;54:12;8:2;76382:450:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;-1:-1;;;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;76382:450:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;76382:450:0;;-1:-1:-1;;;;;;;76382:450:0;;;;;-1:-1:-1;76382:450:0;;;;;;;;;-1:-1:-1;76382:450:0;;-1:-1:-1;76382:450:0:i;76124:130::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;76124:130:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;76124:130:0;;;;;;;;-1:-1:-1;;;11:28;;8:2;;;52:1;49;42:12;8:2;76124:130:0;;41:9:-1;34:4;18:14;14:25;11:40;8:2;;;64:1;61;54:12;8:2;76124:130:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;-1:-1;;;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;76124:130:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;76124:130:0;;-1:-1:-1;76124:130:0;;-1:-1:-1;;;;;76124:130:0:i;80432:191::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;80432:191:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;80432:191:0;;:::i;41560:169::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;41560:169:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;41560:169:0;;:::i;75756:320::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;75756:320:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;75756:320:0;-1:-1:-1;;;;;75756:320:0;;:::i;44013:89::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;44013:89:0;;;:::i;41119:215::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;41119:215:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;41119:215:0;-1:-1:-1;;;;;41119:215:0;;:::i;81663:306::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;81663:306:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;;;;;81663:306:0;;;;;;;;;;;;;;;-1:-1:-1;;;11:28;;8:2;;;52:1;49;42:12;8:2;81663:306:0;;41:9:-1;34:4;18:14;14:25;11:40;8:2;;;64:1;61;54:12;8:2;81663:306:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;-1:-1;;;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;-1:-1;81663:306:0;;-1:-1:-1;81663:306:0;-1:-1:-1;81663:306:0;:::i;42047:96::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;42047:96:0;;;:::i;47144:295::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;47144:295:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;;;;;;47144:295:0;;;;;;;;;;:::i;50227:285::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;50227:285:0;;;;;;15:3:-1;10;7:12;4:2;;;32:1;29;22:12;4:2;-1:-1;;;;;50227:285:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;11:28;;8:2;;;52:1;49;42:12;8:2;50227:285:0;;41:9:-1;34:4;18:14;14:25;11:40;8:2;;;64:1;61;54:12;8:2;50227:285:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;-1:-1;;;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;50227:285:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;50227:285:0;;-1:-1:-1;50227:285:0;;-1:-1:-1;;;;;50227:285:0:i;80686:244::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;80686:244:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;80686:244:0;-1:-1:-1;;;;;80686:244:0;;:::i;43019:755::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;43019:755:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;43019:755:0;;:::i;73556:37::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;73556:37:0;;;:::i;75338:410::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;75338:410:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;75338:410:0;-1:-1:-1;;;;;75338:410:0;;:::i;82467:170::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;82467:170:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;;;;;;82467:170:0;;;;;;;;;;:::i;73519:28::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;73519:28:0;;;:::i;47769:156::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;47769:156:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;;;;;;47769:156:0;;;;;;;;;;:::i;10852:142::-;-1:-1:-1;;;;;;10953:33:0;;10929:4;10953:33;;;;;;;;;;;;;10852:142;;;;:::o;41840:92::-;41919:5;41912:12;;;;;;;;-1:-1:-1;;41912:12:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41886:13;;41912:12;;41919:5;;41912:12;;41919:5;41912:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41840:92;;:::o;46624:213::-;46692:7;46720:16;46728:7;46720;:16::i;:::-;46712:73;;;;-1:-1:-1;;;46712:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;46805:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;46805:24:0;;46624:213::o;76891:631::-;75006:13;;-1:-1:-1;;;;;75006:13:0;74992:10;:27;74984:85;;;;-1:-1:-1;;;74984:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;77289:140:::1;77307:9;77318:21;77341:8;77351:17;77370:29;77401:27;77289:17;:140::i;:::-;77444:9;:13:::0;77440:75:::1;;77474:29;::::0;-1:-1:-1;;;;;77474:18:0;::::1;::::0;77493:9:::1;77474:29:::0;::::1;;;::::0;::::1;::::0;;;77493:9;77474:18;:29;::::1;;;;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;77474:29:0;77440:75;76891:631:::0;;;;;;:::o;45941:390::-;46022:13;46038:16;46046:7;46038;:16::i;:::-;46022:32;;46079:5;-1:-1:-1;;;;;46073:11:0;:2;-1:-1:-1;;;;;46073:11:0;;;46065:57;;;;-1:-1:-1;;;46065:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46159:5;-1:-1:-1;;;;;46143:21:0;:12;:10;:12::i;:::-;-1:-1:-1;;;;;46143:21:0;;:62;;;;46168:37;46185:5;46192:12;:10;:12::i;:::-;46168:16;:37::i;:::-;46135:154;;;;-1:-1:-1;;;46135:154:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46302:21;46311:2;46315:7;46302:8;:21::i;:::-;45941:390;;;:::o;44797:203::-;44850:7;44971:21;:12;:19;:21::i;:::-;44964:28;;44797:203;:::o;48372:305::-;48533:41;48552:12;:10;:12::i;:::-;48566:7;48533:18;:41::i;:::-;48525:103;;;;-1:-1:-1;;;48525:103:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48641:28;48651:4;48657:2;48661:7;48641:9;:28::i;44484:154::-;-1:-1:-1;;;;;44600:20:0;;44573:7;44600:20;;;:13;:20;;;;;:30;;44624:5;44600:30;:23;:30;:::i;:::-;44593:37;;44484:154;;;;;:::o;49339:151::-;49443:39;49460:4;49466:2;49470:7;49443:39;;;;;;;;;;;;:16;:39::i;79413:546::-;79515:7;79542:10;-1:-1:-1;;;;;79542:31:0;;;79534:90;;;;-1:-1:-1;;;79534:90:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;79741:17;-1:-1:-1;;;;;79729:47:0;;:49;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;79729:49:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;79729:49:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;79729:49:0;:54;79721:104;;;;-1:-1:-1;;;79721:104:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;79836:13;79852:16;79860:7;79852;:16::i;:::-;79836:32;;79879:14;79885:7;79879:5;:14::i;:::-;79909:42;;;-1:-1:-1;;;;;79909:42:0;;;;;;;;;;;;;;;;;;;;79413:546;;;:::o;80210:159::-;80301:4;80325:36;80344:7;80353;80325:18;:36::i;82158:193::-;75168:22;;-1:-1:-1;;;;;75168:22:0;75154:10;:36;75146:103;;;;-1:-1:-1;;;75146:103:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;82304:38:::1;::::0;;-1:-1:-1;;;82304:38:0;;82336:4:::1;82304:38;::::0;::::1;::::0;;;-1:-1:-1;;;;;82276:22:0;::::1;::::0;::::1;::::0;82299:3;;82276:22;;82304:23:::1;::::0;:38;;;;;::::1;::::0;;;;;;;;;82276:22;82304:38;::::1;;2:2:-1::0;::::1;;;27:1;24::::0;17:12:::1;2:2;82304:38:0;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;82304:38:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28::::0;21:12:::1;4:2;-1:-1:::0;82304:38:0;82276:67:::1;::::0;;-1:-1:-1;;;;;;82276:67:0::1;::::0;;;;;;-1:-1:-1;;;;;82276:67:0;;::::1;;::::0;::::1;::::0;;;;;;;;;;;;;;82304:38:::1;::::0;82276:67;;;;;;;-1:-1:-1;82276:67:0;;::::1;;2:2:-1::0;::::1;;;27:1;24::::0;17:12:::1;2:2;82276:67:0;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;82276:67:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28::::0;21:12:::1;4:2;-1:-1:::0;;;;82158:193:0:o;73602:39::-;;;-1:-1:-1;;;;;73602:39:0;;:::o;80018:111::-;80081:4;80105:16;80113:7;80105;:16::i;45346:164::-;45413:7;;45455:22;:12;45471:5;45455:22;:15;:22;:::i;:::-;-1:-1:-1;45433:44:0;45346:164;-1:-1:-1;;;45346:164:0:o;76382:450::-;76683:141;76701:10;76713:21;76736:8;76746:17;76765:29;76796:27;76683:17;:141::i;:::-;76382:450;;;;;:::o;76124:130::-;75006:13;;-1:-1:-1;;;;;75006:13:0;74992:10;:27;74984:85;;;;-1:-1:-1;;;74984:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;76222:24:::1;76234:11;76222;:24::i;:::-;76124:130:::0;:::o;80432:191::-;80506:7;80534:16;80542:7;80534;:16::i;:::-;80526:55;;;;;-1:-1:-1;;;80526:55:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;80607:7:0;80432:191::o;41560:169::-;41624:7;41651:70;41668:7;41651:70;;;;;;;;;;;;;;;;;:12;;:70;;:16;:70;:::i;75756:320::-;75006:13;;-1:-1:-1;;;;;75006:13:0;74992:10;:27;74984:85;;;;-1:-1:-1;;;74984:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;75873:31:0;::::1;75865:85;;;;-1:-1:-1::0;;;75865:85:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;75991:13;::::0;75966:58:::1;::::0;-1:-1:-1;;;;;75966:58:0;;::::1;::::0;75991:13:::1;::::0;75966:58:::1;::::0;75991:13:::1;::::0;75966:58:::1;76035:13;:33:::0;;-1:-1:-1;;;;;;76035:33:0::1;-1:-1:-1::0;;;;;76035:33:0;;;::::1;::::0;;;::::1;::::0;;75756:320::o;44013:89::-;44086:8;44079:15;;;;;;;;-1:-1:-1;;44079:15:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44053:13;;44079:15;;44086:8;;44079:15;;44086:8;44079:15;;;;;;;;;;;;;;;;;;;;;;;;41119:215;41183:7;-1:-1:-1;;;;;41211:19:0;;41203:74;;;;-1:-1:-1;;;41203:74:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;41297:20:0;;;;;;:13;:20;;;;;:29;;:27;:29::i;81663:306::-;75168:22;;-1:-1:-1;;;;;75168:22:0;75154:10;:36;75146:103;;;;-1:-1:-1;;;75146:103:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;81817:38:0;::::1;81809:81;;;::::0;;-1:-1:-1;;;81809:81:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;81900:61;::::0;-1:-1:-1;;;81900:61:0;;::::1;;::::0;::::1;::::0;;;;;;;;;-1:-1:-1;;;;;81900:54:0;::::1;::::0;::::1;::::0;81955:5;;;;81900:61;;;;;81955:5;;;;81900:61;1:33:-1::1;99:1;93:3;85:6;81:16;74:27;137:4;133:9;126:4;121:3;117:14;113:30;106:37;;169:3;161:6;157:16;147:26;;81900:61:0;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24::::0;17:12:::1;2:2;81900:61:0;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;81900:61:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28::::0;21:12:::1;42047:96:0::0;42128:7;42121:14;;;;;;;;-1:-1:-1;;42121:14:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42095:13;;42121:14;;42128:7;;42121:14;;42128:7;42121:14;;;;;;;;;;;;;;;;;;;;;;;;47144:295;47259:12;:10;:12::i;:::-;-1:-1:-1;;;;;47247:24:0;:8;-1:-1:-1;;;;;47247:24:0;;;47239:62;;;;;-1:-1:-1;;;47239:62:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;47359:8;47314:18;:32;47333:12;:10;:12::i;:::-;-1:-1:-1;;;;;47314:32:0;;;;;;;;;;;;;;;;;-1:-1:-1;47314:32:0;;;:42;;;;;;;;;;;;:53;;-1:-1:-1;;47314:53:0;;;;;;;;;;;47398:12;:10;:12::i;:::-;47383:48;;;;;;;;;;-1:-1:-1;;;;;47383:48:0;;;;;;;;;;;;;;47144:295;;:::o;50227:285::-;50359:41;50378:12;:10;:12::i;:::-;50392:7;50359:18;:41::i;:::-;50351:103;;;;-1:-1:-1;;;50351:103:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50465:39;50479:4;50485:2;50489:7;50498:5;50465:13;:39::i;80686:244::-;80770:7;-1:-1:-1;;;;;80808:23:0;;80850:16;80808:23;80850:7;:16::i;:::-;80842:55;;;;;-1:-1:-1;;;80842:55:0;;;;;;;;;;;;;;;;;;;;;;;;;;;43019:755;43084:13;43118:16;43126:7;43118;:16::i;:::-;43110:76;;;;-1:-1:-1;;;43110:76:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43225:19;;;;:10;:19;;;;;;;;;43199:45;;;;;;-1:-1:-1;;43199:45:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:23;;:45;;;43225:19;43199:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;43326:8:0;43320:22;43199:45;;-1:-1:-1;;;;43320:22:0;-1:-1:-1;;43320:22:0;;;;;;;;;;;43316:76;;43371:9;-1:-1:-1;43364:16:0;;43316:76;43496:23;;:27;43492:112;;43571:8;43581:9;43554:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;43554:37:0;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;176:10;;164:23;;-1:-1;;139:12;;;;98:2;89:12;;;;114;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;43554:37:0;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;43554:37:0;;;43540:52;;;;;43492:112;43736:8;43746:18;:7;:16;:18::i;:::-;43719:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;43719:46:0;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;176:10;;164:23;;-1:-1;;139:12;;;;98:2;89:12;;;;114;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;43719:46:0;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;43719:46:0;;;43705:61;;;43019:755;;;:::o;73556:37::-;;;-1:-1:-1;;;;;73556:37:0;;:::o;75338:410::-;75168:22;;-1:-1:-1;;;;;75168:22:0;75154:10;:36;75146:103;;;;-1:-1:-1;;;75146:103:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;75482:40:0;::::1;75474:103;;;;-1:-1:-1::0;;;75474:103:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;75627:22;::::0;75593:85:::1;::::0;-1:-1:-1;;;;;75593:85:0;;::::1;::::0;75627:22:::1;::::0;75593:85:::1;::::0;75627:22:::1;::::0;75593:85:::1;75689:22;:51:::0;;-1:-1:-1;;;;;;75689:51:0::1;-1:-1:-1::0;;;;;75689:51:0;;;::::1;::::0;;;::::1;::::0;;75338:410::o;82467:170::-;75168:22;;-1:-1:-1;;;;;75168:22:0;75154:10;:36;75146:103;;;;-1:-1:-1;;;75146:103:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;82589:40:::1;::::0;;-1:-1:-1;;;82589:40:0;;-1:-1:-1;;;;;82589:40:0;;::::1;;::::0;::::1;::::0;82624:4:::1;82589:40:::0;;;;;;:29;;::::1;::::0;::::1;::::0;:40;;;;;-1:-1:-1;;82589:40:0;;;;;;;;-1:-1:-1;82589:29:0;:40;::::1;;2:2:-1::0;::::1;;;27:1;24::::0;17:12:::1;2:2;82589:40:0;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;73519:28:0::0;;;-1:-1:-1;;;;;73519:28:0;;:::o;47769:156::-;-1:-1:-1;;;;;47882:25:0;;;47858:4;47882:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;47769:156::o;57156:100::-;57229:19;;;;:8;;:19;;;;;:::i;:::-;;57156:100;:::o;51705:119::-;51762:4;51786:30;:12;51808:7;51786:30;:21;:30;:::i;77530:1000::-;77938:24;;-1:-1:-1;;;;;77938:24:0;77930:82;;;;;-1:-1:-1;;;77930:82:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;78069:24;;78023:28;;78054:40;;-1:-1:-1;;;;;78069:24:0;78054:14;:40::i;:::-;78110:46;;;-1:-1:-1;;;;;78110:46:0;;;;;;;78023:71;;-1:-1:-1;78110:46:0;;;;;;;;;;;;;78251:51;78261:9;78280:20;-1:-1:-1;;;;;78272:29:0;78251:9;:51::i;:::-;78373:20;-1:-1:-1;;;;;78361:49:0;;78411:21;78434:8;78444:17;78463:29;78494:27;78361:161;;;;;;;;;;;;;-1:-1:-1;;;;;78361:161:0;-1:-1:-1;;;;;78361:161:0;;;;;;;;;;;;-1:-1:-1;;;;;78361:161:0;-1:-1:-1;;;;;78361:161:0;;;;;;-1:-1:-1;;;;;78361:161:0;-1:-1:-1;;;;;78361:161:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;78361:161:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;78361:161:0;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;78361:161:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;78361:161:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;78361:161:0;;;;77530:1000;;;;;;;:::o;1112:106::-;1200:10;1112:106;:::o;58907:158::-;58973:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;58973:29:0;-1:-1:-1;;;;;58973:29:0;;;;;;;;:24;;59027:16;58973:24;59027:7;:16::i;:::-;-1:-1:-1;;;;;59018:39:0;;;;;;;;;;;58907:158;;:::o;35019:123::-;35088:7;35115:19;35123:3;35115:7;:19::i;52194:333::-;52279:4;52304:16;52312:7;52304;:16::i;:::-;52296:73;;;;-1:-1:-1;;;52296:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52380:13;52396:16;52404:7;52396;:16::i;:::-;52380:32;;52442:5;-1:-1:-1;;;;;52431:16:0;:7;-1:-1:-1;;;;;52431:16:0;;:51;;;;52475:7;-1:-1:-1;;;;;52451:31:0;:20;52463:7;52451:11;:20::i;:::-;-1:-1:-1;;;;;52451:31:0;;52431:51;:87;;;;52486:32;52503:5;52510:7;52486:16;:32::i;:::-;52423:96;52194:333;-1:-1:-1;;;;52194:333:0:o;55793:574::-;55911:4;-1:-1:-1;;;;;55891:24:0;:16;55899:7;55891;:16::i;:::-;-1:-1:-1;;;;;55891:24:0;;55883:78;;;;-1:-1:-1;;;55883:78:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;55980:16:0;;55972:65;;;;-1:-1:-1;;;55972:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56050:39;56071:4;56077:2;56081:7;56050:20;:39::i;:::-;56154:29;56171:1;56175:7;56154:8;:29::i;:::-;-1:-1:-1;;;;;56196:19:0;;;;;;:13;:19;;;;;:35;;56223:7;56196:35;:26;:35;:::i;:::-;-1:-1:-1;;;;;;56242:17:0;;;;;;:13;:17;;;;;:30;;56264:7;56242:30;:21;:30;:::i;:::-;-1:-1:-1;56285:29:0;:12;56302:7;56311:2;56285:29;:16;:29;:::i;:::-;;56351:7;56347:2;-1:-1:-1;;;;;56332:27:0;56341:4;-1:-1:-1;;;;;56332:27:0;;;;;;;;;;;55793:574;;;:::o;27626:137::-;27697:7;27732:22;27736:3;27748:5;27732:3;:22::i;54887:520::-;54947:13;54963:16;54971:7;54963;:16::i;:::-;54947:32;;54992:48;55013:5;55028:1;55032:7;54992:20;:48::i;:::-;55081:29;55098:1;55102:7;55081:8;:29::i;:::-;55169:19;;;;:10;:19;;;;;55163:33;;-1:-1:-1;;55163:33:0;;;;;;;;;;;:38;55159:97;;55225:19;;;;:10;:19;;;;;55218:26;;;:::i;:::-;-1:-1:-1;;;;;55268:20:0;;;;;;:13;:20;;;;;:36;;55296:7;55268:36;:27;:36;:::i;:::-;-1:-1:-1;55317:28:0;:12;55337:7;55317:28;:19;:28;:::i;:::-;-1:-1:-1;55363:36:0;;55391:7;;55387:1;;-1:-1:-1;;;;;55363:36:0;;;;;55387:1;;55363:36;54887:520;;:::o;35481:227::-;35561:7;;;;35621:22;35625:3;35637:5;35621:3;:22::i;:::-;35590:53;;;;-1:-1:-1;35481:227:0;-1:-1:-1;;;;;35481:227:0:o;60401:151::-;60483:27;60501:8;60483:17;:27::i;:::-;60526:18;60534:9;:7;:9::i;:::-;60526:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:100:-1;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;60526:18:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60401:151;:::o;36143:204::-;36250:7;36293:44;36298:3;36318;36324:12;36293:4;:44::i;:::-;36285:53;-1:-1:-1;36143:204:0;;;;;;:::o;51231:272::-;51345:28;51355:4;51361:2;51365:7;51345:9;:28::i;:::-;51392:48;51415:4;51421:2;51425:7;51434:5;51392:22;:48::i;:::-;51384:111;;;;-1:-1:-1;;;51384:111:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;36586:744;36642:13;36863:10;36859:53;;-1:-1:-1;36890:10:0;;;;;;;;;;;;-1:-1:-1;;;36890:10:0;;;;;;36859:53;36937:5;36922:12;36978:78;36985:9;;36978:78;;37011:8;;37042:2;37034:10;;;;36978:78;;;37066:19;37098:6;37088:17;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;37088:17:0;;;;;;;;;;;;;;;;;;;;;;;;;;21:6:-1;;108:14;37088:17:0;87:42:-1;143:17;;-1:-1;37088:17:0;-1:-1:-1;37160:5:0;;-1:-1:-1;37066:39:0;-1:-1:-1;;;37132:10:0;;37176:115;37183:9;;37176:115;;37250:2;37243:4;:9;37238:2;:14;37227:27;;37209:6;37216:7;;;;;;;37209:15;;;;;;;;;;;:45;-1:-1:-1;;;;;37209:45:0;;;;;;;;-1:-1:-1;37277:2:0;37269:10;;;;37176:115;;;-1:-1:-1;37315:6:0;36586:744;-1:-1:-1;;;;36586:744:0:o;34780:151::-;34864:4;34888:35;34898:3;34918;34888:9;:35::i;78538:822::-;78614:23;78650:19;78680:14;78672:23;;78650:45;;78942:4;78936:11;-1:-1:-1;;;78968:5:0;78961:81;79081:11;79074:4;79067:5;79063:16;79056:37;-1:-1:-1;;;79125:4:0;79118:5;79114:16;79107:92;79249:4;79242:5;79239:1;79232:22;79213:41;78908:357;-1:-1:-1;;;;78908:357:0:o;53068:110::-;53144:26;53154:2;53158:7;53144:26;;;;;;;;;;;;:9;:26::i;32402:110::-;32485:19;;32402:110::o;26713:137::-;26783:4;26807:35;26815:3;26835:5;26807:7;:35::i;26406:131::-;26473:4;26497:32;26502:3;26522:5;26497:4;:32::i;34212:176::-;34301:4;34325:55;34330:3;34350;-1:-1:-1;;;;;34364:14:0;;34325:4;:55::i;24290:204::-;24385:18;;24357:7;;24385:26;-1:-1:-1;24377:73:0;;;;-1:-1:-1;;;24377:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24468:3;:11;;24480:5;24468:18;;;;;;;;;;;;;;;;24461:25;;24290:204;;;;:::o;34554:142::-;34631:4;34655:33;34663:3;34683;34655:7;:33::i;32867:279::-;32971:19;;32934:7;;;;32971:27;-1:-1:-1;32963:74:0;;;;-1:-1:-1;;;32963:74:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33050:22;33075:3;:12;;33088:5;33075:19;;;;;;;;;;;;;;;;;;33050:44;;33113:5;:10;;;33125:5;:12;;;33105:33;;;;;32867:279;;;;;:::o;33569:319::-;33663:7;33702:17;;;:12;;;:17;;;;;;33753:12;33738:13;33730:36;;;;-1:-1:-1;;;33730:36:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;33730:36:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33820:3;:12;;33844:1;33833:8;:12;33820:26;;;;;;;;;;;;;;;;;;:33;;;33813:40;;;33569:319;;;;;:::o;57821:1078::-;57942:4;57969:15;:2;-1:-1:-1;;;;;57969:13:0;;:15::i;:::-;57964:60;;-1:-1:-1;58008:4:0;58001:11;;57964:60;58095:12;58109:23;-1:-1:-1;;;;;58136:7:0;;-1:-1:-1;;;58241:12:0;:10;:12::i;:::-;58268:4;58287:7;58309:5;58144:181;;;;;;-1:-1:-1;;;;;58144:181:0;-1:-1:-1;;;;;58144:181:0;;;;;;-1:-1:-1;;;;;58144:181:0;-1:-1:-1;;;;;58144:181:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;58144:181:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;58144:181:0;;;-1:-1:-1;;26:21;;;22:32;6:49;;58144:181:0;;;49:4:-1;25:18;;61:17;;-1:-1;;;;;182:15;-1:-1;;;;;;58144:181:0;;;179:29:-1;;;;160:49;;58136:190:0;;;58144:181;;58136:190;;-1:-1:-1;58136:190:0;;-1:-1:-1;25:18;-1:-1;58136:190:0;-1:-1:-1;58136:190:0;;-1:-1:-1;58136:190:0;;-1:-1:-1;25:18;36:153;66:2;61:3;58:11;36:153;;176:10;;164:23;;-1:-1;;139:12;;;;98:2;89:12;;;;114;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;58136:190:0;;;;;;;;;;;;;;;;;;;;;;;;12:1:-1;19;14:27;;;;67:4;61:11;56:16;;134:4;130:9;123:4;105:16;101:27;97:43;94:1;90:51;84:4;77:65;157:16;154:1;147:27;211:16;208:1;201:4;198:1;194:12;179:49;5:228;;14:27;32:4;27:9;;5:228;;58094:232:0;;;;58342:7;58337:555;;58370:17;;:21;58366:384;;58538:10;58532:17;58599:15;58586:10;58582:2;58578:19;58571:44;58486:148;58674:60;;-1:-1:-1;;;58674:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58337:555;58782:13;58809:10;58798:32;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;58798:32:0;-1:-1:-1;;;;;;58853:26:0;-1:-1:-1;;;58853:26:0;;-1:-1:-1;58845:35:0;;-1:-1:-1;;;58845:35:0;32182:125;32253:4;32277:17;;;:12;;;;;:17;;;;;;:22;;;32182:125::o;53792:250::-;53888:18;53894:2;53898:7;53888:5;:18::i;:::-;53925:54;53956:1;53960:2;53964:7;53973:5;53925:22;:54::i;:::-;53917:117;;;;-1:-1:-1;;;53917:117:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21992:1544;22058:4;22197:19;;;:12;;;:19;;;;;;22233:15;;22229:1300;;22668:18;;-1:-1:-1;;22619:14:0;;;;22668:22;;;;22595:21;;22668:3;;:22;;22955;;;;;;;;;;;;;;22935:42;;23101:9;23072:3;:11;;23084:13;23072:26;;;;;;;;;;;;;;;;;;;:38;;;;23178:23;;;23220:1;23178:12;;;:23;;;;;;23204:17;;;23178:43;;23330:17;;23178:3;;23330:17;;;;;;;;;;;;;;;;;;;;;;23425:3;:12;;:19;23438:5;23425:19;;;;;;;;;;;23418:26;;;23468:4;23461:11;;;;;;;;22229:1300;23512:5;23505:12;;;;;21402:414;21465:4;21487:21;21497:3;21502:5;21487:9;:21::i;:::-;21482:327;;-1:-1:-1;27:10;;39:1;23:18;;;45:23;;21525:11:0;:23;;;;;;;;;;;;;21708:18;;21686:19;;;:12;;;:19;;;;;;:40;;;;21741:11;;21482:327;-1:-1:-1;21792:5:0;21785:12;;29682:692;29758:4;29893:17;;;:12;;;:17;;;;;;29927:13;29923:444;;-1:-1:-1;;30012:38:0;;;;;;;;;;;;;;;;;;27:10:-1;;39:1;23:18;;;45:23;;29994:12:0;:57;;;;;;;;;;;;;;;;;;;;;;;;30209:19;;30189:17;;;:12;;;:17;;;;;;;:39;30243:11;;29923:444;30323:5;30287:3;:12;;30311:1;30300:8;:12;30287:26;;;;;;;;;;;;;;;;;;:33;;:41;;;;30350:5;30343:12;;;;;30549:1549;30613:4;30748:17;;;:12;;;:17;;;;;;30782:13;;30778:1313;;31214:19;;-1:-1:-1;;31167:12:0;;;;31214:23;;;;31143:21;;31214:3;;:23;;31511;;;;;;;;;;;;;;;;31482:52;;31659:9;31629:3;:12;;31642:13;31629:27;;;;;;;;;;;;;;;;:39;;:27;;;;;:39;;;;;;;;;;;;;;;31749:14;;31736:28;;:12;;;:28;;;;;31767:17;;;31736:48;;31893:18;;31736:3;;31893:18;;;;;;;;;;;;;;-1:-1:-1;;31893:18:0;;;;;;;;;;;;;;;;;;;;;31989:17;;;:12;;;:17;;;;;;31982:24;;;;31893:18;-1:-1:-1;32023:11:0;;-1:-1:-1;;;;32023:11:0;17755:619;17815:4;18283:20;;18126:66;18323:23;;;;;;:42;;-1:-1:-1;;18350:15:0;;;18315:51;-1:-1:-1;;17755:619:0:o;54295:404::-;-1:-1:-1;;;;;54375:16:0;;54367:61;;;;;-1:-1:-1;;;54367:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54448:16;54456:7;54448;:16::i;:::-;54447:17;54439:58;;;;;-1:-1:-1;;;54439:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;54510:45;54539:1;54543:2;54547:7;54510:20;:45::i;:::-;-1:-1:-1;;;;;54568:17:0;;;;;;:13;:17;;;;;:30;;54590:7;54568:30;:21;:30;:::i;:::-;-1:-1:-1;54611:29:0;:12;54628:7;54637:2;54611:29;:16;:29;:::i;:::-;-1:-1:-1;54658:33:0;;54683:7;;-1:-1:-1;;;;;54658:33:0;;;54675:1;;54658:33;;54675:1;;54658:33;54295:404;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
Swarm Source
ipfs://19a59065eefc73603501a4646e77691a4a4244237d395820cdafd0b8a1664e5f
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.