Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
Latest 1 from a total of 1 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
0x60806040 | 17171330 | 495 days ago | IN | 0 ETH | 0.15471954 |
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Contract Name:
OriginsNFT
Compiler Version
v0.8.17+commit.8df45f5f
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2023-05-02 */ // File: @openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol // OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol) /** * @dev Collection of functions related to the address type */ library AddressUpgradeable { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== * * [IMPORTANT] * ==== * You shouldn't rely on `isContract` to protect against flash loan attacks! * * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract * constructor. * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize/address.code.length, which returns 0 // for contracts in construction, since the code is only stored at the end // of the constructor execution. return account.code.length > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); (bool success, ) = recipient.call{value: amount}(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value ) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage ) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall( address target, bytes memory data, string memory errorMessage ) internal view returns (bytes memory) { (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract. * * _Available since v4.8._ */ function verifyCallResultFromTarget( address target, bool success, bytes memory returndata, string memory errorMessage ) internal view returns (bytes memory) { if (success) { if (returndata.length == 0) { // only check isContract if the call was successful and the return data is empty // otherwise we already know that it was a contract require(isContract(target), "Address: call to non-contract"); } return returndata; } else { _revert(returndata, errorMessage); } } /** * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason or using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal pure returns (bytes memory) { if (success) { return returndata; } else { _revert(returndata, errorMessage); } } function _revert(bytes memory returndata, string memory errorMessage) private pure { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } // File: @openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol // OpenZeppelin Contracts (last updated v4.8.1) (proxy/utils/Initializable.sol) /** * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect. * * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in * case an upgrade adds a module that needs to be initialized. * * For example: * * [.hljs-theme-light.nopadding] * ``` * contract MyToken is ERC20Upgradeable { * function initialize() initializer public { * __ERC20_init("MyToken", "MTK"); * } * } * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable { * function initializeV2() reinitializer(2) public { * __ERC20Permit_init("MyToken"); * } * } * ``` * * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}. * * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity. * * [CAUTION] * ==== * Avoid leaving a contract uninitialized. * * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed: * * [.hljs-theme-light.nopadding] * ``` * /// @custom:oz-upgrades-unsafe-allow constructor * constructor() { * _disableInitializers(); * } * ``` * ==== */ abstract contract Initializable { /** * @dev Indicates that the contract has been initialized. * @custom:oz-retyped-from bool */ uint8 private _initialized; /** * @dev Indicates that the contract is in the process of being initialized. */ bool private _initializing; /** * @dev Triggered when the contract has been initialized or reinitialized. */ event Initialized(uint8 version); /** * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope, * `onlyInitializing` functions can be used to initialize parent contracts. * * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a * constructor. * * Emits an {Initialized} event. */ modifier initializer() { bool isTopLevelCall = !_initializing; require( (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1), "Initializable: contract is already initialized" ); _initialized = 1; if (isTopLevelCall) { _initializing = true; } _; if (isTopLevelCall) { _initializing = false; emit Initialized(1); } } /** * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be * used to initialize parent contracts. * * A reinitializer may be used after the original initialization step. This is essential to configure modules that * are added through upgrades and that require initialization. * * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer` * cannot be nested. If one is invoked in the context of another, execution will revert. * * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in * a contract, executing them in the right order is up to the developer or operator. * * WARNING: setting the version to 255 will prevent any future reinitialization. * * Emits an {Initialized} event. */ modifier reinitializer(uint8 version) { require(!_initializing && _initialized < version, "Initializable: contract is already initialized"); _initialized = version; _initializing = true; _; _initializing = false; emit Initialized(version); } /** * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the * {initializer} and {reinitializer} modifiers, directly or indirectly. */ modifier onlyInitializing() { require(_initializing, "Initializable: contract is not initializing"); _; } /** * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call. * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized * to any version. It is recommended to use this to lock implementation contracts that are designed to be called * through proxies. * * Emits an {Initialized} event the first time it is successfully executed. */ function _disableInitializers() internal virtual { require(!_initializing, "Initializable: contract is initializing"); if (_initialized < type(uint8).max) { _initialized = type(uint8).max; emit Initialized(type(uint8).max); } } /** * @dev Returns the highest version that has been initialized. See {reinitializer}. */ function _getInitializedVersion() internal view returns (uint8) { return _initialized; } /** * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}. */ function _isInitializing() internal view returns (bool) { return _initializing; } } // File: @openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol // OpenZeppelin Contracts v4.4.1 (utils/Context.sol) /** * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract ContextUpgradeable is Initializable { function __Context_init() internal onlyInitializing { } function __Context_init_unchained() internal onlyInitializing { } function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[50] private __gap; } // File: @openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol) /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ function __Ownable_init() internal onlyInitializing { __Ownable_init_unchained(); } function __Ownable_init_unchained() internal onlyInitializing { _transferOwnership(_msgSender()); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { require(owner() == _msgSender(), "Ownable: caller is not the owner"); } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions anymore. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby removing any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[49] private __gap; } // File: @openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol // OpenZeppelin Contracts (last updated v4.8.0) (access/Ownable2Step.sol) /** * @dev Contract module which provides access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership} and {acceptOwnership}. * * This module is used through inheritance. It will make available all functions * from parent (Ownable). */ abstract contract Ownable2StepUpgradeable is Initializable, OwnableUpgradeable { function __Ownable2Step_init() internal onlyInitializing { __Ownable_init_unchained(); } function __Ownable2Step_init_unchained() internal onlyInitializing { } address private _pendingOwner; event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner); /** * @dev Returns the address of the pending owner. */ function pendingOwner() public view virtual returns (address) { return _pendingOwner; } /** * @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one. * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual override onlyOwner { _pendingOwner = newOwner; emit OwnershipTransferStarted(owner(), newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner. * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual override { delete _pendingOwner; super._transferOwnership(newOwner); } /** * @dev The new owner accepts the ownership transfer. */ function acceptOwnership() external { address sender = _msgSender(); require(pendingOwner() == sender, "Ownable2Step: caller is not the new owner"); _transferOwnership(sender); } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[49] private __gap; } // File: @openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol // OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol) /** * @dev Contract module which allows children to implement an emergency stop * mechanism that can be triggered by an authorized account. * * This module is used through inheritance. It will make available the * modifiers `whenNotPaused` and `whenPaused`, which can be applied to * the functions of your contract. Note that they will not be pausable by * simply including this module, only once the modifiers are put in place. */ abstract contract PausableUpgradeable is Initializable, ContextUpgradeable { /** * @dev Emitted when the pause is triggered by `account`. */ event Paused(address account); /** * @dev Emitted when the pause is lifted by `account`. */ event Unpaused(address account); bool private _paused; /** * @dev Initializes the contract in unpaused state. */ function __Pausable_init() internal onlyInitializing { __Pausable_init_unchained(); } function __Pausable_init_unchained() internal onlyInitializing { _paused = false; } /** * @dev Modifier to make a function callable only when the contract is not paused. * * Requirements: * * - The contract must not be paused. */ modifier whenNotPaused() { _requireNotPaused(); _; } /** * @dev Modifier to make a function callable only when the contract is paused. * * Requirements: * * - The contract must be paused. */ modifier whenPaused() { _requirePaused(); _; } /** * @dev Returns true if the contract is paused, and false otherwise. */ function paused() public view virtual returns (bool) { return _paused; } /** * @dev Throws if the contract is paused. */ function _requireNotPaused() internal view virtual { require(!paused(), "Pausable: paused"); } /** * @dev Throws if the contract is not paused. */ function _requirePaused() internal view virtual { require(paused(), "Pausable: not paused"); } /** * @dev Triggers stopped state. * * Requirements: * * - The contract must not be paused. */ function _pause() internal virtual whenNotPaused { _paused = true; emit Paused(_msgSender()); } /** * @dev Returns to normal state. * * Requirements: * * - The contract must be paused. */ function _unpause() internal virtual whenPaused { _paused = false; emit Unpaused(_msgSender()); } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[49] private __gap; } // File: @openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol // OpenZeppelin Contracts (last updated v4.8.0) (security/ReentrancyGuard.sol) /** * @dev Contract module that helps prevent reentrant calls to a function. * * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier * available, which can be applied to functions to make sure there are no nested * (reentrant) calls to them. * * Note that because there is a single `nonReentrant` guard, functions marked as * `nonReentrant` may not call one another. This can be worked around by making * those functions `private`, and then adding `external` `nonReentrant` entry * points to them. * * TIP: If you would like to learn more about reentrancy and alternative ways * to protect against it, check out our blog post * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul]. */ abstract contract ReentrancyGuardUpgradeable is Initializable { // Booleans are more expensive than uint256 or any type that takes up a full // word because each write operation emits an extra SLOAD to first read the // slot's contents, replace the bits taken up by the boolean, and then write // back. This is the compiler's defense against contract upgrades and // pointer aliasing, and it cannot be disabled. // The values being non-zero value makes deployment a bit more expensive, // but in exchange the refund on every call to nonReentrant will be lower in // amount. Since refunds are capped to a percentage of the total // transaction's gas, it is best to keep them low in cases like this one, to // increase the likelihood of the full refund coming into effect. uint256 private constant _NOT_ENTERED = 1; uint256 private constant _ENTERED = 2; uint256 private _status; function __ReentrancyGuard_init() internal onlyInitializing { __ReentrancyGuard_init_unchained(); } function __ReentrancyGuard_init_unchained() internal onlyInitializing { _status = _NOT_ENTERED; } /** * @dev Prevents a contract from calling itself, directly or indirectly. * Calling a `nonReentrant` function from another `nonReentrant` * function is not supported. It is possible to prevent this from happening * by making the `nonReentrant` function external, and making it call a * `private` function that does the actual work. */ modifier nonReentrant() { _nonReentrantBefore(); _; _nonReentrantAfter(); } function _nonReentrantBefore() private { // On the first call to nonReentrant, _status will be _NOT_ENTERED require(_status != _ENTERED, "ReentrancyGuard: reentrant call"); // Any calls to nonReentrant after this point will fail _status = _ENTERED; } function _nonReentrantAfter() private { // By storing the original value once again, a refund is triggered (see // https://eips.ethereum.org/EIPS/eip-2200) _status = _NOT_ENTERED; } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[49] private __gap; } // File: @openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol // OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol) /** * @dev Interface of the ERC165 standard, as defined in the * https://eips.ethereum.org/EIPS/eip-165[EIP]. * * Implementers can declare support of contract interfaces, which can then be * queried by others ({ERC165Checker}). * * For an implementation, see {ERC165}. */ interface IERC165Upgradeable { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); } // File: @openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol // OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/IERC721.sol) /** * @dev Required interface of an ERC721 compliant contract. */ interface IERC721Upgradeable is IERC165Upgradeable { /** * @dev Emitted when `tokenId` token is transferred from `from` to `to`. */ event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token. */ event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets. */ event ApprovalForAll(address indexed owner, address indexed operator, bool approved); /** * @dev Returns the number of tokens in ``owner``'s account. */ function balanceOf(address owner) external view returns (uint256 balance); /** * @dev Returns the owner of the `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function ownerOf(uint256 tokenId) external view returns (address owner); /** * @dev Safely transfers `tokenId` token from `from` to `to`. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom( address from, address to, uint256 tokenId, bytes calldata data ) external; /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom( address from, address to, uint256 tokenId ) external; /** * @dev Transfers `tokenId` token from `from` to `to`. * * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721 * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must * understand this adds an external call which potentially creates a reentrancy vulnerability. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * * Emits a {Transfer} event. */ function transferFrom( address from, address to, uint256 tokenId ) external; /** * @dev Gives permission to `to` to transfer `tokenId` token to another account. * The approval is cleared when the token is transferred. * * Only a single account can be approved at a time, so approving the zero address clears previous approvals. * * Requirements: * * - The caller must own the token or be an approved operator. * - `tokenId` must exist. * * Emits an {Approval} event. */ function approve(address to, uint256 tokenId) external; /** * @dev Approve or remove `operator` as an operator for the caller. * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. * * Requirements: * * - The `operator` cannot be the caller. * * Emits an {ApprovalForAll} event. */ function setApprovalForAll(address operator, bool _approved) external; /** * @dev Returns the account approved for `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function getApproved(uint256 tokenId) external view returns (address operator); /** * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`. * * See {setApprovalForAll} */ function isApprovedForAll(address owner, address operator) external view returns (bool); } // File: @openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol) /** * @title ERC721 token receiver interface * @dev Interface for any contract that wants to support safeTransfers * from ERC721 asset contracts. */ interface IERC721ReceiverUpgradeable { /** * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom} * by `operator` from `from`, this function is called. * * It must return its Solidity selector to confirm the token transfer. * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted. * * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`. */ function onERC721Received( address operator, address from, uint256 tokenId, bytes calldata data ) external returns (bytes4); } // File: @openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol // OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol) /** * @title ERC-721 Non-Fungible Token Standard, optional metadata extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721MetadataUpgradeable is IERC721Upgradeable { /** * @dev Returns the token collection name. */ function name() external view returns (string memory); /** * @dev Returns the token collection symbol. */ function symbol() external view returns (string memory); /** * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token. */ function tokenURI(uint256 tokenId) external view returns (string memory); } // File: @openzeppelin/contracts-upgradeable/utils/math/MathUpgradeable.sol // OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol) /** * @dev Standard math utilities missing in the Solidity language. */ library MathUpgradeable { enum Rounding { Down, // Toward negative infinity Up, // Toward infinity Zero // Toward zero } /** * @dev Returns the largest of two numbers. */ function max(uint256 a, uint256 b) internal pure returns (uint256) { return a > b ? a : b; } /** * @dev Returns the smallest of two numbers. */ function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } /** * @dev Returns the average of two numbers. The result is rounded towards * zero. */ function average(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b) / 2 can overflow. return (a & b) + (a ^ b) / 2; } /** * @dev Returns the ceiling of the division of two numbers. * * This differs from standard division with `/` in that it rounds up instead * of rounding down. */ function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b - 1) / b can overflow on addition, so we distribute. return a == 0 ? 0 : (a - 1) / b + 1; } /** * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0 * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) * with further edits by Uniswap Labs also under MIT license. */ function mulDiv( uint256 x, uint256 y, uint256 denominator ) internal pure returns (uint256 result) { unchecked { // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256 // variables such that product = prod1 * 2^256 + prod0. uint256 prod0; // Least significant 256 bits of the product uint256 prod1; // Most significant 256 bits of the product assembly { let mm := mulmod(x, y, not(0)) prod0 := mul(x, y) prod1 := sub(sub(mm, prod0), lt(mm, prod0)) } // Handle non-overflow cases, 256 by 256 division. if (prod1 == 0) { return prod0 / denominator; } // Make sure the result is less than 2^256. Also prevents denominator == 0. require(denominator > prod1); /////////////////////////////////////////////// // 512 by 256 division. /////////////////////////////////////////////// // Make division exact by subtracting the remainder from [prod1 prod0]. uint256 remainder; assembly { // Compute remainder using mulmod. remainder := mulmod(x, y, denominator) // Subtract 256 bit number from 512 bit number. prod1 := sub(prod1, gt(remainder, prod0)) prod0 := sub(prod0, remainder) } // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1. // See https://cs.stackexchange.com/q/138556/92363. // Does not overflow because the denominator cannot be zero at this stage in the function. uint256 twos = denominator & (~denominator + 1); assembly { // Divide denominator by twos. denominator := div(denominator, twos) // Divide [prod1 prod0] by twos. prod0 := div(prod0, twos) // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one. twos := add(div(sub(0, twos), twos), 1) } // Shift in bits from prod1 into prod0. prod0 |= prod1 * twos; // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for // four bits. That is, denominator * inv = 1 mod 2^4. uint256 inverse = (3 * denominator) ^ 2; // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works // in modular arithmetic, doubling the correct bits in each step. inverse *= 2 - denominator * inverse; // inverse mod 2^8 inverse *= 2 - denominator * inverse; // inverse mod 2^16 inverse *= 2 - denominator * inverse; // inverse mod 2^32 inverse *= 2 - denominator * inverse; // inverse mod 2^64 inverse *= 2 - denominator * inverse; // inverse mod 2^128 inverse *= 2 - denominator * inverse; // inverse mod 2^256 // Because the division is now exact we can divide by multiplying with the modular inverse of denominator. // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1 // is no longer required. result = prod0 * inverse; return result; } } /** * @notice Calculates x * y / denominator with full precision, following the selected rounding direction. */ function mulDiv( uint256 x, uint256 y, uint256 denominator, Rounding rounding ) internal pure returns (uint256) { uint256 result = mulDiv(x, y, denominator); if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) { result += 1; } return result; } /** * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down. * * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11). */ function sqrt(uint256 a) internal pure returns (uint256) { if (a == 0) { return 0; } // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target. // // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`. // // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)` // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))` // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)` // // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit. uint256 result = 1 << (log2(a) >> 1); // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128, // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision // into the expected uint128 result. unchecked { result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; return min(result, a / result); } } /** * @notice Calculates sqrt(a), following the selected rounding direction. */ function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = sqrt(a); return result + (rounding == Rounding.Up && result * result < a ? 1 : 0); } } /** * @dev Return the log in base 2, rounded down, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 128; } if (value >> 64 > 0) { value >>= 64; result += 64; } if (value >> 32 > 0) { value >>= 32; result += 32; } if (value >> 16 > 0) { value >>= 16; result += 16; } if (value >> 8 > 0) { value >>= 8; result += 8; } if (value >> 4 > 0) { value >>= 4; result += 4; } if (value >> 2 > 0) { value >>= 2; result += 2; } if (value >> 1 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 2, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log2(value); return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0); } } /** * @dev Return the log in base 10, rounded down, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >= 10**64) { value /= 10**64; result += 64; } if (value >= 10**32) { value /= 10**32; result += 32; } if (value >= 10**16) { value /= 10**16; result += 16; } if (value >= 10**8) { value /= 10**8; result += 8; } if (value >= 10**4) { value /= 10**4; result += 4; } if (value >= 10**2) { value /= 10**2; result += 2; } if (value >= 10**1) { result += 1; } } return result; } /** * @dev Return the log in base 10, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log10(value); return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0); } } /** * @dev Return the log in base 256, rounded down, of a positive value. * Returns 0 if given 0. * * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string. */ function log256(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 16; } if (value >> 64 > 0) { value >>= 64; result += 8; } if (value >> 32 > 0) { value >>= 32; result += 4; } if (value >> 16 > 0) { value >>= 16; result += 2; } if (value >> 8 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 10, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log256(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log256(value); return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0); } } } // File: @openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol // OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol) /** * @dev String operations. */ library StringsUpgradeable { bytes16 private constant _SYMBOLS = "0123456789abcdef"; uint8 private constant _ADDRESS_LENGTH = 20; /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function toString(uint256 value) internal pure returns (string memory) { unchecked { uint256 length = MathUpgradeable.log10(value) + 1; string memory buffer = new string(length); uint256 ptr; /// @solidity memory-safe-assembly assembly { ptr := add(buffer, add(32, length)) } while (true) { ptr--; /// @solidity memory-safe-assembly assembly { mstore8(ptr, byte(mod(value, 10), _SYMBOLS)) } value /= 10; if (value == 0) break; } return buffer; } } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { unchecked { return toHexString(value, MathUpgradeable.log256(value) + 1); } } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length. */ function toHexString(uint256 value, uint256 length) internal pure returns (string memory) { bytes memory buffer = new bytes(2 * length + 2); buffer[0] = "0"; buffer[1] = "x"; for (uint256 i = 2 * length + 1; i > 1; --i) { buffer[i] = _SYMBOLS[value & 0xf]; value >>= 4; } require(value == 0, "Strings: hex length insufficient"); return string(buffer); } /** * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation. */ function toHexString(address addr) internal pure returns (string memory) { return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH); } } // File: @openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol // OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol) /** * @dev Implementation of the {IERC165} interface. * * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check * for the additional interface id that will be supported. For example: * * ```solidity * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId); * } * ``` * * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation. */ abstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable { function __ERC165_init() internal onlyInitializing { } function __ERC165_init_unchained() internal onlyInitializing { } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IERC165Upgradeable).interfaceId; } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[50] private __gap; } // File: @openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol // OpenZeppelin Contracts (last updated v4.8.2) (token/ERC721/ERC721.sol) /** * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including * the Metadata extension, but not including the Enumerable extension, which is available separately as * {ERC721Enumerable}. */ contract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable { using AddressUpgradeable for address; using StringsUpgradeable for uint256; // Token name string private _name; // Token symbol string private _symbol; // Mapping from token ID to owner address mapping(uint256 => address) private _owners; // Mapping owner address to token count mapping(address => uint256) private _balances; // Mapping from token ID to approved address mapping(uint256 => address) private _tokenApprovals; // Mapping from owner to operator approvals mapping(address => mapping(address => bool)) private _operatorApprovals; /** * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection. */ function __ERC721_init(string memory name_, string memory symbol_) internal onlyInitializing { __ERC721_init_unchained(name_, symbol_); } function __ERC721_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing { _name = name_; _symbol = symbol_; } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) { return interfaceId == type(IERC721Upgradeable).interfaceId || interfaceId == type(IERC721MetadataUpgradeable).interfaceId || super.supportsInterface(interfaceId); } /** * @dev See {IERC721-balanceOf}. */ function balanceOf(address owner) public view virtual override returns (uint256) { require(owner != address(0), "ERC721: address zero is not a valid owner"); return _balances[owner]; } /** * @dev See {IERC721-ownerOf}. */ function ownerOf(uint256 tokenId) public view virtual override returns (address) { address owner = _ownerOf(tokenId); require(owner != address(0), "ERC721: invalid token ID"); return owner; } /** * @dev See {IERC721Metadata-name}. */ function name() public view virtual override returns (string memory) { return _name; } /** * @dev See {IERC721Metadata-symbol}. */ function symbol() public view virtual override returns (string memory) { return _symbol; } /** * @dev See {IERC721Metadata-tokenURI}. */ function tokenURI(uint256 tokenId) public view virtual override returns (string memory) { _requireMinted(tokenId); string memory baseURI = _baseURI(); return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : ""; } /** * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each * token will be the concatenation of the `baseURI` and the `tokenId`. Empty * by default, can be overridden in child contracts. */ function _baseURI() internal view virtual returns (string memory) { return ""; } /** * @dev See {IERC721-approve}. */ function approve(address to, uint256 tokenId) public virtual override { address owner = ERC721Upgradeable.ownerOf(tokenId); require(to != owner, "ERC721: approval to current owner"); require( _msgSender() == owner || isApprovedForAll(owner, _msgSender()), "ERC721: approve caller is not token owner or approved for all" ); _approve(to, tokenId); } /** * @dev See {IERC721-getApproved}. */ function getApproved(uint256 tokenId) public view virtual override returns (address) { _requireMinted(tokenId); return _tokenApprovals[tokenId]; } /** * @dev See {IERC721-setApprovalForAll}. */ function setApprovalForAll(address operator, bool approved) public virtual override { _setApprovalForAll(_msgSender(), operator, approved); } /** * @dev See {IERC721-isApprovedForAll}. */ function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) { return _operatorApprovals[owner][operator]; } /** * @dev See {IERC721-transferFrom}. */ function transferFrom( address from, address to, uint256 tokenId ) public virtual override { //solhint-disable-next-line max-line-length require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved"); _transfer(from, to, tokenId); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom( address from, address to, uint256 tokenId ) public virtual override { safeTransferFrom(from, to, tokenId, ""); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom( address from, address to, uint256 tokenId, bytes memory data ) public virtual override { require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved"); _safeTransfer(from, to, tokenId, data); } /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * `data` is additional data, it has no specified format and it is sent in call to `to`. * * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g. * implement alternative mechanisms to perform token transfer, such as signature-based. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function _safeTransfer( address from, address to, uint256 tokenId, bytes memory data ) internal virtual { _transfer(from, to, tokenId); require(_checkOnERC721Received(from, to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer"); } /** * @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist */ function _ownerOf(uint256 tokenId) internal view virtual returns (address) { return _owners[tokenId]; } /** * @dev Returns whether `tokenId` exists. * * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}. * * Tokens start existing when they are minted (`_mint`), * and stop existing when they are burned (`_burn`). */ function _exists(uint256 tokenId) internal view virtual returns (bool) { return _ownerOf(tokenId) != address(0); } /** * @dev Returns whether `spender` is allowed to manage `tokenId`. * * Requirements: * * - `tokenId` must exist. */ function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) { address owner = ERC721Upgradeable.ownerOf(tokenId); return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender); } /** * @dev Safely mints `tokenId` and transfers it to `to`. * * Requirements: * * - `tokenId` must not exist. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function _safeMint(address to, uint256 tokenId) internal virtual { _safeMint(to, tokenId, ""); } /** * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is * forwarded in {IERC721Receiver-onERC721Received} to contract recipients. */ function _safeMint( address to, uint256 tokenId, bytes memory data ) internal virtual { _mint(to, tokenId); require( _checkOnERC721Received(address(0), to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer" ); } /** * @dev Mints `tokenId` and transfers it to `to`. * * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible * * Requirements: * * - `tokenId` must not exist. * - `to` cannot be the zero address. * * Emits a {Transfer} event. */ function _mint(address to, uint256 tokenId) internal virtual { require(to != address(0), "ERC721: mint to the zero address"); require(!_exists(tokenId), "ERC721: token already minted"); _beforeTokenTransfer(address(0), to, tokenId, 1); // Check that tokenId was not minted by `_beforeTokenTransfer` hook require(!_exists(tokenId), "ERC721: token already minted"); unchecked { // Will not overflow unless all 2**256 token ids are minted to the same owner. // Given that tokens are minted one by one, it is impossible in practice that // this ever happens. Might change if we allow batch minting. // The ERC fails to describe this case. _balances[to] += 1; } _owners[tokenId] = to; emit Transfer(address(0), to, tokenId); _afterTokenTransfer(address(0), to, tokenId, 1); } /** * @dev Destroys `tokenId`. * The approval is cleared when the token is burned. * This is an internal function that does not check if the sender is authorized to operate on the token. * * Requirements: * * - `tokenId` must exist. * * Emits a {Transfer} event. */ function _burn(uint256 tokenId) internal virtual { address owner = ERC721Upgradeable.ownerOf(tokenId); _beforeTokenTransfer(owner, address(0), tokenId, 1); // Update ownership in case tokenId was transferred by `_beforeTokenTransfer` hook owner = ERC721Upgradeable.ownerOf(tokenId); // Clear approvals delete _tokenApprovals[tokenId]; unchecked { // Cannot overflow, as that would require more tokens to be burned/transferred // out than the owner initially received through minting and transferring in. _balances[owner] -= 1; } delete _owners[tokenId]; emit Transfer(owner, address(0), tokenId); _afterTokenTransfer(owner, address(0), tokenId, 1); } /** * @dev Transfers `tokenId` from `from` to `to`. * As opposed to {transferFrom}, this imposes no restrictions on msg.sender. * * Requirements: * * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * * Emits a {Transfer} event. */ function _transfer( address from, address to, uint256 tokenId ) internal virtual { require(ERC721Upgradeable.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner"); require(to != address(0), "ERC721: transfer to the zero address"); _beforeTokenTransfer(from, to, tokenId, 1); // Check that tokenId was not transferred by `_beforeTokenTransfer` hook require(ERC721Upgradeable.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner"); // Clear approvals from the previous owner delete _tokenApprovals[tokenId]; unchecked { // `_balances[from]` cannot overflow for the same reason as described in `_burn`: // `from`'s balance is the number of token held, which is at least one before the current // transfer. // `_balances[to]` could overflow in the conditions described in `_mint`. That would require // all 2**256 token ids to be minted, which in practice is impossible. _balances[from] -= 1; _balances[to] += 1; } _owners[tokenId] = to; emit Transfer(from, to, tokenId); _afterTokenTransfer(from, to, tokenId, 1); } /** * @dev Approve `to` to operate on `tokenId` * * Emits an {Approval} event. */ function _approve(address to, uint256 tokenId) internal virtual { _tokenApprovals[tokenId] = to; emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId); } /** * @dev Approve `operator` to operate on all of `owner` tokens * * Emits an {ApprovalForAll} event. */ function _setApprovalForAll( address owner, address operator, bool approved ) internal virtual { require(owner != operator, "ERC721: approve to caller"); _operatorApprovals[owner][operator] = approved; emit ApprovalForAll(owner, operator, approved); } /** * @dev Reverts if the `tokenId` has not been minted yet. */ function _requireMinted(uint256 tokenId) internal view virtual { require(_exists(tokenId), "ERC721: invalid token ID"); } /** * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address. * The call is not executed if the target address is not a contract. * * @param from address representing the previous owner of the given token ID * @param to target address that will receive the tokens * @param tokenId uint256 ID of the token to be transferred * @param data bytes optional data to send along with the call * @return bool whether the call correctly returned the expected magic value */ function _checkOnERC721Received( address from, address to, uint256 tokenId, bytes memory data ) private returns (bool) { if (to.isContract()) { try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) { return retval == IERC721ReceiverUpgradeable.onERC721Received.selector; } catch (bytes memory reason) { if (reason.length == 0) { revert("ERC721: transfer to non ERC721Receiver implementer"); } else { /// @solidity memory-safe-assembly assembly { revert(add(32, reason), mload(reason)) } } } } else { return true; } } /** * @dev Hook that is called before any token transfer. This includes minting and burning. If {ERC721Consecutive} is * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1. * * Calling conditions: * * - When `from` and `to` are both non-zero, ``from``'s tokens will be transferred to `to`. * - When `from` is zero, the tokens will be minted for `to`. * - When `to` is zero, ``from``'s tokens will be burned. * - `from` and `to` are never both zero. * - `batchSize` is non-zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer( address from, address to, uint256 firstTokenId, uint256 batchSize ) internal virtual {} /** * @dev Hook that is called after any token transfer. This includes minting and burning. If {ERC721Consecutive} is * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1. * * Calling conditions: * * - When `from` and `to` are both non-zero, ``from``'s tokens were transferred to `to`. * - When `from` is zero, the tokens were minted for `to`. * - When `to` is zero, ``from``'s tokens were burned. * - `from` and `to` are never both zero. * - `batchSize` is non-zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _afterTokenTransfer( address from, address to, uint256 firstTokenId, uint256 batchSize ) internal virtual {} /** * @dev Unsafe write access to the balances, used by extensions that "mint" tokens using an {ownerOf} override. * * WARNING: Anyone calling this MUST ensure that the balances remain consistent with the ownership. The invariant * being that for any address `a` the value returned by `balanceOf(a)` must be equal to the number of tokens such * that `ownerOf(tokenId)` is `a`. */ // solhint-disable-next-line func-name-mixedcase function __unsafe_increaseBalance(address account, uint256 amount) internal { _balances[account] += amount; } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[44] private __gap; } // File: @openzeppelin/contracts-upgradeable/utils/CountersUpgradeable.sol // OpenZeppelin Contracts v4.4.1 (utils/Counters.sol) /** * @title Counters * @author Matt Condon (@shrugs) * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number * of elements in a mapping, issuing ERC721 ids, or counting request ids. * * Include with `using Counters for Counters.Counter;` */ library CountersUpgradeable { struct Counter { // This variable should never be directly accessed by users of the library: interactions must be restricted to // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add // this feature: see https://github.com/ethereum/solidity/issues/4637 uint256 _value; // default: 0 } function current(Counter storage counter) internal view returns (uint256) { return counter._value; } function increment(Counter storage counter) internal { unchecked { counter._value += 1; } } function decrement(Counter storage counter) internal { uint256 value = counter._value; require(value > 0, "Counter: decrement overflow"); unchecked { counter._value = value - 1; } } function reset(Counter storage counter) internal { counter._value = 0; } } // File: contracts/interfaces/INFTPayoutsUpgradeable.sol // Openzeppelin /** * @dev Interface for the Multiple NFT Payouts Standard. * * A standardized way to retrieve royalty payment information for non-fungible tokens (NFTs) to enable universal * support for royalty payments across all NFT marketplaces and ecosystem participants. */ interface INFTPayoutsUpgradeable is IERC165Upgradeable { function creator(uint256 tokenId) external view returns (address); function payoutCount( uint256 tokenId, bool isPayout ) external view returns (uint256); function payoutInfo( uint256 tokenId, uint256 salePrice, bool isPayout ) external view returns (address[] memory receivers, uint256[] memory payoutAmounts); } // File: contracts/utils/NFTPayoutsUpgradeable.sol // Openzeppelin // Interfaces /** * @dev Implementation of the NFT Royalty Standard plus Payout Info added, a standardized way to retrieve royalty payment and payout information. * * Royalty information can be specified globally for all token ids via {_setDefaultRoyalty}, and/or individually for * specific token ids via {_setTokenRoyalty}. The latter takes precedence over the first. * * Royalty is specified as a fraction of sale price. {_feeDenominator} is overridable but defaults to 10000, meaning the * fee is specified in basis points by default. * * IMPORTANT: ERC-2981 only specifies a way to signal royalty information and does not enforce its payment. See * https://eips.ethereum.org/EIPS/eip-2981#optional-royalty-payments[Rationale] in the EIP. Marketplaces are expected to * voluntarily pay royalties together with sales, but note that this standard is not yet widely supported. * */ abstract contract NFTPayoutsUpgradeable is Initializable, ERC165Upgradeable, INFTPayoutsUpgradeable { struct PayoutInfo { address receiver; uint96 payoutFraction; } struct PayoutTier { address creator; PayoutInfo[] primaryPayoutInfo; PayoutInfo[] secondaryPayoutInfo; } mapping(uint256 => address) private _tokenCreatorInfo; mapping(bool => mapping(uint256 => PayoutInfo[])) private _tokenPayoutInfo; mapping(bool => mapping(uint256 => uint256)) private _tokenPayoutCount; function __ERC2981Payout_init() internal onlyInitializing {} function __ERC2981Payout_init_unchained() internal onlyInitializing {} /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface( bytes4 interfaceId ) public view virtual override(IERC165Upgradeable, ERC165Upgradeable) returns (bool) { return interfaceId == type(INFTPayoutsUpgradeable).interfaceId || super.supportsInterface(interfaceId); } function creator( uint256 tokenId_ ) public view virtual override returns (address) { return _tokenCreatorInfo[tokenId_]; } /** * @inheritdoc INFTPayoutsUpgradeable */ function payoutCount( uint256 tokenId_, bool isPayout_ ) public view virtual override returns (uint256) { return _tokenPayoutCount[isPayout_][tokenId_]; } /** * @inheritdoc INFTPayoutsUpgradeable */ function payoutInfo( uint256 tokenId_, uint256 salePrice_, bool isPayout_ ) public view virtual override returns (address[] memory receivers, uint256[] memory payoutAmounts) { uint256 count = payoutCount(tokenId_, isPayout_); require(count != 0, "NFTPayouts: no payout"); receivers = new address[](count); payoutAmounts = new uint256[](count); for (uint256 i; i < count; ) { receivers[i] = _tokenPayoutInfo[isPayout_][tokenId_][i].receiver; payoutAmounts[i] = (salePrice_ * _tokenPayoutInfo[isPayout_][tokenId_][i].payoutFraction) / _feeDenominator(); unchecked { ++i; } } } /** * @dev The denominator with which to interpret the fee set in {_setTokenRoyalty} and {_setDefaultRoyalty} as a * fraction of the sale price. Defaults to 10000 so fees are expressed in basis points, but may be customized by an * override. */ function _feeDenominator() internal pure virtual returns (uint96) { return 10000; } /** * @dev Sets the payout information for a specific token id, overriding the global default. */ function _setCreator(uint256 tokenId_, address creator_) internal virtual { require(creator_ != address(0), "NFTPayouts: zero creator address"); _tokenCreatorInfo[tokenId_] = creator_; } /** * @dev Sets the payout information for a specific token id, overriding the global default. */ function _setTokenPayout( uint256 tokenId_, bool isPayout_, uint256 payoutCount_, PayoutInfo[] calldata payoutInfo_ ) internal virtual { _resetTokenPayout(tokenId_, isPayout_); uint256 payoutTotal; _tokenPayoutCount[isPayout_][tokenId_] = payoutCount_; for (uint256 i; i < payoutCount_; ) { require( payoutInfo_[i].receiver != address(0), "NFTPayouts: invalid receiver" ); payoutTotal = payoutTotal + payoutInfo_[i].payoutFraction; unchecked { ++i; } } if (isPayout_) { require( payoutTotal == _feeDenominator(), "ERC2981Payout: invalid payouts" ); } else { require( payoutTotal <= _feeDenominator(), "ERC2981Payout: invalid royalties" ); } for (uint256 i; i < payoutCount_; ) { _tokenPayoutInfo[isPayout_][tokenId_].push(payoutInfo_[i]); unchecked { ++i; } } } /** * @dev Resets payout information for the token id back to the global default. */ function _resetTokenPayout( uint256 tokenId_, bool isPayout_ ) internal virtual { delete _tokenPayoutCount[isPayout_][tokenId_]; delete _tokenPayoutInfo[isPayout_][tokenId_]; delete _tokenCreatorInfo[tokenId_]; } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[48] private __gap; } // File: contracts/interfaces/IOriginsNFT.sol // Utils /** * @title IOriginsNFT * @dev Interface for OriginsNFT contract * @author kazunetakeda25 */ interface IOriginsNFT { /** * @dev Mint NFT with ID `tokenId_` (called by Auction Manager) * @param to_ (address) Mint to address * @param tokenId_ (uint256) Token ID to mint */ function mint(address to_, uint256 tokenId_) external; } // File: contracts/OriginsNFT.sol // SPDX-License-Identifier: MIT // Openzeppelin // Utils // Interfaces // Errors error InvalidTokenID(); error NotAuctionManager(); error NotAllowedToMintNFTs(); error ZeroAddress(); /** * @title OriginsNFT * @dev Origins and Ancestry Series 1 Collection contract * @author kazunetakeda25 */ contract OriginsNFT is IOriginsNFT, Initializable, ERC721Upgradeable, NFTPayoutsUpgradeable, ReentrancyGuardUpgradeable, Ownable2StepUpgradeable, PausableUpgradeable { using CountersUpgradeable for CountersUpgradeable.Counter; using StringsUpgradeable for uint256; CountersUpgradeable.Counter private _tokenIdsCounter; address private _auctionManager; // Auction manager contract address mapping(address => bool) private _allowedToMint; // Allowed minter list string public baseURI; // Base URI of the collection // Events event AuctionManagerChanged( address indexed previousContract, address indexed newContract ); // Event emitted when auction manager changed event BaseURIChanged(string baseURI); // Event emitted when base URI changed event NFTMinted(address indexed to, uint256 tokenId); // Event emitted when NFT minted /** * @dev Modidier to check if minters are allowed */ modifier onlyAllowedMinters() { if (!_allowedToMint[msg.sender]) { revert NotAllowedToMintNFTs(); } _; } /** * @dev Modifier to check if caller is auction manager */ modifier onlyAuctionManager() { if (msg.sender != _auctionManager) { revert NotAuctionManager(); } _; } /** * @dev Initializer * @param name_ (string calldata) Collection name * @param symbol_ (string calldata) Collection symbol * @param baseURI_ (string calldata) Collection base URI */ function initialize( string calldata name_, string calldata symbol_, string calldata baseURI_ ) public initializer { __Ownable2Step_init(); __ERC721_init(name_, symbol_); _setBaseURI(baseURI_); // Starts from 1 _tokenIdsCounter.increment(); } /** * @dev Pause the contract */ function pause() external onlyOwner { _pause(); } /** * @dev Unpause the contract */ function unpause() external onlyOwner { _unpause(); } /** * @dev Set Auction Manager contract address * @param auctionManager_ (address) Auction Manager contract address */ function setAuctionManager(address auctionManager_) external onlyOwner { if (auctionManager_ == address(0)) { revert ZeroAddress(); } address prev = _auctionManager; _auctionManager = auctionManager_; emit AuctionManagerChanged(prev, auctionManager_); } /** * @dev Set the base URI * @param baseURI_ (string calldata) base URI */ function setBaseURI(string calldata baseURI_) external onlyOwner { _setBaseURI(baseURI_); } /** * @dev Mints `tokenId_` and transfers it to `to_`. * @param to_ (address) Mint to address * @param tokenId_ (uint256) Token ID to mint * @param payoutInfo_ {PayoutTier calldata} Payout info */ function mint( address to_, uint256 tokenId_, PayoutTier calldata payoutInfo_ ) external nonReentrant onlyAllowedMinters whenNotPaused { uint256 newTokenId = tokenId_; if (newTokenId == 0) { newTokenId = _tokenIdsCounter.current(); while (_exists(newTokenId)) { newTokenId = _tokenIdsCounter.current(); _tokenIdsCounter.increment(); } } _safeMint(to_, newTokenId); uint256 primaryPayoutCount = payoutInfo_.primaryPayoutInfo.length; if (primaryPayoutCount > 0) { _setTokenPayout( newTokenId, true, primaryPayoutCount, payoutInfo_.primaryPayoutInfo ); } uint256 secondaryPayoutCount = payoutInfo_.secondaryPayoutInfo.length; if (secondaryPayoutCount > 0) { _setTokenPayout( newTokenId, false, secondaryPayoutCount, payoutInfo_.secondaryPayoutInfo ); } _setCreator(newTokenId, payoutInfo_.creator); emit NFTMinted(to_, newTokenId); } /** * @dev Mint NFT with ID `tokenId_` (called by Auction Manager) * @param to_ (address) Mint to address * @param tokenId_ (uint256) Token ID to mint */ function mint( address to_, uint256 tokenId_ ) external nonReentrant onlyAuctionManager whenNotPaused { _safeMint(to_, tokenId_); _tokenIdsCounter.increment(); emit NFTMinted(to_, tokenId_); } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface( bytes4 interfaceId_ ) public view virtual override(ERC721Upgradeable, NFTPayoutsUpgradeable) returns (bool) { return interfaceId_ == type(NFTPayoutsUpgradeable).interfaceId || super.supportsInterface(interfaceId_); } /** * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token. * @param tokenId_ (uint256) Token ID * @return (string memory) URI of the token */ function tokenURI( uint256 tokenId_ ) public view override returns (string memory) { if (!_exists(tokenId_)) { revert InvalidTokenID(); } return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId_.toString())) : ""; } /** * @dev See {ERC721-_beforeTokenTransfer}. */ function _beforeTokenTransfer( address from, address to, uint256 firstTokenId, uint256 batchSize ) internal virtual override(ERC721Upgradeable) { super._beforeTokenTransfer(from, to, firstTokenId, batchSize); } /** * @dev Destroys `tokenId`. * The approval is cleared when the token is burned. * This is an internal function that does not check if the sender is authorized to operate on the token. * Emits a {Transfer} event. * @param tokenId_ (uint256) Token ID to burn */ function _burn(uint256 tokenId_) internal override(ERC721Upgradeable) { super._burn(tokenId_); } /** * @dev Set the base URI * @param baseURI_ (string calldata) base URI */ function _setBaseURI(string calldata baseURI_) private { baseURI = baseURI_; emit BaseURIChanged(baseURI_); } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[],"name":"InvalidTokenID","type":"error"},{"inputs":[],"name":"NotAllowedToMintNFTs","type":"error"},{"inputs":[],"name":"NotAuctionManager","type":"error"},{"inputs":[],"name":"ZeroAddress","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousContract","type":"address"},{"indexed":true,"internalType":"address","name":"newContract","type":"address"}],"name":"AuctionManagerChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"baseURI","type":"string"}],"name":"BaseURIChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"version","type":"uint8"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"NFTMinted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferStarted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"acceptOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId_","type":"uint256"}],"name":"creator","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":"string","name":"name_","type":"string"},{"internalType":"string","name":"symbol_","type":"string"},{"internalType":"string","name":"baseURI_","type":"string"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to_","type":"address"},{"internalType":"uint256","name":"tokenId_","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to_","type":"address"},{"internalType":"uint256","name":"tokenId_","type":"uint256"},{"components":[{"internalType":"address","name":"creator","type":"address"},{"components":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint96","name":"payoutFraction","type":"uint96"}],"internalType":"struct NFTPayoutsUpgradeable.PayoutInfo[]","name":"primaryPayoutInfo","type":"tuple[]"},{"components":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint96","name":"payoutFraction","type":"uint96"}],"internalType":"struct NFTPayoutsUpgradeable.PayoutInfo[]","name":"secondaryPayoutInfo","type":"tuple[]"}],"internalType":"struct NFTPayoutsUpgradeable.PayoutTier","name":"payoutInfo_","type":"tuple"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId_","type":"uint256"},{"internalType":"bool","name":"isPayout_","type":"bool"}],"name":"payoutCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId_","type":"uint256"},{"internalType":"uint256","name":"salePrice_","type":"uint256"},{"internalType":"bool","name":"isPayout_","type":"bool"}],"name":"payoutInfo","outputs":[{"internalType":"address[]","name":"receivers","type":"address[]"},{"internalType":"uint256[]","name":"payoutAmounts","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"auctionManager_","type":"address"}],"name":"setAuctionManager","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseURI_","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":[{"internalType":"uint256","name":"tokenId_","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Deployed Bytecode Sourcemap
80650:6723:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;85491:348;;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;85491:348:0;;;;;;;;55919:100;;;:::i;:::-;;;;;;;:::i;57426:169::-;;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1697:32:1;;;1679:51;;1667:2;1652:18;57426:169:0;1533:203:1;56939:423:0;;;;;;:::i;:::-;;:::i;:::-;;58118:333;;;;;;:::i;:::-;;:::i;82770:67::-;;;:::i;85174:247::-;;;;;;:::i;:::-;;:::i;58520:185::-;;;;;;:::i;:::-;;:::i;83749:1236::-;;;;;;:::i;:::-;;:::i;75866:151::-;;;;;;:::i;:::-;75955:7;75982:27;;;:17;:27;;;;;;-1:-1:-1;;;;;75982:27:0;;75866:151;83406:105;;;;;;:::i;:::-;;:::i;24077:86::-;24148:7;;;;24077:86;;55631:223;;;;;;:::i;:::-;;:::i;76084:191::-;;;;;;:::i;:::-;76229:28;;76202:7;76229:28;;;:17;:28;;;;;;;;:38;;;;;;;;;76084:191;;;;4588:25:1;;;4576:2;4561:18;76084:191:0;4442:177:1;81176:21:0;;;:::i;55364:207::-;;;;;;:::i;:::-;;:::i;18626:103::-;;;:::i;21726:210::-;;;:::i;82649:63::-;;;:::i;17982:87::-;18055:6;;-1:-1:-1;;;;;18055:6:0;17982:87;;56086:104;;;:::i;82985:316::-;;;;;;:::i;:::-;;:::i;57665:155::-;;;;;;:::i;:::-;;:::i;82269:324::-;;;;;;:::i;:::-;;:::i;76342:839::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;58774:322::-;;;;;;:::i;:::-;;:::i;86035:341::-;;;;;;:::i;:::-;;:::i;20820:101::-;20900:13;;-1:-1:-1;;;;;20900:13:0;20820:101;;57889:164;;;;;;:::i;:::-;-1:-1:-1;;;;;58010:25:0;;;57986:4;58010:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;57889:164;21118:181;;;;;;:::i;:::-;;:::i;85491:348::-;85680:4;-1:-1:-1;;;;;;85722:55:0;;-1:-1:-1;;;85722:55:0;;:109;;;85794:37;85818:12;85794:23;:37::i;:::-;85702:129;85491:348;-1:-1:-1;;85491:348:0:o;55919:100::-;55973:13;56006:5;55999:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55919:100;:::o;57426:169::-;57502:7;57522:23;57537:7;57522:14;:23::i;:::-;-1:-1:-1;57563:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;57563:24:0;;57426:169::o;56939:423::-;57020:13;57036:34;57062:7;57036:25;:34::i;:::-;57020:50;;57095:5;-1:-1:-1;;;;;57089:11:0;:2;-1:-1:-1;;;;;57089:11:0;;57081:57;;;;-1:-1:-1;;;57081:57:0;;10098:2:1;57081:57:0;;;10080:21:1;10137:2;10117:18;;;10110:30;10176:34;10156:18;;;10149:62;-1:-1:-1;;;10227:18:1;;;10220:31;10268:19;;57081:57:0;;;;;;;;;16153:10;-1:-1:-1;;;;;57171:21:0;;;;:62;;-1:-1:-1;57196:37:0;57213:5;16153:10;57889:164;:::i;57196:37::-;57149:173;;;;-1:-1:-1;;;57149:173:0;;10500:2:1;57149:173:0;;;10482:21:1;10539:2;10519:18;;;10512:30;10578:34;10558:18;;;10551:62;10649:31;10629:18;;;10622:59;10698:19;;57149:173:0;10298:425:1;57149:173:0;57333:21;57342:2;57346:7;57333:8;:21::i;:::-;57009:353;56939:423;;:::o;58118:333::-;58313:41;16153:10;58346:7;58313:18;:41::i;:::-;58305:99;;;;-1:-1:-1;;;58305:99:0;;;;;;;:::i;:::-;58415:28;58425:4;58431:2;58435:7;58415:9;:28::i;82770:67::-;17870:13;:11;:13::i;:::-;82819:10:::1;:8;:10::i;:::-;82770:67::o:0;85174:247::-;27875:21;:19;:21::i;:::-;81955:15:::1;::::0;-1:-1:-1;;;;;81955:15:0::1;81941:10;:29;81937:88;;81994:19;;-1:-1:-1::0;;;81994:19:0::1;;;;;;;;;;;81937:88;23686:19:::2;:17;:19::i;:::-;85310:24:::3;85320:3;85325:8;85310:9;:24::i;:::-;85345:28;:16;72561:19:::0;;72579:1;72561:19;;;72472:127;85345:28:::3;85399:3;-1:-1:-1::0;;;;;85389:24:0::3;;85404:8;85389:24;;;;4588:25:1::0;;4576:2;4561:18;;4442:177;85389:24:0::3;;;;;;;;27919:20:::0;27144:1;28433:7;:22;28250:213;27919:20;85174:247;;:::o;58520:185::-;58658:39;58675:4;58681:2;58685:7;58658:39;;;;;;;;;;;;:16;:39::i;83749:1236::-;27875:21;:19;:21::i;:::-;81724:10:::1;81709:26;::::0;;;:14:::1;:26;::::0;;;;;::::1;;81704:89;;81759:22;;-1:-1:-1::0;;;81759:22:0::1;;;;;;;;;;;81704:89;23686:19:::2;:17;:19::i;:::-;83948:8:::0;83927:18:::3;83971:15:::0;;;83967:250:::3;;-1:-1:-1::0;84016:16:0::3;72444:14:::0;84057:149:::3;60893:4:::0;60493:16;;;:7;:16;;;;;;-1:-1:-1;;;;;60493:16:0;60917:31;84057:149:::3;;-1:-1:-1::0;84117:16:0::3;72444:14:::0;;72579:1;72561:19;;;;;84057:149:::3;;;84227:26;84237:3;84242:10;84227:9;:26::i;:::-;84264;84293:29;;::::0;::::3;:11:::0;:29:::3;:::i;:::-;:36:::0;-1:-1:-1;;84344:22:0;;84340:222:::3;;84383:167;84417:10:::0;84446:4:::3;84469:18:::0;84506:29:::3;;::::0;::::3;:11:::0;:29:::3;:::i;:::-;84383:15;:167::i;:::-;84572:28;84603:31;;::::0;::::3;:11:::0;:31:::3;:::i;:::-;:38:::0;-1:-1:-1;;84656:24:0;;84652:229:::3;;84697:172;84731:10:::0;84760:5:::3;84784:20:::0;84823:31:::3;;::::0;::::3;:11:::0;:31:::3;:::i;84697:172::-;84891:44;84903:10:::0;84915:19:::3;;::::0;::::3;:11:::0;:19:::3;:::i;:::-;84891:11;:44::i;:::-;84961:3;-1:-1:-1::0;;;;;84951:26:0::3;;84966:10;84951:26;;;;4588:25:1::0;;4576:2;4561:18;;4442:177;84951:26:0::3;;;;;;;;83916:1069;;;27919:20:::0;27144:1;28433:7;:22;28250:213;83406:105;17870:13;:11;:13::i;:::-;83482:21:::1;83494:8;;83482:11;:21::i;55631:223::-:0;55703:7;60493:16;;;:7;:16;;;;;;-1:-1:-1;;;;;60493:16:0;;55767:56;;;;-1:-1:-1;;;55767:56:0;;11924:2:1;55767:56:0;;;11906:21:1;11963:2;11943:18;;;11936:30;-1:-1:-1;;;11982:18:1;;;11975:54;12046:18;;55767:56:0;11722:348:1;81176:21:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;55364:207::-;55436:7;-1:-1:-1;;;;;55464:19:0;;55456:73;;;;-1:-1:-1;;;55456:73:0;;12277:2:1;55456:73:0;;;12259:21:1;12316:2;12296:18;;;12289:30;12355:34;12335:18;;;12328:62;-1:-1:-1;;;12406:18:1;;;12399:39;12455:19;;55456:73:0;12075:405:1;55456:73:0;-1:-1:-1;;;;;;55547:16:0;;;;;:9;:16;;;;;;;55364:207::o;18626:103::-;17870:13;:11;:13::i;:::-;18691:30:::1;18718:1;18691:18;:30::i;21726:210::-:0;20900:13;;16153:10;;-1:-1:-1;;;;;20900:13:0;21821:24;;21813:78;;;;-1:-1:-1;;;21813:78:0;;12687:2:1;21813:78:0;;;12669:21:1;12726:2;12706:18;;;12699:30;12765:34;12745:18;;;12738:62;-1:-1:-1;;;12816:18:1;;;12809:39;12865:19;;21813:78:0;12485:405:1;21813:78:0;21902:26;21921:6;21902:18;:26::i;:::-;21762:174;21726:210::o;82649:63::-;17870:13;:11;:13::i;:::-;82696:8:::1;:6;:8::i;56086:104::-:0;56142:13;56175:7;56168:14;;;;;:::i;82985:316::-;17870:13;:11;:13::i;:::-;-1:-1:-1;;;;;83071:29:0;::::1;83067:82;;83124:13;;-1:-1:-1::0;;;83124:13:0::1;;;;;;;;;;;83067:82;83174:15;::::0;;-1:-1:-1;;;;;83200:33:0;;::::1;-1:-1:-1::0;;;;;;83200:33:0;::::1;::::0;::::1;::::0;;;83249:44:::1;::::0;83174:15;::::1;::::0;83200:33;83174:15;;83249:44:::1;::::0;83159:12:::1;::::0;83249:44:::1;83056:245;82985:316:::0;:::o;57665:155::-;57760:52;16153:10;57793:8;57803;57760:18;:52::i;82269:324::-;11801:19;11824:13;;;;;;11823:14;;11871:34;;;;-1:-1:-1;11889:12:0;;11904:1;11889:12;;;;:16;11871:34;11870:108;;;-1:-1:-1;11950:4:0;1527:19;:23;;;11911:66;;-1:-1:-1;11960:12:0;;;;;:17;11911:66;11848:204;;;;-1:-1:-1;;;11848:204:0;;13097:2:1;11848:204:0;;;13079:21:1;13136:2;13116:18;;;13109:30;13175:34;13155:18;;;13148:62;-1:-1:-1;;;13226:18:1;;;13219:44;13280:19;;11848:204:0;12895:410:1;11848:204:0;12063:12;:16;;-1:-1:-1;;12063:16:0;12078:1;12063:16;;;12090:67;;;;12125:13;:20;;-1:-1:-1;;12125:20:0;;;;;12090:67;82427:21:::1;:19;:21::i;:::-;82459:29;82473:5;;82459:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;;82459:29:0::1;::::0;;::::1;;::::0;::::1;::::0;;::::1;::::0;::::1;::::0;;;;;;;;;;;-1:-1:-1;82480:7:0;;-1:-1:-1;82480:7:0;;;;82459:29;::::1;82480:7:::0;;;;82459:29;::::1;;::::0;::::1;::::0;;;;-1:-1:-1;82459:13:0::1;::::0;-1:-1:-1;;;82459:29:0:i:1;:::-;82499:21;82511:8;;82499:11;:21::i;:::-;82557:28;:16;72561:19:::0;;72579:1;72561:19;;;72472:127;82557:28:::1;12183:14:::0;12179:102;;;12230:5;12214:21;;-1:-1:-1;;12214:21:0;;;12255:14;;-1:-1:-1;13462:36:1;;12255:14:0;;13450:2:1;13435:18;12255:14:0;;;;;;;12179:102;11790:498;82269:324;;;;;;:::o;76342:839::-;76533:26;76561:30;76609:13;76625:32;76637:8;76647:9;76229:28;;76202:7;76229:28;;;:17;:28;;;;;;;;:38;;;;;;;;;76084:191;76625:32;76609:48;;76676:5;76685:1;76676:10;76668:44;;;;-1:-1:-1;;;76668:44:0;;13711:2:1;76668:44:0;;;13693:21:1;13750:2;13730:18;;;13723:30;-1:-1:-1;;;13769:18:1;;;13762:51;13830:18;;76668:44:0;13509:345:1;76668:44:0;76749:5;76735:20;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;76735:20:0;;76723:32;;76796:5;76782:20;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;76782:20:0;;76766:36;;76818:9;76813:361;76833:5;76829:1;:9;76813:361;;;76872:27;;;;;;;:16;:27;;;;;;;;:37;;;;;;;;:40;;76910:1;;76872:40;;;;;;:::i;:::-;;;;;;;;;;:49;76857:12;;-1:-1:-1;;;;;76872:49:0;;;;76857:9;;76867:1;;76857:12;;;;;;:::i;:::-;-1:-1:-1;;;;;76857:64:0;;;;:12;;;;;;;;;;:64;77007:27;;;;;;;:16;:27;;;;;;:37;;;;;;;:40;;77545:5;;77007:37;77045:1;;77007:40;;;;;;:::i;:::-;;;;;;;;;;:55;76973:89;;-1:-1:-1;;;77007:55:0;;-1:-1:-1;;;;;77007:55:0;76973:10;:89;:::i;:::-;76972:128;;;;:::i;:::-;76936:13;76950:1;76936:16;;;;;;;;:::i;:::-;;;;;;;;;;:164;77144:3;;76813:361;;;;76598:583;76342:839;;;;;;:::o;58774:322::-;58948:41;16153:10;58981:7;58948:18;:41::i;:::-;58940:99;;;;-1:-1:-1;;;58940:99:0;;;;;;;:::i;:::-;59050:38;59064:4;59070:2;59074:7;59083:4;59050:13;:38::i;:::-;58774:322;;;;:::o;86035:341::-;60893:4;60493:16;;;:7;:16;;;;;;86117:13;;-1:-1:-1;;;;;60493:16:0;86143:74;;86189:16;;-1:-1:-1;;;86189:16:0;;;;;;;;;;;86143:74;86271:1;86253:7;86247:21;;;;;:::i;:::-;;;:25;:121;;;;;;;;;;;;;;;;;86316:7;86325:19;:8;:17;:19::i;:::-;86299:46;;;;;;;;;:::i;:::-;;;;;;;;;;;;;86227:141;86035:341;-1:-1:-1;;86035:341:0:o;21118:181::-;17870:13;:11;:13::i;:::-;21208::::1;:24:::0;;-1:-1:-1;;;;;21208:24:0;::::1;-1:-1:-1::0;;;;;;21208:24:0;;::::1;::::0;::::1;::::0;;;21273:7:::1;18055:6:::0;;-1:-1:-1;;;;;18055:6:0;;17982:87;21273:7:::1;-1:-1:-1::0;;;;;21248:43:0::1;;;;;;;;;;;21118:181:::0;:::o;75517:343::-;75702:4;-1:-1:-1;;;;;;75744:55:0;;-1:-1:-1;;;75744:55:0;;:108;;;75816:36;75840:11;75816:23;:36::i;67237:135::-;60893:4;60493:16;;;:7;:16;;;;;;-1:-1:-1;;;;;60493:16:0;67311:53;;;;-1:-1:-1;;;67311:53:0;;11924:2:1;67311:53:0;;;11906:21:1;11963:2;11943:18;;;11936:30;-1:-1:-1;;;11982:18:1;;;11975:54;12046:18;;67311:53:0;11722:348:1;66509:185:0;66584:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;66584:29:0;-1:-1:-1;;;;;66584:29:0;;;;;;;;:24;;66638:34;66584:24;66638:25;:34::i;:::-;-1:-1:-1;;;;;66629:57:0;;;;;;;;;;;66509:185;;:::o;61121:275::-;61214:4;61231:13;61247:34;61273:7;61247:25;:34::i;:::-;61231:50;;61311:5;-1:-1:-1;;;;;61300:16:0;:7;-1:-1:-1;;;;;61300:16:0;;:52;;;-1:-1:-1;;;;;;58010:25:0;;;57986:4;58010:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;61320:32;61300:87;;;;61380:7;-1:-1:-1;;;;;61356:31:0;:20;61368:7;61356:11;:20::i;:::-;-1:-1:-1;;;;;61356:31:0;;61300:87;61292:96;61121:275;-1:-1:-1;;;;61121:275:0:o;65119:1273::-;65289:4;-1:-1:-1;;;;;65251:42:0;:34;65277:7;65251:25;:34::i;:::-;-1:-1:-1;;;;;65251:42:0;;65243:92;;;;-1:-1:-1;;;65243:92:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;65354:16:0;;65346:65;;;;-1:-1:-1;;;65346:65:0;;16409:2:1;65346:65:0;;;16391:21:1;16448:2;16428:18;;;16421:30;16487:34;16467:18;;;16460:62;-1:-1:-1;;;16538:18:1;;;16531:34;16582:19;;65346:65:0;16207:400:1;65346:65:0;65422:42;65443:4;65449:2;65453:7;65462:1;65422:20;:42::i;:::-;65603:4;-1:-1:-1;;;;;65565:42:0;:34;65591:7;65565:25;:34::i;:::-;-1:-1:-1;;;;;65565:42:0;;65557:92;;;;-1:-1:-1;;;65557:92:0;;;;;;;:::i;:::-;65719:24;;;;:15;:24;;;;;;;;65712:31;;-1:-1:-1;;;;;;65712:31:0;;;;;;-1:-1:-1;;;;;66193:15:0;;;;;;:9;:15;;;;;:20;;-1:-1:-1;;66193:20:0;;;66228:13;;;;;;;;;:18;;65712:31;66228:18;;;66268:16;;;:7;:16;;;;;;:21;;;;;;;;;;66305:27;;65735:7;;66305:27;;;57009:353;56939:423;;:::o;18145:132::-;18055:6;;-1:-1:-1;;;;;18055:6:0;16153:10;18209:23;18201:68;;;;-1:-1:-1;;;18201:68:0;;16814:2:1;18201:68:0;;;16796:21:1;;;16833:18;;;16826:30;16892:34;16872:18;;;16865:62;16944:18;;18201:68:0;16612:356:1;24924:120:0;23943:16;:14;:16::i;:::-;24983:7:::1;:15:::0;;-1:-1:-1;;24983:15:0::1;::::0;;25014:22:::1;16153:10:::0;25023:12:::1;25014:22;::::0;-1:-1:-1;;;;;1697:32:1;;;1679:51;;1667:2;1652:18;25014:22:0::1;;;;;;;24924:120::o:0;27953:291::-;27188:1;28087:7;;:19;28079:63;;;;-1:-1:-1;;;28079:63:0;;17175:2:1;28079:63:0;;;17157:21:1;17214:2;17194:18;;;17187:30;17253:33;17233:18;;;17226:61;17304:18;;28079:63:0;16973:355:1;28079:63:0;27188:1;28218:7;:18;27953:291::o;24234:108::-;24148:7;;;;24304:9;24296:38;;;;-1:-1:-1;;;24296:38:0;;17535:2:1;24296:38:0;;;17517:21:1;17574:2;17554:18;;;17547:30;-1:-1:-1;;;17593:18:1;;;17586:46;17649:18;;24296:38:0;17333:340:1;61736:110:0;61812:26;61822:2;61826:7;61812:26;;;;;;;;;;;;:9;:26::i;78009:1189::-;78196:38;78214:8;78224:9;78196:17;:38::i;:::-;78275:28;;;78245:19;78275:28;;;:17;:28;;;;;;;;:38;;;;;;;;:53;;;78245:19;78339:324;78359:12;78355:1;:16;78339:324;;;78451:1;78416:11;;78428:1;78416:14;;;;;;;:::i;:::-;:23;;;:14;;;;;:23;;;;-1:-1:-1;78416:23:0;:::i;:::-;-1:-1:-1;;;;;78416:37:0;;78390:127;;;;-1:-1:-1;;;78390:127:0;;17880:2:1;78390:127:0;;;17862:21:1;17919:2;17899:18;;;17892:30;17958;17938:18;;;17931:58;18006:18;;78390:127:0;17678:352:1;78390:127:0;78560:11;;78572:1;78560:14;;;;;;;:::i;:::-;;;;;;:29;;;;;;;;;;:::i;:::-;78546:43;;-1:-1:-1;;;;;78546:43:0;:11;:43;:::i;:::-;78532:57;-1:-1:-1;78633:3:0;;78339:324;;;;78677:9;78673:325;;;77545:5;78729:32;;78703:124;;;;-1:-1:-1;;;78703:124:0;;18759:2:1;78703:124:0;;;18741:21:1;18798:2;18778:18;;;18771:30;18837:32;18817:18;;;18810:60;18887:18;;78703:124:0;18557:354:1;78703:124:0;78673:325;;;77545:5;78886:32;;;78860:126;;;;-1:-1:-1;;;78860:126:0;;19118:2:1;78860:126:0;;;19100:21:1;;;19137:18;;;19130:30;19196:34;19176:18;;;19169:62;19248:18;;78860:126:0;18916:356:1;78860:126:0;79013:9;79008:183;79028:12;79024:1;:16;79008:183;;;79059:27;;;;;;;:16;:27;;;;;;;;:37;;;;;;;;79102:11;;79114:1;79102:14;;;;;;;:::i;:::-;79059:58;;;;;;;-1:-1:-1;79059:58:0;;;;;;;79102:14;;;;;;;;;79059:58;;;;;-1:-1:-1;79059:58:0;79102:14;79059:58;;:::i;:::-;-1:-1:-1;;79161:3:0;;79008:183;;77679:209;-1:-1:-1;;;;;77772:22:0;;77764:67;;;;-1:-1:-1;;;77764:67:0;;20017:2:1;77764:67:0;;;19999:21:1;;;20036:18;;;20029:30;20095:34;20075:18;;;20068:62;20147:18;;77764:67:0;19815:356:1;77764:67:0;77842:27;;;;:17;:27;;;;;;:38;;-1:-1:-1;;;;;;77842:38:0;-1:-1:-1;;;;;77842:38:0;;;;;;;;;77679:209::o;87238:132::-;87304:7;:18;87314:8;;87304:7;:18;:::i;:::-;;87338:24;87353:8;;87338:24;;;;;;;:::i;:::-;;;;;;;;87238:132;;:::o;21487:156::-;21577:13;21570:20;;-1:-1:-1;;;;;;21570:20:0;;;21601:34;21626:8;21601:24;:34::i;24667:118::-;23686:19;:17;:19::i;:::-;24727:7:::1;:14:::0;;-1:-1:-1;;24727:14:0::1;24737:4;24727:14;::::0;;24757:20:::1;24764:12;16153:10:::0;;16073:98;66835:315;66990:8;-1:-1:-1;;;;;66981:17:0;:5;-1:-1:-1;;;;;66981:17:0;;66973:55;;;;-1:-1:-1;;;66973:55:0;;22705:2:1;66973:55:0;;;22687:21:1;22744:2;22724:18;;;22717:30;22783:27;22763:18;;;22756:55;22828:18;;66973:55:0;22503:349:1;66973:55:0;-1:-1:-1;;;;;67039:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;67039:46:0;;;;;;;;;;67101:41;;540::1;;;67101::0;;513:18:1;67101:41:0;;;;;;;66835:315;;;:::o;20428:102::-;13940:13;;;;;;;13932:69;;;;-1:-1:-1;;;13932:69:0;;;;;;;:::i;:::-;20496:26:::1;:24;:26::i;54563:151::-:0;13940:13;;;;;;;13932:69;;;;-1:-1:-1;;;13932:69:0;;;;;;;:::i;:::-;54667:39:::1;54691:5;54698:7;54667:23;:39::i;59975:313::-:0;60131:28;60141:4;60147:2;60151:7;60131:9;:28::i;:::-;60178:47;60201:4;60207:2;60211:7;60220:4;60178:22;:47::i;:::-;60170:110;;;;-1:-1:-1;;;60170:110:0;;;;;;;:::i;49883:727::-;49939:13;49990:14;50007:28;50029:5;50007:21;:28::i;:::-;50038:1;50007:32;49990:49;;50054:20;50088:6;50077:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;50077:18:0;-1:-1:-1;50054:41:0;-1:-1:-1;50219:28:0;;;50235:2;50219:28;50276:288;-1:-1:-1;;50308:5:0;-1:-1:-1;;;50445:2:0;50434:14;;50429:30;50308:5;50416:44;50506:2;50497:11;;;-1:-1:-1;50527:21:0;50276:288;50527:21;-1:-1:-1;50585:6:0;49883:727;-1:-1:-1;;;49883:727:0:o;54953:349::-;55077:4;-1:-1:-1;;;;;;55114:51:0;;-1:-1:-1;;;55114:51:0;;:127;;-1:-1:-1;;;;;;;55182:59:0;;-1:-1:-1;;;55182:59:0;55114:127;:180;;;-1:-1:-1;;;;;;;;;;52930:51:0;;;55258:36;52821:168;86448:265;86644:61;58774:322;24417:108;24148:7;;;;24476:41;;;;-1:-1:-1;;;24476:41:0;;23890:2:1;24476:41:0;;;23872:21:1;23929:2;23909:18;;;23902:30;-1:-1:-1;;;23948:18:1;;;23941:50;24008:18;;24476:41:0;23688:344:1;62071:319:0;62200:18;62206:2;62210:7;62200:5;:18::i;:::-;62251:53;62282:1;62286:2;62290:7;62299:4;62251:22;:53::i;:::-;62229:153;;;;-1:-1:-1;;;62229:153:0;;;;;;;:::i;79306:267::-;79427:28;;;;;;;:17;:28;;;;;;;;:38;;;;;;;;79420:45;;;79483:27;;;:16;:27;;;;;:37;;;;;;;;79476:44;;;:::i;:::-;-1:-1:-1;79538:27:0;;;;:17;:27;;;;;79531:34;;-1:-1:-1;;;;;;79531:34:0;;;79306:267::o;19241:191::-;19334:6;;;-1:-1:-1;;;;;19351:17:0;;;-1:-1:-1;;;;;;19351:17:0;;;;;;;19384:40;;19334:6;;;19351:17;19334:6;;19384:40;;19315:16;;19384:40;19304:128;19241:191;:::o;17634:113::-;13940:13;;;;;;;13932:69;;;;-1:-1:-1;;;13932:69:0;;;;;;;:::i;:::-;17707:32:::1;16153:10:::0;17707:18:::1;:32::i;54720:163::-:0;13940:13;;;;;;;13932:69;;;;-1:-1:-1;;;13932:69:0;;;;;;;:::i;:::-;54834:5:::1;:13;54842:5:::0;54834;:13:::1;:::i;:::-;-1:-1:-1::0;54858:7:0::1;:17;54868:7:::0;54858;:17:::1;:::i;67934:875::-:0;68088:4;-1:-1:-1;;;;;68109:13:0;;1527:19;:23;68105:697;;68145:82;;-1:-1:-1;;;68145:82:0;;-1:-1:-1;;;;;68145:47:0;;;;;:82;;16153:10;;68207:4;;68213:7;;68222:4;;68145:82;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;68145:82:0;;;;;;;;-1:-1:-1;;68145:82:0;;;;;;;;;;;;:::i;:::-;;;68141:606;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;68408:6;:13;68425:1;68408:18;68404:328;;68451:60;;-1:-1:-1;;;68451:60:0;;;;;;;:::i;68404:328::-;68682:6;68676:13;68667:6;68663:2;68659:15;68652:38;68141:606;-1:-1:-1;;;;;;68278:62:0;-1:-1:-1;;;68278:62:0;;-1:-1:-1;68271:69:0;;68105:697;-1:-1:-1;68786:4:0;67934:875;;;;;;:::o;46760:922::-;46813:7;;-1:-1:-1;;;46891:15:0;;46887:102;;-1:-1:-1;;;46927:15:0;;;-1:-1:-1;46971:2:0;46961:12;46887:102;47016:6;47007:5;:15;47003:102;;47052:6;47043:15;;;-1:-1:-1;47087:2:0;47077:12;47003:102;47132:6;47123:5;:15;47119:102;;47168:6;47159:15;;;-1:-1:-1;47203:2:0;47193:12;47119:102;47248:5;47239;:14;47235:99;;47283:5;47274:14;;;-1:-1:-1;47317:1:0;47307:11;47235:99;47361:5;47352;:14;47348:99;;47396:5;47387:14;;;-1:-1:-1;47430:1:0;47420:11;47348:99;47474:5;47465;:14;47461:99;;47509:5;47500:14;;;-1:-1:-1;47543:1:0;47533:11;47461:99;47587:5;47578;:14;47574:66;;47623:1;47613:11;47668:6;46760:922;-1:-1:-1;;46760:922:0:o;62724:930::-;-1:-1:-1;;;;;62804:16:0;;62796:61;;;;-1:-1:-1;;;62796:61:0;;26344:2:1;62796:61:0;;;26326:21:1;;;26363:18;;;26356:30;26422:34;26402:18;;;26395:62;26474:18;;62796:61:0;26142:356:1;62796:61:0;60893:4;60493:16;;;:7;:16;;;;;;-1:-1:-1;;;;;60493:16:0;60917:31;62868:58;;;;-1:-1:-1;;;62868:58:0;;26705:2:1;62868:58:0;;;26687:21:1;26744:2;26724:18;;;26717:30;26783;26763:18;;;26756:58;26831:18;;62868:58:0;26503:352:1;62868:58:0;62937:48;62966:1;62970:2;62974:7;62983:1;62937:20;:48::i;:::-;60893:4;60493:16;;;:7;:16;;;;;;-1:-1:-1;;;;;60493:16:0;60917:31;63073:58;;;;-1:-1:-1;;;63073:58:0;;26705:2:1;63073:58:0;;;26687:21:1;26744:2;26724:18;;;26717:30;26783;26763:18;;;26756:58;26831:18;;63073:58:0;26503:352:1;63073:58:0;-1:-1:-1;;;;;63478:13:0;;;;;;:9;:13;;;;;;;;:18;;63495:1;63478:18;;;63518:16;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;63518:21:0;;;;;63555:33;63526:7;;63478:13;;63555:33;;63478:13;;63555:33;85174:247;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;14:131:1:-;-1:-1:-1;;;;;;88:32:1;;78:43;;68:71;;135:1;132;125:12;150:245;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;:::-;384:5;150:245;-1:-1:-1;;;150:245:1:o;592:250::-;677:1;687:113;701:6;698:1;695:13;687:113;;;777:11;;;771:18;758:11;;;751:39;723:2;716:10;687:113;;;-1:-1:-1;;834:1:1;816:16;;809:27;592:250::o;847:271::-;889:3;927:5;921:12;954:6;949:3;942:19;970:76;1039:6;1032:4;1027:3;1023:14;1016:4;1009:5;1005:16;970:76;:::i;:::-;1100:2;1079:15;-1:-1:-1;;1075:29:1;1066:39;;;;1107:4;1062:50;;847:271;-1:-1:-1;;847:271:1:o;1123:220::-;1272:2;1261:9;1254:21;1235:4;1292:45;1333:2;1322:9;1318:18;1310:6;1292:45;:::i;1348:180::-;1407:6;1460:2;1448:9;1439:7;1435:23;1431:32;1428:52;;;1476:1;1473;1466:12;1428:52;-1:-1:-1;1499:23:1;;1348:180;-1:-1:-1;1348:180:1:o;1741:131::-;-1:-1:-1;;;;;1816:31:1;;1806:42;;1796:70;;1862:1;1859;1852:12;1877:315;1945:6;1953;2006:2;1994:9;1985:7;1981:23;1977:32;1974:52;;;2022:1;2019;2012:12;1974:52;2061:9;2048:23;2080:31;2105:5;2080:31;:::i;:::-;2130:5;2182:2;2167:18;;;;2154:32;;-1:-1:-1;;;1877:315:1:o;2197:456::-;2274:6;2282;2290;2343:2;2331:9;2322:7;2318:23;2314:32;2311:52;;;2359:1;2356;2349:12;2311:52;2398:9;2385:23;2417:31;2442:5;2417:31;:::i;:::-;2467:5;-1:-1:-1;2524:2:1;2509:18;;2496:32;2537:33;2496:32;2537:33;:::i;:::-;2197:456;;2589:7;;-1:-1:-1;;;2643:2:1;2628:18;;;;2615:32;;2197:456::o;2658:592::-;2765:6;2773;2781;2834:2;2822:9;2813:7;2809:23;2805:32;2802:52;;;2850:1;2847;2840:12;2802:52;2889:9;2876:23;2908:31;2933:5;2908:31;:::i;:::-;2958:5;-1:-1:-1;3010:2:1;2995:18;;2982:32;;-1:-1:-1;3065:2:1;3050:18;;3037:32;3092:18;3081:30;;3078:50;;;3124:1;3121;3114:12;3078:50;3147:22;;3203:2;3185:16;;;3181:25;3178:45;;;3219:1;3216;3209:12;3178:45;3242:2;3232:12;;;2658:592;;;;;:::o;3255:348::-;3307:8;3317:6;3371:3;3364:4;3356:6;3352:17;3348:27;3338:55;;3389:1;3386;3379:12;3338:55;-1:-1:-1;3412:20:1;;3455:18;3444:30;;3441:50;;;3487:1;3484;3477:12;3441:50;3524:4;3516:6;3512:17;3500:29;;3576:3;3569:4;3560:6;3552;3548:19;3544:30;3541:39;3538:59;;;3593:1;3590;3583:12;3538:59;3255:348;;;;;:::o;3608:411::-;3679:6;3687;3740:2;3728:9;3719:7;3715:23;3711:32;3708:52;;;3756:1;3753;3746:12;3708:52;3796:9;3783:23;3829:18;3821:6;3818:30;3815:50;;;3861:1;3858;3851:12;3815:50;3900:59;3951:7;3942:6;3931:9;3927:22;3900:59;:::i;:::-;3978:8;;3874:85;;-1:-1:-1;3608:411:1;-1:-1:-1;;;;3608:411:1:o;4024:160::-;4089:20;;4145:13;;4138:21;4128:32;;4118:60;;4174:1;4171;4164:12;4118:60;4024:160;;;:::o;4189:248::-;4254:6;4262;4315:2;4303:9;4294:7;4290:23;4286:32;4283:52;;;4331:1;4328;4321:12;4283:52;4367:9;4354:23;4344:33;;4396:35;4427:2;4416:9;4412:18;4396:35;:::i;:::-;4386:45;;4189:248;;;;;:::o;4624:247::-;4683:6;4736:2;4724:9;4715:7;4711:23;4707:32;4704:52;;;4752:1;4749;4742:12;4704:52;4791:9;4778:23;4810:31;4835:5;4810:31;:::i;4876:315::-;4941:6;4949;5002:2;4990:9;4981:7;4977:23;4973:32;4970:52;;;5018:1;5015;5008:12;4970:52;5057:9;5044:23;5076:31;5101:5;5076:31;:::i;:::-;5126:5;-1:-1:-1;5150:35:1;5181:2;5166:18;;5150:35;:::i;5196:1010::-;5309:6;5317;5325;5333;5341;5349;5402:2;5390:9;5381:7;5377:23;5373:32;5370:52;;;5418:1;5415;5408:12;5370:52;5458:9;5445:23;5487:18;5528:2;5520:6;5517:14;5514:34;;;5544:1;5541;5534:12;5514:34;5583:59;5634:7;5625:6;5614:9;5610:22;5583:59;:::i;:::-;5661:8;;-1:-1:-1;5557:85:1;-1:-1:-1;5749:2:1;5734:18;;5721:32;;-1:-1:-1;5765:16:1;;;5762:36;;;5794:1;5791;5784:12;5762:36;5833:61;5886:7;5875:8;5864:9;5860:24;5833:61;:::i;:::-;5913:8;;-1:-1:-1;5807:87:1;-1:-1:-1;6001:2:1;5986:18;;5973:32;;-1:-1:-1;6017:16:1;;;6014:36;;;6046:1;6043;6036:12;6014:36;;6085:61;6138:7;6127:8;6116:9;6112:24;6085:61;:::i;:::-;5196:1010;;;;-1:-1:-1;5196:1010:1;;-1:-1:-1;5196:1010:1;;6165:8;;5196:1010;-1:-1:-1;;;5196:1010:1:o;6211:316::-;6285:6;6293;6301;6354:2;6342:9;6333:7;6329:23;6325:32;6322:52;;;6370:1;6367;6360:12;6322:52;6406:9;6393:23;6383:33;;6463:2;6452:9;6448:18;6435:32;6425:42;;6486:35;6517:2;6506:9;6502:18;6486:35;:::i;:::-;6476:45;;6211:316;;;;;:::o;6532:1178::-;6800:2;6812:21;;;6882:13;;6785:18;;;6904:22;;;6752:4;;6979;;6957:2;6942:18;;;7006:15;;;6752:4;7049:195;7063:6;7060:1;7057:13;7049:195;;;7128:13;;-1:-1:-1;;;;;7124:39:1;7112:52;;7184:12;;;;7219:15;;;;7160:1;7078:9;7049:195;;;-1:-1:-1;;;7280:19:1;;;7260:18;;;7253:47;7350:13;;7372:21;;;7448:15;;;;7411:12;;;7483:1;7493:189;7509:8;7504:3;7501:17;7493:189;;;7578:15;;7564:30;;7655:17;;;;7616:14;;;;7537:1;7528:11;7493:189;;;-1:-1:-1;7699:5:1;;6532:1178;-1:-1:-1;;;;;;;6532:1178:1:o;7715:127::-;7776:10;7771:3;7767:20;7764:1;7757:31;7807:4;7804:1;7797:15;7831:4;7828:1;7821:15;7847:1266;7942:6;7950;7958;7966;8019:3;8007:9;7998:7;7994:23;7990:33;7987:53;;;8036:1;8033;8026:12;7987:53;8075:9;8062:23;8094:31;8119:5;8094:31;:::i;:::-;8144:5;-1:-1:-1;8201:2:1;8186:18;;8173:32;8214:33;8173:32;8214:33;:::i;:::-;8266:7;-1:-1:-1;8320:2:1;8305:18;;8292:32;;-1:-1:-1;8375:2:1;8360:18;;8347:32;8398:18;8428:14;;;8425:34;;;8455:1;8452;8445:12;8425:34;8493:6;8482:9;8478:22;8468:32;;8538:7;8531:4;8527:2;8523:13;8519:27;8509:55;;8560:1;8557;8550:12;8509:55;8596:2;8583:16;8618:2;8614;8611:10;8608:36;;;8624:18;;:::i;:::-;8699:2;8693:9;8667:2;8753:13;;-1:-1:-1;;8749:22:1;;;8773:2;8745:31;8741:40;8729:53;;;8797:18;;;8817:22;;;8794:46;8791:72;;;8843:18;;:::i;:::-;8883:10;8879:2;8872:22;8918:2;8910:6;8903:18;8958:7;8953:2;8948;8944;8940:11;8936:20;8933:33;8930:53;;;8979:1;8976;8969:12;8930:53;9035:2;9030;9026;9022:11;9017:2;9009:6;9005:15;8992:46;9080:1;9075:2;9070;9062:6;9058:15;9054:24;9047:35;9101:6;9091:16;;;;;;;7847:1266;;;;;;;:::o;9118:388::-;9186:6;9194;9247:2;9235:9;9226:7;9222:23;9218:32;9215:52;;;9263:1;9260;9253:12;9215:52;9302:9;9289:23;9321:31;9346:5;9321:31;:::i;:::-;9371:5;-1:-1:-1;9428:2:1;9413:18;;9400:32;9441:33;9400:32;9441:33;:::i;:::-;9493:7;9483:17;;;9118:388;;;;;:::o;9511:380::-;9590:1;9586:12;;;;9633;;;9654:61;;9708:4;9700:6;9696:17;9686:27;;9654:61;9761:2;9753:6;9750:14;9730:18;9727:38;9724:161;;9807:10;9802:3;9798:20;9795:1;9788:31;9842:4;9839:1;9832:15;9870:4;9867:1;9860:15;9724:161;;9511:380;;;:::o;10728:409::-;10930:2;10912:21;;;10969:2;10949:18;;;10942:30;11008:34;11003:2;10988:18;;10981:62;-1:-1:-1;;;11074:2:1;11059:18;;11052:43;11127:3;11112:19;;10728:409::o;11142:575::-;11265:4;11271:6;11331:11;11318:25;11425:2;11421:7;11410:8;11394:14;11390:29;11386:43;11366:18;11362:68;11352:96;;11444:1;11441;11434:12;11352:96;11471:33;;11523:20;;;-1:-1:-1;11566:18:1;11555:30;;11552:50;;;11598:1;11595;11588:12;11552:50;11631:4;11619:17;;-1:-1:-1;11682:1:1;11678:14;;;11662;11658:35;11648:46;;11645:66;;;11707:1;11704;11697:12;13859:127;13920:10;13915:3;13911:20;13908:1;13901:31;13951:4;13948:1;13941:15;13975:4;13972:1;13965:15;13991:127;14052:10;14047:3;14043:20;14040:1;14033:31;14083:4;14080:1;14073:15;14107:4;14104:1;14097:15;14123:168;14196:9;;;14227;;14244:15;;;14238:22;;14224:37;14214:71;;14265:18;;:::i;14428:217::-;14468:1;14494;14484:132;;14538:10;14533:3;14529:20;14526:1;14519:31;14573:4;14570:1;14563:15;14601:4;14598:1;14591:15;14484:132;-1:-1:-1;14630:9:1;;14428:217::o;14776:1020::-;14952:3;14981:1;15014:6;15008:13;15044:36;15070:9;15044:36;:::i;:::-;15099:1;15116:18;;;15143:133;;;;15290:1;15285:356;;;;15109:532;;15143:133;-1:-1:-1;;15176:24:1;;15164:37;;15249:14;;15242:22;15230:35;;15221:45;;;-1:-1:-1;15143:133:1;;15285:356;15316:6;15313:1;15306:17;15346:4;15391:2;15388:1;15378:16;15416:1;15430:165;15444:6;15441:1;15438:13;15430:165;;;15522:14;;15509:11;;;15502:35;15565:16;;;;15459:10;;15430:165;;;15434:3;;;15624:6;15619:3;15615:16;15608:23;;15109:532;;;;;15672:6;15666:13;15688:68;15747:8;15742:3;15735:4;15727:6;15723:17;15688:68;:::i;:::-;15772:18;;14776:1020;-1:-1:-1;;;;14776:1020:1:o;15801:401::-;16003:2;15985:21;;;16042:2;16022:18;;;16015:30;16081:34;16076:2;16061:18;;16054:62;-1:-1:-1;;;16147:2:1;16132:18;;16125:35;16192:3;16177:19;;15801:401::o;18035:137::-;-1:-1:-1;;;;;18113:5:1;18109:38;18102:5;18099:49;18089:77;;18162:1;18159;18152:12;18177:245;18235:6;18288:2;18276:9;18267:7;18263:23;18259:32;18256:52;;;18304:1;18301;18294:12;18256:52;18343:9;18330:23;18362:30;18386:5;18362:30;:::i;18427:125::-;18492:9;;;18513:10;;;18510:36;;;18526:18;;:::i;19277:533::-;19448:5;19435:19;19463:33;19488:7;19463:33;:::i;:::-;19632:11;;-1:-1:-1;;;;;;19628:20:1;;;-1:-1:-1;;;;;19515:33:1;;;;19625:28;;;19612:42;;19702:2;19691:14;;19678:28;19715:32;19678:28;19715:32;:::i;:::-;19784:3;19780:17;19776:26;19769:34;19756:48;;-1:-1:-1;19277:533:1:o;20176:545::-;20278:2;20273:3;20270:11;20267:448;;;20314:1;20339:5;20335:2;20328:17;20384:4;20380:2;20370:19;20454:2;20442:10;20438:19;20435:1;20431:27;20425:4;20421:38;20490:4;20478:10;20475:20;20472:47;;;-1:-1:-1;20513:4:1;20472:47;20568:2;20563:3;20559:12;20556:1;20552:20;20546:4;20542:31;20532:41;;20623:82;20641:2;20634:5;20631:13;20623:82;;;20686:17;;;20667:1;20656:13;20623:82;;;20627:3;;;20176:545;;;:::o;20897:1206::-;21021:18;21016:3;21013:27;21010:53;;;21043:18;;:::i;:::-;21072:94;21162:3;21122:38;21154:4;21148:11;21122:38;:::i;:::-;21116:4;21072:94;:::i;:::-;21192:1;21217:2;21212:3;21209:11;21234:1;21229:616;;;;21889:1;21906:3;21903:93;;;-1:-1:-1;21962:19:1;;;21949:33;21903:93;-1:-1:-1;;20854:1:1;20850:11;;;20846:24;20842:29;20832:40;20878:1;20874:11;;;20829:57;22009:78;;21202:895;;21229:616;14723:1;14716:14;;;14760:4;14747:18;;-1:-1:-1;;21265:17:1;;;21366:9;21388:229;21402:7;21399:1;21396:14;21388:229;;;21491:19;;;21478:33;21463:49;;21598:4;21583:20;;;;21551:1;21539:14;;;;21418:12;21388:229;;;21392:3;21645;21636:7;21633:16;21630:159;;;21769:1;21765:6;21759:3;21753;21750:1;21746:11;21742:21;21738:34;21734:39;21721:9;21716:3;21712:19;21699:33;21695:79;21687:6;21680:95;21630:159;;;21832:1;21826:3;21823:1;21819:11;21815:19;21809:4;21802:33;21202:895;;;20897:1206;;;:::o;22108:390::-;22267:2;22256:9;22249:21;22306:6;22301:2;22290:9;22286:18;22279:34;22363:6;22355;22350:2;22339:9;22335:18;22322:48;22419:1;22390:22;;;22414:2;22386:31;;;22379:42;;;;22482:2;22461:15;;;-1:-1:-1;;22457:29:1;22442:45;22438:54;;22108:390;-1:-1:-1;22108:390:1:o;22857:407::-;23059:2;23041:21;;;23098:2;23078:18;;;23071:30;23137:34;23132:2;23117:18;;23110:62;-1:-1:-1;;;23203:2:1;23188:18;;23181:41;23254:3;23239:19;;22857:407::o;23269:414::-;23471:2;23453:21;;;23510:2;23490:18;;;23483:30;23549:34;23544:2;23529:18;;23522:62;-1:-1:-1;;;23615:2:1;23600:18;;23593:48;23673:3;23658:19;;23269:414::o;24037:1352::-;24163:3;24157:10;24190:18;24182:6;24179:30;24176:56;;;24212:18;;:::i;:::-;24241:97;24331:6;24291:38;24323:4;24317:11;24291:38;:::i;:::-;24285:4;24241:97;:::i;:::-;24393:4;;24457:2;24446:14;;24474:1;24469:663;;;;25176:1;25193:6;25190:89;;;-1:-1:-1;25245:19:1;;;25239:26;25190:89;-1:-1:-1;;20854:1:1;20850:11;;;20846:24;20842:29;20832:40;20878:1;20874:11;;;20829:57;25292:81;;24439:944;;24469:663;14723:1;14716:14;;;14760:4;14747:18;;-1:-1:-1;;24505:20:1;;;24623:236;24637:7;24634:1;24631:14;24623:236;;;24726:19;;;24720:26;24705:42;;24818:27;;;;24786:1;24774:14;;;;24653:19;;24623:236;;;24627:3;24887:6;24878:7;24875:19;24872:201;;;24948:19;;;24942:26;-1:-1:-1;;25031:1:1;25027:14;;;25043:3;25023:24;25019:37;25015:42;25000:58;24985:74;;24872:201;-1:-1:-1;;;;;25119:1:1;25103:14;;;25099:22;25086:36;;-1:-1:-1;24037:1352:1:o;25394:489::-;-1:-1:-1;;;;;25663:15:1;;;25645:34;;25715:15;;25710:2;25695:18;;25688:43;25762:2;25747:18;;25740:34;;;25810:3;25805:2;25790:18;;25783:31;;;25588:4;;25831:46;;25857:19;;25849:6;25831:46;:::i;:::-;25823:54;25394:489;-1:-1:-1;;;;;;25394:489:1:o;25888:249::-;25957:6;26010:2;25998:9;25989:7;25985:23;25981:32;25978:52;;;26026:1;26023;26016:12;25978:52;26058:9;26052:16;26077:30;26101:5;26077:30;:::i
Swarm Source
ipfs://8c7d1e3672dbdfa07934353a3ca8e182c2dad55e27fc45d91713c19ccf887db4
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 26 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
Loading...
Loading
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.