ERC-721
NFT
Overview
Max Total Supply
2,622 DAILY
Holders
401
Market
Volume (24H)
0.0201 ETH
Min Price (24H)
$52.09 @ 0.020100 ETH
Max Price (24H)
$52.09 @ 0.020100 ETH
Other Info
Token Contract
Balance
13 DAILYLoading...
Loading
Loading...
Loading
Loading...
Loading
# | Exchange | Pair | Price | 24H Volume | % Volume |
---|
Contract Name:
FellowshipDailyArtCollection
Compiler Version
v0.8.21+commit.d9974bed
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2023-09-12 */ // File: operator-filter-registry/src/lib/Constants.sol pragma solidity ^0.8.13; address constant CANONICAL_OPERATOR_FILTER_REGISTRY_ADDRESS = 0x000000000000AAeB6D7670E522A718067333cd4E; address constant CANONICAL_CORI_SUBSCRIPTION = 0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6; // File: @openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol // OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol) pragma solidity ^0.8.1; /** * @dev Collection of functions related to the address type */ library AddressUpgradeable { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * * Furthermore, `isContract` will also return true if the target contract within * the same transaction is already scheduled for destruction by `SELFDESTRUCT`, * which only has an effect at the end of a transaction. * ==== * * [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://consensys.net/diligence/blog/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.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); (bool success, ) = recipient.call{value: amount}(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage ) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall( address target, bytes memory data, string memory errorMessage ) internal view returns (bytes memory) { (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract. * * _Available since v4.8._ */ function verifyCallResultFromTarget( address target, bool success, bytes memory returndata, string memory errorMessage ) internal view returns (bytes memory) { if (success) { if (returndata.length == 0) { // only check isContract if the call was successful and the return data is empty // otherwise we already know that it was a contract require(isContract(target), "Address: call to non-contract"); } return returndata; } else { _revert(returndata, errorMessage); } } /** * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason or using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal pure returns (bytes memory) { if (success) { return returndata; } else { _revert(returndata, errorMessage); } } function _revert(bytes memory returndata, string memory errorMessage) private pure { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } // File: @openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol // OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol) pragma solidity ^0.8.2; /** * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect. * * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in * case an upgrade adds a module that needs to be initialized. * * For example: * * [.hljs-theme-light.nopadding] * ```solidity * 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: operator-filter-registry/src/IOperatorFilterRegistry.sol pragma solidity ^0.8.13; interface IOperatorFilterRegistry { /** * @notice Returns true if operator is not filtered for a given token, either by address or codeHash. Also returns * true if supplied registrant address is not registered. */ function isOperatorAllowed(address registrant, address operator) external view returns (bool); /** * @notice Registers an address with the registry. May be called by address itself or by EIP-173 owner. */ function register(address registrant) external; /** * @notice Registers an address with the registry and "subscribes" to another address's filtered operators and codeHashes. */ function registerAndSubscribe(address registrant, address subscription) external; /** * @notice Registers an address with the registry and copies the filtered operators and codeHashes from another * address without subscribing. */ function registerAndCopyEntries(address registrant, address registrantToCopy) external; /** * @notice Unregisters an address with the registry and removes its subscription. May be called by address itself or by EIP-173 owner. * Note that this does not remove any filtered addresses or codeHashes. * Also note that any subscriptions to this registrant will still be active and follow the existing filtered addresses and codehashes. */ function unregister(address addr) external; /** * @notice Update an operator address for a registered address - when filtered is true, the operator is filtered. */ function updateOperator(address registrant, address operator, bool filtered) external; /** * @notice Update multiple operators for a registered address - when filtered is true, the operators will be filtered. Reverts on duplicates. */ function updateOperators(address registrant, address[] calldata operators, bool filtered) external; /** * @notice Update a codeHash for a registered address - when filtered is true, the codeHash is filtered. */ function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external; /** * @notice Update multiple codeHashes for a registered address - when filtered is true, the codeHashes will be filtered. Reverts on duplicates. */ function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external; /** * @notice Subscribe an address to another registrant's filtered operators and codeHashes. Will remove previous * subscription if present. * Note that accounts with subscriptions may go on to subscribe to other accounts - in this case, * subscriptions will not be forwarded. Instead the former subscription's existing entries will still be * used. */ function subscribe(address registrant, address registrantToSubscribe) external; /** * @notice Unsubscribe an address from its current subscribed registrant, and optionally copy its filtered operators and codeHashes. */ function unsubscribe(address registrant, bool copyExistingEntries) external; /** * @notice Get the subscription address of a given registrant, if any. */ function subscriptionOf(address addr) external returns (address registrant); /** * @notice Get the set of addresses subscribed to a given registrant. * Note that order is not guaranteed as updates are made. */ function subscribers(address registrant) external returns (address[] memory); /** * @notice Get the subscriber at a given index in the set of addresses subscribed to a given registrant. * Note that order is not guaranteed as updates are made. */ function subscriberAt(address registrant, uint256 index) external returns (address); /** * @notice Copy filtered operators and codeHashes from a different registrantToCopy to addr. */ function copyEntriesOf(address registrant, address registrantToCopy) external; /** * @notice Returns true if operator is filtered by a given address or its subscription. */ function isOperatorFiltered(address registrant, address operator) external returns (bool); /** * @notice Returns true if the hash of an address's code is filtered by a given address or its subscription. */ function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool); /** * @notice Returns true if a codeHash is filtered by a given address or its subscription. */ function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool); /** * @notice Returns a list of filtered operators for a given address or its subscription. */ function filteredOperators(address addr) external returns (address[] memory); /** * @notice Returns the set of filtered codeHashes for a given address or its subscription. * Note that order is not guaranteed as updates are made. */ function filteredCodeHashes(address addr) external returns (bytes32[] memory); /** * @notice Returns the filtered operator at the given index of the set of filtered operators for a given address or * its subscription. * Note that order is not guaranteed as updates are made. */ function filteredOperatorAt(address registrant, uint256 index) external returns (address); /** * @notice Returns the filtered codeHash at the given index of the list of filtered codeHashes for a given address or * its subscription. * Note that order is not guaranteed as updates are made. */ function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32); /** * @notice Returns true if an address has registered */ function isRegistered(address addr) external returns (bool); /** * @dev Convenience method to compute the code hash of an arbitrary contract */ function codeHashOf(address addr) external returns (bytes32); } // File: operator-filter-registry/src/upgradeable/OperatorFiltererUpgradeable.sol pragma solidity ^0.8.13; /** * @title OperatorFiltererUpgradeable * @notice Abstract contract whose constructor automatically registers and optionally subscribes to or copies another * registrant's entries in the OperatorFilterRegistry when the init function is called. * @dev This smart contract is meant to be inherited by token contracts so they can use the following: * - `onlyAllowedOperator` modifier for `transferFrom` and `safeTransferFrom` methods. * - `onlyAllowedOperatorApproval` modifier for `approve` and `setApprovalForAll` methods. */ abstract contract OperatorFiltererUpgradeable is Initializable { /// @notice Emitted when an operator is not allowed. error OperatorNotAllowed(address operator); IOperatorFilterRegistry constant OPERATOR_FILTER_REGISTRY = IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E); /// @dev The upgradeable initialize function that should be called when the contract is being upgraded. function __OperatorFilterer_init(address subscriptionOrRegistrantToCopy, bool subscribe) internal onlyInitializing { // If an inheriting token contract is deployed to a network without the registry deployed, the modifier // will not revert, but the contract will need to be registered with the registry once it is deployed in // order for the modifier to filter addresses. if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) { if (!OPERATOR_FILTER_REGISTRY.isRegistered(address(this))) { if (subscribe) { OPERATOR_FILTER_REGISTRY.registerAndSubscribe(address(this), subscriptionOrRegistrantToCopy); } else { if (subscriptionOrRegistrantToCopy != address(0)) { OPERATOR_FILTER_REGISTRY.registerAndCopyEntries(address(this), subscriptionOrRegistrantToCopy); } else { OPERATOR_FILTER_REGISTRY.register(address(this)); } } } } } /** * @dev A helper modifier to check if the operator is allowed. */ modifier onlyAllowedOperator(address from) virtual { // Allow spending tokens from addresses with balance // Note that this still allows listings and marketplaces with escrow to transfer tokens if transferred // from an EOA. if (from != msg.sender) { _checkFilterOperator(msg.sender); } _; } /** * @dev A helper modifier to check if the operator approval is allowed. */ modifier onlyAllowedOperatorApproval(address operator) virtual { _checkFilterOperator(operator); _; } /** * @dev A helper function to check if the operator is allowed. */ function _checkFilterOperator(address operator) internal view virtual { // Check registry code length to facilitate testing in environments without a deployed registry. if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) { // under normal circumstances, this function will revert rather than return false, but inheriting or // upgraded contracts may specify their own OperatorFilterRegistry implementations, which may behave // differently if (!OPERATOR_FILTER_REGISTRY.isOperatorAllowed(address(this), operator)) { revert OperatorNotAllowed(operator); } } } } // File: operator-filter-registry/src/upgradeable/RevokableOperatorFiltererUpgradeable.sol pragma solidity ^0.8.13; /** * @title Upgradeable storage layout for RevokableOperatorFiltererUpgradeable. * @notice Upgradeable contracts must use a storage layout that can be used across upgrades. * Only append new variables to the end of the layout. */ library RevokableOperatorFiltererUpgradeableStorage { struct Layout { /// @dev Whether the OperatorFilterRegistry has been revoked. bool _isOperatorFilterRegistryRevoked; } /// @dev The storage slot for the layout. bytes32 internal constant STORAGE_SLOT = keccak256("RevokableOperatorFiltererUpgradeable.contracts.storage"); /// @dev The layout of the storage. function layout() internal pure returns (Layout storage l) { bytes32 slot = STORAGE_SLOT; assembly { l.slot := slot } } } /** * @title RevokableOperatorFilterer * @notice This contract is meant to allow contracts to permanently opt out of the OperatorFilterRegistry. The Registry * itself has an "unregister" function, but if the contract is ownable, the owner can re-register at any point. * As implemented, this abstract contract allows the contract owner to toggle the * isOperatorFilterRegistryRevoked flag in order to permanently bypass the OperatorFilterRegistry checks. */ abstract contract RevokableOperatorFiltererUpgradeable is OperatorFiltererUpgradeable { using RevokableOperatorFiltererUpgradeableStorage for RevokableOperatorFiltererUpgradeableStorage.Layout; error OnlyOwner(); error AlreadyRevoked(); event OperatorFilterRegistryRevoked(); function __RevokableOperatorFilterer_init(address subscriptionOrRegistrantToCopy, bool subscribe) internal { OperatorFiltererUpgradeable.__OperatorFilterer_init(subscriptionOrRegistrantToCopy, subscribe); } /** * @dev A helper function to check if the operator is allowed. */ function _checkFilterOperator(address operator) internal view virtual override { // Check registry code length to facilitate testing in environments without a deployed registry. if ( !RevokableOperatorFiltererUpgradeableStorage.layout()._isOperatorFilterRegistryRevoked && address(OPERATOR_FILTER_REGISTRY).code.length > 0 ) { // under normal circumstances, this function will revert rather than return false, but inheriting or // upgraded contracts may specify their own OperatorFilterRegistry implementations, which may behave // differently if (!OPERATOR_FILTER_REGISTRY.isOperatorAllowed(address(this), operator)) { revert OperatorNotAllowed(operator); } } } /** * @notice Disable the isOperatorFilterRegistryRevoked flag. OnlyOwner. */ function revokeOperatorFilterRegistry() external { if (msg.sender != owner()) { revert OnlyOwner(); } if (RevokableOperatorFiltererUpgradeableStorage.layout()._isOperatorFilterRegistryRevoked) { revert AlreadyRevoked(); } RevokableOperatorFiltererUpgradeableStorage.layout()._isOperatorFilterRegistryRevoked = true; emit OperatorFilterRegistryRevoked(); } function isOperatorFilterRegistryRevoked() public view returns (bool) { return RevokableOperatorFiltererUpgradeableStorage.layout()._isOperatorFilterRegistryRevoked; } /** * @dev assume the contract has an owner, but leave specific Ownable implementation up to inheriting contract */ function owner() public view virtual returns (address); } // File: operator-filter-registry/src/upgradeable/RevokableDefaultOperatorFiltererUpgradeable.sol pragma solidity ^0.8.13; /** * @title RevokableDefaultOperatorFiltererUpgradeable * @notice Inherits from RevokableOperatorFiltererUpgradeable and automatically subscribes to the default OpenSea subscription * when the init function is called. * Note that OpenSea will disable creator earnings enforcement if filtered operators begin fulfilling orders * on-chain, eg, if the registry is revoked or bypassed. */ abstract contract RevokableDefaultOperatorFiltererUpgradeable is RevokableOperatorFiltererUpgradeable { /// @dev The upgradeable initialize function that should be called when the contract is being upgraded. function __RevokableDefaultOperatorFilterer_init() internal onlyInitializing { RevokableOperatorFiltererUpgradeable.__RevokableOperatorFilterer_init(CANONICAL_CORI_SUBSCRIPTION, true); } } // File: @openzeppelin/contracts/utils/math/SignedMath.sol // OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol) pragma solidity ^0.8.0; /** * @dev Standard signed math utilities missing in the Solidity language. */ library SignedMath { /** * @dev Returns the largest of two signed numbers. */ function max(int256 a, int256 b) internal pure returns (int256) { return a > b ? a : b; } /** * @dev Returns the smallest of two signed numbers. */ function min(int256 a, int256 b) internal pure returns (int256) { return a < b ? a : b; } /** * @dev Returns the average of two signed numbers without overflow. * The result is rounded towards zero. */ function average(int256 a, int256 b) internal pure returns (int256) { // Formula from the book "Hacker's Delight" int256 x = (a & b) + ((a ^ b) >> 1); return x + (int256(uint256(x) >> 255) & (a ^ b)); } /** * @dev Returns the absolute unsigned value of a signed value. */ function abs(int256 n) internal pure returns (uint256) { unchecked { // must be unchecked in order to support `n = type(int256).min` return uint256(n >= 0 ? n : -n); } } } // File: @openzeppelin/contracts/utils/math/Math.sol // OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol) pragma solidity ^0.8.0; /** * @dev Standard math utilities missing in the Solidity language. */ library Math { enum Rounding { Down, // Toward negative infinity Up, // Toward infinity Zero // Toward zero } /** * @dev Returns the largest of two numbers. */ function max(uint256 a, uint256 b) internal pure returns (uint256) { return a > b ? a : b; } /** * @dev Returns the smallest of two numbers. */ function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } /** * @dev Returns the average of two numbers. The result is rounded towards * zero. */ function average(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b) / 2 can overflow. return (a & b) + (a ^ b) / 2; } /** * @dev Returns the ceiling of the division of two numbers. * * This differs from standard division with `/` in that it rounds up instead * of rounding down. */ function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b - 1) / b can overflow on addition, so we distribute. return a == 0 ? 0 : (a - 1) / b + 1; } /** * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0 * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) * with further edits by Uniswap Labs also under MIT license. */ function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) { unchecked { // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256 // variables such that product = prod1 * 2^256 + prod0. uint256 prod0; // Least significant 256 bits of the product uint256 prod1; // Most significant 256 bits of the product assembly { let mm := mulmod(x, y, not(0)) prod0 := mul(x, y) prod1 := sub(sub(mm, prod0), lt(mm, prod0)) } // Handle non-overflow cases, 256 by 256 division. if (prod1 == 0) { // Solidity will revert if denominator == 0, unlike the div opcode on its own. // The surrounding unchecked block does not change this fact. // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic. return prod0 / denominator; } // Make sure the result is less than 2^256. Also prevents denominator == 0. require(denominator > prod1, "Math: mulDiv overflow"); /////////////////////////////////////////////// // 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 256, 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 << 3) < value ? 1 : 0); } } } // File: @openzeppelin/contracts/utils/Strings.sol // OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol) pragma solidity ^0.8.0; /** * @dev String operations. */ library Strings { bytes16 private constant _SYMBOLS = "0123456789abcdef"; uint8 private constant _ADDRESS_LENGTH = 20; /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function toString(uint256 value) internal pure returns (string memory) { unchecked { uint256 length = Math.log10(value) + 1; string memory buffer = new string(length); uint256 ptr; /// @solidity memory-safe-assembly assembly { ptr := add(buffer, add(32, length)) } while (true) { ptr--; /// @solidity memory-safe-assembly assembly { mstore8(ptr, byte(mod(value, 10), _SYMBOLS)) } value /= 10; if (value == 0) break; } return buffer; } } /** * @dev Converts a `int256` to its ASCII `string` decimal representation. */ function toString(int256 value) internal pure returns (string memory) { return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value)))); } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { unchecked { return toHexString(value, Math.log256(value) + 1); } } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length. */ function toHexString(uint256 value, uint256 length) internal pure returns (string memory) { bytes memory buffer = new bytes(2 * length + 2); buffer[0] = "0"; buffer[1] = "x"; for (uint256 i = 2 * length + 1; i > 1; --i) { buffer[i] = _SYMBOLS[value & 0xf]; value >>= 4; } require(value == 0, "Strings: hex length insufficient"); return string(buffer); } /** * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation. */ function toHexString(address addr) internal pure returns (string memory) { return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH); } /** * @dev Returns true if the two strings are equal. */ function equal(string memory a, string memory b) internal pure returns (bool) { return keccak256(bytes(a)) == keccak256(bytes(b)); } } // File: @openzeppelin/contracts/utils/Address.sol // OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol) pragma solidity ^0.8.1; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * * Furthermore, `isContract` will also return true if the target contract within * the same transaction is already scheduled for destruction by `SELFDESTRUCT`, * which only has an effect at the end of a transaction. * ==== * * [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://consensys.net/diligence/blog/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.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); (bool success, ) = recipient.call{value: amount}(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage ) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall( address target, bytes memory data, string memory errorMessage ) internal view returns (bytes memory) { (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract. * * _Available since v4.8._ */ function verifyCallResultFromTarget( address target, bool success, bytes memory returndata, string memory errorMessage ) internal view returns (bytes memory) { if (success) { if (returndata.length == 0) { // only check isContract if the call was successful and the return data is empty // otherwise we already know that it was a contract require(isContract(target), "Address: call to non-contract"); } return returndata; } else { _revert(returndata, errorMessage); } } /** * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason or using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal pure returns (bytes memory) { if (success) { return returndata; } else { _revert(returndata, errorMessage); } } function _revert(bytes memory returndata, string memory errorMessage) private pure { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } // File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol) pragma solidity ^0.8.0; /** * @title ERC721 token receiver interface * @dev Interface for any contract that wants to support safeTransfers * from ERC721 asset contracts. */ interface IERC721Receiver { /** * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom} * by `operator` from `from`, this function is called. * * It must return its Solidity selector to confirm the token transfer. * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted. * * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`. */ function onERC721Received( address operator, address from, uint256 tokenId, bytes calldata data ) external returns (bytes4); } // File: @openzeppelin/contracts/utils/introspection/IERC165.sol // OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC165 standard, as defined in the * https://eips.ethereum.org/EIPS/eip-165[EIP]. * * Implementers can declare support of contract interfaces, which can then be * queried by others ({ERC165Checker}). * * For an implementation, see {ERC165}. */ interface IERC165 { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); } // File: @openzeppelin/contracts/utils/introspection/ERC165.sol // OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol) pragma solidity ^0.8.0; /** * @dev Implementation of the {IERC165} interface. * * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check * for the additional interface id that will be supported. For example: * * ```solidity * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId); * } * ``` * * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation. */ abstract contract ERC165 is IERC165 { /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IERC165).interfaceId; } } // File: @openzeppelin/contracts/token/ERC721/IERC721.sol // OpenZeppelin Contracts (last updated v4.9.0) (token/ERC721/IERC721.sol) pragma solidity ^0.8.0; /** * @dev Required interface of an ERC721 compliant contract. */ interface IERC721 is IERC165 { /** * @dev Emitted when `tokenId` token is transferred from `from` to `to`. */ event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token. */ event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets. */ event ApprovalForAll(address indexed owner, address indexed operator, bool approved); /** * @dev Returns the number of tokens in ``owner``'s account. */ function balanceOf(address owner) external view returns (uint256 balance); /** * @dev Returns the owner of the `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function ownerOf(uint256 tokenId) external view returns (address owner); /** * @dev Safely transfers `tokenId` token from `from` to `to`. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external; /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom(address from, address to, uint256 tokenId) external; /** * @dev Transfers `tokenId` token from `from` to `to`. * * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721 * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must * understand this adds an external call which potentially creates a reentrancy vulnerability. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * * Emits a {Transfer} event. */ function transferFrom(address from, address to, uint256 tokenId) external; /** * @dev Gives permission to `to` to transfer `tokenId` token to another account. * The approval is cleared when the token is transferred. * * Only a single account can be approved at a time, so approving the zero address clears previous approvals. * * Requirements: * * - The caller must own the token or be an approved operator. * - `tokenId` must exist. * * Emits an {Approval} event. */ function approve(address to, uint256 tokenId) external; /** * @dev Approve or remove `operator` as an operator for the caller. * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. * * Requirements: * * - The `operator` cannot be the caller. * * Emits an {ApprovalForAll} event. */ function setApprovalForAll(address operator, bool approved) external; /** * @dev Returns the account approved for `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function getApproved(uint256 tokenId) external view returns (address operator); /** * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`. * * See {setApprovalForAll} */ function isApprovedForAll(address owner, address operator) external view returns (bool); } // File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol // OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol) pragma solidity ^0.8.0; /** * @title ERC-721 Non-Fungible Token Standard, optional metadata extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721Metadata is IERC721 { /** * @dev Returns the token collection name. */ function name() external view returns (string memory); /** * @dev Returns the token collection symbol. */ function symbol() external view returns (string memory); /** * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token. */ function tokenURI(uint256 tokenId) external view returns (string memory); } // File: @openzeppelin/contracts/utils/Context.sol // OpenZeppelin Contracts v4.4.1 (utils/Context.sol) pragma solidity ^0.8.0; /** * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } } // File: @openzeppelin/contracts/token/ERC721/ERC721.sol // OpenZeppelin Contracts (last updated v4.9.0) (token/ERC721/ERC721.sol) pragma solidity ^0.8.0; /** * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including * the Metadata extension, but not including the Enumerable extension, which is available separately as * {ERC721Enumerable}. */ contract ERC721 is Context, ERC165, IERC721, IERC721Metadata { using Address for address; using Strings for uint256; // Token name string private _name; // Token symbol string private _symbol; // Mapping from token ID to owner address mapping(uint256 => address) private _owners; // Mapping owner address to token count mapping(address => uint256) private _balances; // Mapping from token ID to approved address mapping(uint256 => address) private _tokenApprovals; // Mapping from owner to operator approvals mapping(address => mapping(address => bool)) private _operatorApprovals; /** * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection. */ constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) { return interfaceId == type(IERC721).interfaceId || interfaceId == type(IERC721Metadata).interfaceId || super.supportsInterface(interfaceId); } /** * @dev See {IERC721-balanceOf}. */ function balanceOf(address owner) public view virtual override returns (uint256) { require(owner != address(0), "ERC721: address zero is not a valid owner"); return _balances[owner]; } /** * @dev See {IERC721-ownerOf}. */ function ownerOf(uint256 tokenId) public view virtual override returns (address) { address owner = _ownerOf(tokenId); require(owner != address(0), "ERC721: invalid token ID"); return owner; } /** * @dev See {IERC721Metadata-name}. */ function name() public view virtual override returns (string memory) { return _name; } /** * @dev See {IERC721Metadata-symbol}. */ function symbol() public view virtual override returns (string memory) { return _symbol; } /** * @dev See {IERC721Metadata-tokenURI}. */ function tokenURI(uint256 tokenId) public view virtual override returns (string memory) { _requireMinted(tokenId); string memory baseURI = _baseURI(); return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : ""; } /** * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each * token will be the concatenation of the `baseURI` and the `tokenId`. Empty * by default, can be overridden in child contracts. */ function _baseURI() internal view virtual returns (string memory) { return ""; } /** * @dev See {IERC721-approve}. */ function approve(address to, uint256 tokenId) public virtual override { address owner = ERC721.ownerOf(tokenId); require(to != owner, "ERC721: approval to current owner"); require( _msgSender() == owner || isApprovedForAll(owner, _msgSender()), "ERC721: approve caller is not token owner or approved for all" ); _approve(to, tokenId); } /** * @dev See {IERC721-getApproved}. */ function getApproved(uint256 tokenId) public view virtual override returns (address) { _requireMinted(tokenId); return _tokenApprovals[tokenId]; } /** * @dev See {IERC721-setApprovalForAll}. */ function setApprovalForAll(address operator, bool approved) public virtual override { _setApprovalForAll(_msgSender(), operator, approved); } /** * @dev See {IERC721-isApprovedForAll}. */ function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) { return _operatorApprovals[owner][operator]; } /** * @dev See {IERC721-transferFrom}. */ function transferFrom(address from, address to, uint256 tokenId) public virtual override { //solhint-disable-next-line max-line-length require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved"); _transfer(from, to, tokenId); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override { safeTransferFrom(from, to, tokenId, ""); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public virtual override { require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved"); _safeTransfer(from, to, tokenId, data); } /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * `data` is additional data, it has no specified format and it is sent in call to `to`. * * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g. * implement alternative mechanisms to perform token transfer, such as signature-based. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function _safeTransfer(address from, address to, uint256 tokenId, bytes memory data) internal virtual { _transfer(from, to, tokenId); require(_checkOnERC721Received(from, to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer"); } /** * @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist */ function _ownerOf(uint256 tokenId) internal view virtual returns (address) { return _owners[tokenId]; } /** * @dev Returns whether `tokenId` exists. * * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}. * * Tokens start existing when they are minted (`_mint`), * and stop existing when they are burned (`_burn`). */ function _exists(uint256 tokenId) internal view virtual returns (bool) { return _ownerOf(tokenId) != address(0); } /** * @dev Returns whether `spender` is allowed to manage `tokenId`. * * Requirements: * * - `tokenId` must exist. */ function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) { address owner = ERC721.ownerOf(tokenId); return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender); } /** * @dev Safely mints `tokenId` and transfers it to `to`. * * Requirements: * * - `tokenId` must not exist. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function _safeMint(address to, uint256 tokenId) internal virtual { _safeMint(to, tokenId, ""); } /** * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is * forwarded in {IERC721Receiver-onERC721Received} to contract recipients. */ function _safeMint(address to, uint256 tokenId, bytes memory data) internal virtual { _mint(to, tokenId); require( _checkOnERC721Received(address(0), to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer" ); } /** * @dev Mints `tokenId` and transfers it to `to`. * * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible * * Requirements: * * - `tokenId` must not exist. * - `to` cannot be the zero address. * * Emits a {Transfer} event. */ function _mint(address to, uint256 tokenId) internal virtual { require(to != address(0), "ERC721: mint to the zero address"); require(!_exists(tokenId), "ERC721: token already minted"); _beforeTokenTransfer(address(0), to, tokenId, 1); // Check that tokenId was not minted by `_beforeTokenTransfer` hook require(!_exists(tokenId), "ERC721: token already minted"); unchecked { // Will not overflow unless all 2**256 token ids are minted to the same owner. // Given that tokens are minted one by one, it is impossible in practice that // this ever happens. Might change if we allow batch minting. // The ERC fails to describe this case. _balances[to] += 1; } _owners[tokenId] = to; emit Transfer(address(0), to, tokenId); _afterTokenTransfer(address(0), to, tokenId, 1); } /** * @dev Destroys `tokenId`. * The approval is cleared when the token is burned. * This is an internal function that does not check if the sender is authorized to operate on the token. * * Requirements: * * - `tokenId` must exist. * * Emits a {Transfer} event. */ function _burn(uint256 tokenId) internal virtual { address owner = ERC721.ownerOf(tokenId); _beforeTokenTransfer(owner, address(0), tokenId, 1); // Update ownership in case tokenId was transferred by `_beforeTokenTransfer` hook owner = ERC721.ownerOf(tokenId); // Clear approvals delete _tokenApprovals[tokenId]; unchecked { // Cannot overflow, as that would require more tokens to be burned/transferred // out than the owner initially received through minting and transferring in. _balances[owner] -= 1; } delete _owners[tokenId]; emit Transfer(owner, address(0), tokenId); _afterTokenTransfer(owner, address(0), tokenId, 1); } /** * @dev Transfers `tokenId` from `from` to `to`. * As opposed to {transferFrom}, this imposes no restrictions on msg.sender. * * Requirements: * * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * * Emits a {Transfer} event. */ function _transfer(address from, address to, uint256 tokenId) internal virtual { require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner"); require(to != address(0), "ERC721: transfer to the zero address"); _beforeTokenTransfer(from, to, tokenId, 1); // Check that tokenId was not transferred by `_beforeTokenTransfer` hook require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner"); // Clear approvals from the previous owner delete _tokenApprovals[tokenId]; unchecked { // `_balances[from]` cannot overflow for the same reason as described in `_burn`: // `from`'s balance is the number of token held, which is at least one before the current // transfer. // `_balances[to]` could overflow in the conditions described in `_mint`. That would require // all 2**256 token ids to be minted, which in practice is impossible. _balances[from] -= 1; _balances[to] += 1; } _owners[tokenId] = to; emit Transfer(from, to, tokenId); _afterTokenTransfer(from, to, tokenId, 1); } /** * @dev Approve `to` to operate on `tokenId` * * Emits an {Approval} event. */ function _approve(address to, uint256 tokenId) internal virtual { _tokenApprovals[tokenId] = to; emit Approval(ERC721.ownerOf(tokenId), to, tokenId); } /** * @dev Approve `operator` to operate on all of `owner` tokens * * Emits an {ApprovalForAll} event. */ function _setApprovalForAll(address owner, address operator, bool approved) internal virtual { require(owner != operator, "ERC721: approve to caller"); _operatorApprovals[owner][operator] = approved; emit ApprovalForAll(owner, operator, approved); } /** * @dev Reverts if the `tokenId` has not been minted yet. */ function _requireMinted(uint256 tokenId) internal view virtual { require(_exists(tokenId), "ERC721: invalid token ID"); } /** * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address. * The call is not executed if the target address is not a contract. * * @param from address representing the previous owner of the given token ID * @param to target address that will receive the tokens * @param tokenId uint256 ID of the token to be transferred * @param data bytes optional data to send along with the call * @return bool whether the call correctly returned the expected magic value */ function _checkOnERC721Received( address from, address to, uint256 tokenId, bytes memory data ) private returns (bool) { if (to.isContract()) { try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) { return retval == IERC721Receiver.onERC721Received.selector; } catch (bytes memory reason) { if (reason.length == 0) { revert("ERC721: transfer to non ERC721Receiver implementer"); } else { /// @solidity memory-safe-assembly assembly { revert(add(32, reason), mload(reason)) } } } } else { return true; } } /** * @dev Hook that is called before any token transfer. This includes minting and burning. If {ERC721Consecutive} is * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1. * * Calling conditions: * * - When `from` and `to` are both non-zero, ``from``'s tokens will be transferred to `to`. * - When `from` is zero, the tokens will be minted for `to`. * - When `to` is zero, ``from``'s tokens will be burned. * - `from` and `to` are never both zero. * - `batchSize` is non-zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize) internal virtual {} /** * @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; } } // File: @openzeppelin/contracts/access/Ownable.sol // OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol) pragma solidity ^0.8.0; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor() { _transferOwnership(_msgSender()); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { require(owner() == _msgSender(), "Ownable: caller is not the owner"); } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby disabling any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } } // File: contracts/FellowshipDailyArtCollection.sol // Copyright (c) 2022-2023 Fellowship pragma solidity ^0.8.17; /// @title Token Base /// @notice Shared logic for token contracts contract FellowshipDailyArtCollection is ERC721, Ownable, RevokableDefaultOperatorFiltererUpgradeable { uint256 private immutable MAX_SUPPLY; address public royaltyReceiver; address public minter; address public metadataContract; uint256 public royaltyFraction; uint256 public royaltyDenominator = 100; /// @notice Count of valid NFTs tracked by this contract uint256 public totalSupply; /// @notice Return the baseURI used for computing `tokenURI` values string public baseURI; error OnlyMinter(); /// @dev This event emits when the metadata of a token is changed. Anyone aware of ERC-4906 can update cached /// attributes related to a given `tokenId`. event MetadataUpdate(uint256 tokenId); /// @dev This event emits when the metadata of a range of tokens is changed. Anyone aware of ERC-4906 can update /// cached attributes for tokens in the designated range. event BatchMetadataUpdate(uint256 fromTokenId, uint256 toTokenId); constructor( string memory name, string memory symbol, string memory baseURI_, uint256 maxSupply, address royaltyReceiver_, uint256 royaltyPercent ) ERC721(name, symbol) { // CHECKS inputs require(maxSupply > 0, "Max supply must not be zero"); require(royaltyReceiver_ != address(0), "Royalty receiver must not be the zero address"); require(royaltyPercent <= 100, "Royalty fraction must not be greater than 100%"); // EFFECTS MAX_SUPPLY = maxSupply; baseURI = baseURI_; royaltyReceiver = royaltyReceiver_; royaltyFraction = royaltyPercent; } modifier onlyMinter() { if (msg.sender != minter) revert OnlyMinter(); _; } /// @inheritdoc Ownable function owner() public view virtual override(Ownable, RevokableOperatorFiltererUpgradeable) returns (address) { return Ownable.owner(); } // MINTER FUNCTIONS /// @notice Mint an unclaimed token to the given address /// @dev Can only be called by the `minter` address /// @param to The new token owner that will receive the minted token /// @param tokenId The token being claimed. Reverts if invalid or already claimed. function mint(address to, uint256 tokenId) external onlyMinter { // CHECKS inputs require(tokenId > 0 && tokenId <= MAX_SUPPLY, "Invalid token ID"); // CHECKS + EFFECTS (not _safeMint, so no interactions) _mint(to, tokenId); // More EFFECTS unchecked { totalSupply++; } } // ERC721 OVERRIDES /// @inheritdoc ERC721 function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) { super.setApprovalForAll(operator, approved); } /// @inheritdoc ERC721 function approve(address operator, uint256 tokenId) public override onlyAllowedOperatorApproval(operator) { super.approve(operator, tokenId); } /// @inheritdoc ERC721 function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) { super.transferFrom(from, to, tokenId); } /// @inheritdoc ERC721 function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) { super.safeTransferFrom(from, to, tokenId); } /// @inheritdoc ERC721 function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public override onlyAllowedOperator(from) { super.safeTransferFrom(from, to, tokenId, data); } // OWNER FUNCTIONS /// @notice Set the `minter` address /// @dev Can only be called by the contract `owner` function setMinter(address minter_) external onlyOwner { minter = minter_; } /// @notice Set the `royaltyReceiver` address /// @dev Can only be called by the contract `owner` function setRoyaltyReceiver(address royaltyReceiver_) external onlyOwner { // CHECKS inputs require(royaltyReceiver_ != address(0), "Royalty receiver must not be the zero address"); // EFFECTS royaltyReceiver = royaltyReceiver_; } /// @notice Update the royalty fraction /// @dev Can only be called by the contract `owner` function setRoyaltyFraction(uint256 royaltyFraction_, uint256 royaltyDenominator_) external onlyOwner { // CHECKS inputss require(royaltyDenominator_ != 0, "Royalty denominator must not be zero"); require(royaltyFraction_ <= royaltyDenominator_, "Royalty fraction must not be greater than 100%"); // EFFECTS royaltyFraction = royaltyFraction_; royaltyDenominator = royaltyDenominator_; } /// @notice Update the baseURI for all metadata /// @dev Can only be called by the contract `owner`. Emits an ERC-4906 event. /// @param baseURI_ The new URI base. When specified, token URIs are created by concatenating the baseURI, /// token ID, and ".json". function updateBaseURI(string calldata baseURI_) external onlyOwner { // CHECKS inputs require(bytes(baseURI_).length > 0, "New base URI must be provided"); // EFFECTS baseURI = baseURI_; metadataContract = address(0); emit BatchMetadataUpdate(1, MAX_SUPPLY); } /// @notice Delegate all `tokenURI` calls to another contract /// @dev Can only be called by the contract `owner`. Emits an ERC-4906 event. /// @param delegate The contract that will handle `tokenURI` responses function delegateTokenURIs(address delegate) external onlyOwner { // CHECKS inputs require(delegate != address(0), "New metadata delegate must not be the zero address"); require(delegate.code.length > 0, "New metadata delegate must be a contract"); // EFFECTS baseURI = ""; metadataContract = delegate; emit BatchMetadataUpdate(1, MAX_SUPPLY); } // VIEW FUNCTIONS /// @notice The URI for the given token /// @dev Throws if `tokenId` is not valid or has not been minted function tokenURI(uint256 tokenId) public view override returns (string memory) { _requireMinted(tokenId); if (bytes(baseURI).length > 0) { return string(abi.encodePacked(baseURI, Strings.toString(tokenId), ".json")); } if (address(metadataContract) != address(0)) { return IERC721Metadata(metadataContract).tokenURI(tokenId); } revert("tokenURI not configured"); } /// @notice Return whether the given tokenId has been minted yet function exists(uint256 tokenId) external view returns (bool) { return _exists(tokenId); } /// @notice Calculate how much royalty is owed and to whom /// @param salePrice - the sale price of the NFT asset /// @return receiver - address of where the royalty payment should be sent /// @return royaltyAmount - the royalty payment amount for salePrice function royaltyInfo(uint256, uint256 salePrice) external view returns (address receiver, uint256 royaltyAmount) { receiver = royaltyReceiver; // Use OpenZeppelin math utils for full precision multiply and divide without overflow royaltyAmount = Math.mulDiv(salePrice, royaltyFraction, royaltyDenominator, Math.Rounding.Up); } /// @notice Query if a contract implements an interface /// @dev Interface identification is specified in ERC-165. This function uses less than 30,000 gas. /// @param interfaceId The interface identifier, as specified in ERC-165 /// @return `true` if the contract implements `interfaceID` and `interfaceID` is not 0xffffffff, `false` otherwise function supportsInterface(bytes4 interfaceId) public pure virtual override returns (bool) { return interfaceId == 0x80ac58cd || // ERC-721 Non-Fungible Token Standard interfaceId == 0x5b5e139f || // ERC-721 Non-Fungible Token Standard - metadata extension interfaceId == 0x2a55205a || // ERC-2981 NFT Royalty Standard interfaceId == 0x49064906 || // ERC-4906 Metadata Update Extension interfaceId == 0x7f5828d0 || // ERC-173 Contract Ownership Standard interfaceId == 0x01ffc9a7; // ERC-165 Standard Interface Detection } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"string","name":"baseURI_","type":"string"},{"internalType":"uint256","name":"maxSupply","type":"uint256"},{"internalType":"address","name":"royaltyReceiver_","type":"address"},{"internalType":"uint256","name":"royaltyPercent","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AlreadyRevoked","type":"error"},{"inputs":[],"name":"OnlyMinter","type":"error"},{"inputs":[],"name":"OnlyOwner","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"OperatorNotAllowed","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"fromTokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"toTokenId","type":"uint256"}],"name":"BatchMetadataUpdate","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"version","type":"uint8"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"MetadataUpdate","type":"event"},{"anonymous":false,"inputs":[],"name":"OperatorFilterRegistryRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"operator","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":"address","name":"delegate","type":"address"}],"name":"delegateTokenURIs","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"exists","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isOperatorFilterRegistryRevoked","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"metadataContract","outputs":[{"internalType":"address","name":"","type":"address"}],"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":[],"name":"minter","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"revokeOperatorFilterRegistry","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"royaltyDenominator","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"royaltyFraction","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"salePrice","type":"uint256"}],"name":"royaltyInfo","outputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint256","name":"royaltyAmount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"royaltyReceiver","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","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":"minter_","type":"address"}],"name":"setMinter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"royaltyFraction_","type":"uint256"},{"internalType":"uint256","name":"royaltyDenominator_","type":"uint256"}],"name":"setRoyaltyFraction","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"royaltyReceiver_","type":"address"}],"name":"setRoyaltyReceiver","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","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":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseURI_","type":"string"}],"name":"updateBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
00000000000000000000000000000000000000000000000000000000000000c00000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000014000000000000000000000000000000000000000000000000001e7357fe892b5f10000000000000000000000005308545d3ca57d051e1cfa56e9e1a330c2933d79000000000000000000000000000000000000000000000000000000000000000500000000000000000000000000000000000000000000000000000000000000094441494c592e58595a000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000054441494c5900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000027878000000000000000000000000000000000000000000000000000000000000
-----Decoded View---------------
Arg [0] : name (string): DAILY.XYZ
Arg [1] : symbol (string): DAILY
Arg [2] : baseURI_ (string): xx
Arg [3] : maxSupply (uint256): 137137137137137137
Arg [4] : royaltyReceiver_ (address): 0x5308545D3CA57D051E1cFa56e9E1a330c2933d79
Arg [5] : royaltyPercent (uint256): 5
-----Encoded View---------------
12 Constructor Arguments found :
Arg [0] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000100
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000140
Arg [3] : 00000000000000000000000000000000000000000000000001e7357fe892b5f1
Arg [4] : 0000000000000000000000005308545d3ca57d051e1cfa56e9e1a330c2933d79
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000009
Arg [7] : 4441494c592e58595a0000000000000000000000000000000000000000000000
Arg [8] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [9] : 4441494c59000000000000000000000000000000000000000000000000000000
Arg [10] : 0000000000000000000000000000000000000000000000000000000000000002
Arg [11] : 7878000000000000000000000000000000000000000000000000000000000000
Deployed Bytecode Sourcemap
88466:8643:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;96492:614;;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;96492:614:0;;;;;;;;70643:100;;;:::i;:::-;;;;;;;:::i;88658:21::-;;;;;-1:-1:-1;;;;;88658:21:0;;;;;;-1:-1:-1;;;;;1512:32:1;;;1494:51;;1482:2;1467:18;88658:21:0;1348:203:1;72155:171:0;;;;;;:::i;:::-;;:::i;91433:157::-;;;;;;:::i;:::-;;:::i;:::-;;94273:417;;;;;;:::i;:::-;;:::i;88873:26::-;;;;;;;;;2515:25:1;;;2503:2;2488:18;88873:26:0;2369:177:1;91626:163:0;;;;;;:::i;:::-;;:::i;95762:358::-;;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;3329:32:1;;;3311:51;;3393:2;3378:18;;3371:34;;;;3284:18;95762:358:0;3137:274:1;88686:31:0;;;;;-1:-1:-1;;;;;88686:31:0;;;90806:352;;;;;;:::i;:::-;;:::i;91825:171::-;;;;;;:::i;:::-;;:::i;95372:104::-;;;;;;:::i;:::-;;:::i;29839:440::-;;;:::i;70353:223::-;;;;;;:::i;:::-;;:::i;88981:21::-;;;:::i;70084:207::-;;;;;;:::i;:::-;;:::i;87444:103::-;;;:::i;90338:152::-;;;:::i;92599:271::-;;;;;;:::i;:::-;;:::i;93715:324::-;;;;;;:::i;:::-;;:::i;70812:104::-;;;:::i;88621:30::-;;;;;-1:-1:-1;;;;;88621:30:0;;;91221:176;;;;;;:::i;:::-;;:::i;92032:228::-;;;;;;:::i;:::-;;:::i;94838:456::-;;;;;;:::i;:::-;;:::i;88726:30::-;;;;;;72624:164;;;;;;:::i;:::-;;:::i;30287:181::-;-1:-1:-1;;;;;;;;;;;30375:85:0;;;30287:181;;92980:446;;;;;;:::i;:::-;;:::i;87702:201::-;;;;;;:::i;:::-;;:::i;92393:90::-;;;;;;:::i;:::-;;:::i;88763:39::-;;;;;;96492:614;96577:4;-1:-1:-1;;;;;;;;;96614:25:0;;;;:106;;-1:-1:-1;;;;;;;;;;96695:25:0;;;96614:106;:208;;;-1:-1:-1;;;;;;;;;;96797:25:0;;;96614:208;:283;;;-1:-1:-1;;;;;;;;;;96872:25:0;;;96614:283;:363;;;-1:-1:-1;;;;;;;;;;96952:25:0;;;96614:363;:444;;;-1:-1:-1;;;;;;;;;;97033:25:0;;;96614:444;96594:464;96492:614;-1:-1:-1;;96492:614:0:o;70643:100::-;70697:13;70730:5;70723:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;70643:100;:::o;72155:171::-;72231:7;72251:23;72266:7;72251:14;:23::i;:::-;-1:-1:-1;72294:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;72294:24:0;;72155:171::o;91433:157::-;91529:8;26019:30;26040:8;26019:20;:30::i;:::-;91550:32:::1;91564:8;91574:7;91550:13;:32::i;:::-;91433:157:::0;;;:::o;94273:417::-;86689:13;:11;:13::i;:::-;-1:-1:-1;;;;;94382:22:0;::::1;94374:85;;;::::0;-1:-1:-1;;;94374:85:0;;6804:2:1;94374:85:0::1;::::0;::::1;6786:21:1::0;6843:2;6823:18;;;6816:30;6882:34;6862:18;;;6855:62;-1:-1:-1;;;6933:18:1;;;6926:48;6991:19;;94374:85:0::1;;;;;;;;;94501:1;94478:8;-1:-1:-1::0;;;;;94478:20:0::1;;:24;94470:77;;;::::0;-1:-1:-1;;;94470:77:0;;7223:2:1;94470:77:0::1;::::0;::::1;7205:21:1::0;7262:2;7242:18;;;7235:30;7301:34;7281:18;;;7274:62;-1:-1:-1;;;7352:18:1;;;7345:38;7400:19;;94470:77:0::1;7021:404:1::0;94470:77:0::1;94580:12;::::0;;::::1;::::0;::::1;::::0;;;-1:-1:-1;94580:12:0;;:7:::1;::::0;:12:::1;::::0;:7;:12:::1;:::i;:::-;-1:-1:-1::0;94603:16:0::1;:27:::0;;-1:-1:-1;;;;;;94603:27:0::1;-1:-1:-1::0;;;;;94603:27:0;::::1;;::::0;;94648:34:::1;::::0;;-1:-1:-1;9816:25:1;;94671:10:0::1;9872:2:1::0;9857:18;;9850:34;94648::0::1;::::0;9789:18:1;94648:34:0::1;;;;;;;94273:417:::0;:::o;91626:163::-;91727:4;-1:-1:-1;;;;;25744:18:0;;25752:10;25744:18;25740:83;;25779:32;25800:10;25779:20;:32::i;:::-;91744:37:::1;91763:4;91769:2;91773:7;91744:18;:37::i;:::-;91626:163:::0;;;;:::o;95762:358::-;95897:15;;96058;;96075:18;;-1:-1:-1;;;;;95897:15:0;;;;95834:16;;96035:77;;96047:9;;96058:15;95897;96035:11;:77::i;:::-;96019:93;;95762:358;;;;;:::o;90806:352::-;90254:6;;-1:-1:-1;;;;;90254:6:0;90240:10;:20;90236:45;;90269:12;;-1:-1:-1;;;90269:12:0;;;;;;;;;;;90236:45;90924:1:::1;90914:7;:11;:36;;;;;90940:10;90929:7;:21;;90914:36;90906:65;;;::::0;-1:-1:-1;;;90906:65:0;;10097:2:1;90906:65:0::1;::::0;::::1;10079:21:1::0;10136:2;10116:18;;;10109:30;-1:-1:-1;;;10155:18:1;;;10148:46;10211:18;;90906:65:0::1;9895:340:1::0;90906:65:0::1;91047:18;91053:2;91057:7;91047:5;:18::i;:::-;-1:-1:-1::0;;91126:11:0::1;:13:::0;;::::1;;::::0;;90806:352::o;91825:171::-;91930:4;-1:-1:-1;;;;;25744:18:0;;25752:10;25744:18;25740:83;;25779:32;25800:10;25779:20;:32::i;:::-;91947:41:::1;91970:4;91976:2;91980:7;91947:22;:41::i;95372:104::-:0;95428:4;75086:16;;;:7;:16;;;;;;-1:-1:-1;;;;;75086:16:0;75512:31;;95452:16;75423:128;29839:440;29917:7;:5;:7::i;:::-;-1:-1:-1;;;;;29903:21:0;:10;-1:-1:-1;;;;;29903:21:0;;29899:72;;29948:11;;-1:-1:-1;;;29948:11:0;;;;;;;;;;;29899:72;-1:-1:-1;;;;;;;;;;;29985:85:0;;;29981:141;;;30094:16;;-1:-1:-1;;;30094:16:0;;;;;;;;;;;29981:141;-1:-1:-1;;;;;;;;;;;30132:92:0;;-1:-1:-1;;30132:92:0;30220:4;30132:92;;;30240:31;;;;30132:92;;30240:31;29839:440::o;70353:223::-;70425:7;75086:16;;;:7;:16;;;;;;-1:-1:-1;;;;;75086:16:0;;70489:56;;;;-1:-1:-1;;;70489:56:0;;10442:2:1;70489:56:0;;;10424:21:1;10481:2;10461:18;;;10454:30;-1:-1:-1;;;10500:18:1;;;10493:54;10564:18;;70489:56:0;10240:348:1;88981:21:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;70084:207::-;70156:7;-1:-1:-1;;;;;70184:19:0;;70176:73;;;;-1:-1:-1;;;70176:73:0;;10795:2:1;70176:73:0;;;10777:21:1;10834:2;10814:18;;;10807:30;10873:34;10853:18;;;10846:62;-1:-1:-1;;;10924:18:1;;;10917:39;10973:19;;70176:73:0;10593:405:1;70176:73:0;-1:-1:-1;;;;;;70267:16:0;;;;;:9;:16;;;;;;;70084:207::o;87444:103::-;86689:13;:11;:13::i;:::-;87509:30:::1;87536:1;87509:18;:30::i;:::-;87444:103::o:0;90338:152::-;90440:7;90467:15;86876:6;;-1:-1:-1;;;;;86876:6:0;;86803:87;90467:15;90460:22;;90338:152;:::o;92599:271::-;86689:13;:11;:13::i;:::-;-1:-1:-1;;;;;92717:30:0;::::1;92709:88;;;::::0;-1:-1:-1;;;92709:88:0;;11205:2:1;92709:88:0::1;::::0;::::1;11187:21:1::0;11244:2;11224:18;;;11217:30;11283:34;11263:18;;;11256:62;-1:-1:-1;;;11334:18:1;;;11327:43;11387:19;;92709:88:0::1;11003:409:1::0;92709:88:0::1;92828:15;:34:::0;;-1:-1:-1;;;;;;92828:34:0::1;-1:-1:-1::0;;;;;92828:34:0;;;::::1;::::0;;;::::1;::::0;;92599:271::o;93715:324::-;86689:13;:11;:13::i;:::-;93828:26;93820:68:::1;;;::::0;-1:-1:-1;;;93820:68:0;;11619:2:1;93820:68:0::1;::::0;::::1;11601:21:1::0;11658:2;11638:18;;;11631:30;11697:31;11677:18;;;11670:59;11746:18;;93820:68:0::1;11417:353:1::0;93820:68:0::1;93921:7;:18;93931:8:::0;;93921:7;:18:::1;:::i;:::-;-1:-1:-1::0;93950:16:0::1;:29:::0;;-1:-1:-1;;;;;;93950:29:0::1;::::0;;93997:34:::1;::::0;;-1:-1:-1;9816:25:1;;94020:10:0::1;9872:2:1::0;9857:18;;9850:34;93997::0::1;::::0;9789:18:1;93997:34:0::1;;;;;;;93715:324:::0;;:::o;70812:104::-;70868:13;70901:7;70894:14;;;;;:::i;91221:176::-;91325:8;26019:30;26040:8;26019:20;:30::i;:::-;91346:43:::1;91370:8;91380;91346:23;:43::i;92032:228::-:0;92183:4;-1:-1:-1;;;;;25744:18:0;;25752:10;25744:18;25740:83;;25779:32;25800:10;25779:20;:32::i;:::-;92205:47:::1;92228:4;92234:2;92238:7;92247:4;92205:22;:47::i;:::-;92032:228:::0;;;;;:::o;94838:456::-;94903:13;94929:23;94944:7;94929:14;:23::i;:::-;94993:1;94975:7;94969:21;;;;;:::i;:::-;;;:25;94965:134;;;95042:7;95051:25;95068:7;95051:16;:25::i;:::-;95025:61;;;;;;;;;:::i;:::-;;;;;;;;;;;;;95011:76;;94838:456;;;:::o;94965:134::-;95123:16;;-1:-1:-1;;;;;95123:16:0;95115:39;95111:130;;95194:16;;95178:51;;-1:-1:-1;;;95178:51:0;;;;;2515:25:1;;;-1:-1:-1;;;;;95194:16:0;;;;95178:42;;2488:18:1;;95178:51:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;95178:51:0;;;;;;;;;;;;:::i;95111:130::-;95253:33;;-1:-1:-1;;;95253:33:0;;15033:2:1;95253:33:0;;;15015:21:1;15072:2;15052:18;;;15045:30;15111:25;15091:18;;;15084:53;15154:18;;95253:33:0;14831:347:1;72624:164:0;-1:-1:-1;;;;;72745:25:0;;;72721:4;72745:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;72624:164::o;92980:446::-;86689:13;:11;:13::i;:::-;93128:19:::1;93151:1;93128:24:::0;93120:73:::1;;;::::0;-1:-1:-1;;;93120:73:0;;15385:2:1;93120:73:0::1;::::0;::::1;15367:21:1::0;15424:2;15404:18;;;15397:30;15463:34;15443:18;;;15436:62;-1:-1:-1;;;15514:18:1;;;15507:34;15558:19;;93120:73:0::1;15183:400:1::0;93120:73:0::1;93232:19;93212:16;:39;;93204:98;;;::::0;-1:-1:-1;;;93204:98:0;;15790:2:1;93204:98:0::1;::::0;::::1;15772:21:1::0;15829:2;15809:18;;;15802:30;15868:34;15848:18;;;15841:62;-1:-1:-1;;;15919:18:1;;;15912:44;15973:19;;93204:98:0::1;15588:410:1::0;93204:98:0::1;93333:15;:34:::0;;;;93378:18:::1;:40:::0;92980:446::o;87702:201::-;86689:13;:11;:13::i;:::-;-1:-1:-1;;;;;87791:22:0;::::1;87783:73;;;::::0;-1:-1:-1;;;87783:73:0;;16205:2:1;87783:73:0::1;::::0;::::1;16187:21:1::0;16244:2;16224:18;;;16217:30;16283:34;16263:18;;;16256:62;-1:-1:-1;;;16334:18:1;;;16327:36;16380:19;;87783:73:0::1;16003:402:1::0;87783:73:0::1;87867:28;87886:8;87867:18;:28::i;:::-;87702:201:::0;:::o;92393:90::-;86689:13;:11;:13::i;:::-;92459:6:::1;:16:::0;;-1:-1:-1;;;;;;92459:16:0::1;-1:-1:-1::0;;;;;92459:16:0;;;::::1;::::0;;;::::1;::::0;;92393:90::o;81718:135::-;75488:4;75086:16;;;:7;:16;;;;;;-1:-1:-1;;;;;75086:16:0;81792:53;;;;-1:-1:-1;;;81792:53:0;;10442:2:1;81792:53:0;;;10424:21:1;10481:2;10461:18;;;10454:30;-1:-1:-1;;;10500:18:1;;;10493:54;10564:18;;81792:53:0;10240:348:1;28921:815:0;-1:-1:-1;;;;;;;;;;;29136:85:0;;;29135:86;:156;;;;-1:-1:-1;24113:42:0;29242:45;:49;;29135:156;29117:612;;;29579:67;;-1:-1:-1;;;29579:67:0;;29630:4;29579:67;;;16622:34:1;-1:-1:-1;;;;;16692:15:1;;16672:18;;;16665:43;24113:42:0;;29579;;16557:18:1;;29579:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;29574:144;;29674:28;;-1:-1:-1;;;29674:28:0;;-1:-1:-1;;;;;1512:32:1;;29674:28:0;;;1494:51:1;1467:18;;29674:28:0;1348:203:1;71673:416:0;71754:13;71770:23;71785:7;71770:14;:23::i;:::-;71754:39;;71818:5;-1:-1:-1;;;;;71812:11:0;:2;-1:-1:-1;;;;;71812:11:0;;71804:57;;;;-1:-1:-1;;;71804:57:0;;17171:2:1;71804:57:0;;;17153:21:1;17210:2;17190:18;;;17183:30;17249:34;17229:18;;;17222:62;-1:-1:-1;;;17300:18:1;;;17293:31;17341:19;;71804:57:0;16969:397:1;71804:57:0;68174:10;-1:-1:-1;;;;;71896:21:0;;;;:62;;-1:-1:-1;71921:37:0;71938:5;68174:10;72624:164;:::i;71921:37::-;71874:173;;;;-1:-1:-1;;;71874:173:0;;17573:2:1;71874:173:0;;;17555:21:1;17612:2;17592:18;;;17585:30;17651:34;17631:18;;;17624:62;17722:31;17702:18;;;17695:59;17771:19;;71874:173:0;17371:425:1;71874:173:0;72060:21;72069:2;72073:7;72060:8;:21::i;86968:132::-;68174:10;87032:7;:5;:7::i;:::-;-1:-1:-1;;;;;87032:23:0;;87024:68;;;;-1:-1:-1;;;87024:68:0;;18003:2:1;87024:68:0;;;17985:21:1;;;18022:18;;;18015:30;18081:34;18061:18;;;18054:62;18133:18;;87024:68:0;17801:356:1;72855:301:0;73016:41;68174:10;73049:7;73016:18;:41::i;:::-;73008:99;;;;-1:-1:-1;;;73008:99:0;;;;;;;:::i;:::-;73120:28;73130:4;73136:2;73140:7;73120:9;:28::i;39169:305::-;39270:7;39290:14;39307:25;39314:1;39317;39320:11;39307:6;:25::i;:::-;39290:42;-1:-1:-1;39359:11:0;39347:8;:23;;;;;;;;:::i;:::-;;:56;;;;;39402:1;39387:11;39374:25;;;;;:::i;:::-;39384:1;39381;39374:25;:29;39347:56;39343:100;;;39420:11;39430:1;39420:11;;:::i;:::-;;;39343:100;39460:6;-1:-1:-1;39169:305:0;;;;;;;:::o;77282:942::-;-1:-1:-1;;;;;77362:16:0;;77354:61;;;;-1:-1:-1;;;77354:61:0;;19269:2:1;77354:61:0;;;19251:21:1;;;19288:18;;;19281:30;19347:34;19327:18;;;19320:62;19399:18;;77354:61:0;19067:356:1;77354:61:0;75488:4;75086:16;;;:7;:16;;;;;;-1:-1:-1;;;;;75086:16:0;75512:31;77426:58;;;;-1:-1:-1;;;77426:58:0;;19630:2:1;77426:58:0;;;19612:21:1;19669:2;19649:18;;;19642:30;19708;19688:18;;;19681:58;19756:18;;77426:58:0;19428:352:1;77426:58:0;75488:4;75086:16;;;:7;:16;;;;;;-1:-1:-1;;;;;75086:16:0;75512:31;77635:58;;;;-1:-1:-1;;;77635:58:0;;19630:2:1;77635:58:0;;;19612:21:1;19669:2;19649:18;;;19642:30;19708;19688:18;;;19681:58;19756:18;;77635:58:0;19428:352:1;77635:58:0;-1:-1:-1;;;;;78042:13:0;;;;;;:9;:13;;;;;;;;:18;;78059:1;78042:18;;;78084:16;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;78084:21:0;;;;;78123:33;78092:7;;78042:13;;78123:33;;78042:13;;78123:33;78169:47;77282:942;;:::o;73227:151::-;73331:39;73348:4;73354:2;73358:7;73331:39;;;;;;;;;;;;:16;:39::i;88063:191::-;88156:6;;;-1:-1:-1;;;;;88173:17:0;;;-1:-1:-1;;;;;;88173:17:0;;;;;;;88206:40;;88156:6;;;88173:17;88156:6;;88206:40;;88137:16;;88206:40;88126:128;88063:191;:::o;72398:155::-;72493:52;68174:10;72526:8;72536;72493:18;:52::i;73449:279::-;73580:41;68174:10;73613:7;73580:18;:41::i;:::-;73572:99;;;;-1:-1:-1;;;73572:99:0;;;;;;;:::i;:::-;73682:38;73696:4;73702:2;73706:7;73715:4;73682:13;:38::i;46575:716::-;46631:13;46682:14;46699:17;46710:5;46699:10;:17::i;:::-;46719:1;46699:21;46682:38;;46735:20;46769:6;46758:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;46758:18:0;-1:-1:-1;46735:41:0;-1:-1:-1;46900:28:0;;;46916:2;46900:28;46957:288;-1:-1:-1;;46989:5:0;-1:-1:-1;;;47126:2:0;47115:14;;47110:30;46989:5;47097:44;47187:2;47178:11;;;-1:-1:-1;47208:21:0;46957:288;47208:21;-1:-1:-1;47266:6:0;46575:716;-1:-1:-1;;;46575:716:0:o;81031:174::-;81106:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;81106:29:0;-1:-1:-1;;;;;81106:29:0;;;;;;;;:24;;81160:23;81106:24;81160:14;:23::i;:::-;-1:-1:-1;;;;;81151:46:0;;;;;;;;;;;81031:174;;:::o;75718:264::-;75811:4;75828:13;75844:23;75859:7;75844:14;:23::i;:::-;75828:39;;75897:5;-1:-1:-1;;;;;75886:16:0;:7;-1:-1:-1;;;;;75886:16:0;;:52;;;;75906:32;75923:5;75930:7;75906:16;:32::i;:::-;75886:87;;;;75966:7;-1:-1:-1;;;;;75942:31:0;:20;75954:7;75942:11;:20::i;:::-;-1:-1:-1;;;;;75942:31:0;;75878:96;75718:264;-1:-1:-1;;;;75718:264:0:o;79683:1229::-;79808:4;-1:-1:-1;;;;;79781:31:0;:23;79796:7;79781:14;:23::i;:::-;-1:-1:-1;;;;;79781:31:0;;79773:81;;;;-1:-1:-1;;;79773:81:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;79873:16:0;;79865:65;;;;-1:-1:-1;;;79865:65:0;;20393:2:1;79865:65:0;;;20375:21:1;20432:2;20412:18;;;20405:30;20471:34;20451:18;;;20444:62;-1:-1:-1;;;20522:18:1;;;20515:34;20566:19;;79865:65:0;20191:400:1;79865:65:0;80115:4;-1:-1:-1;;;;;80088:31:0;:23;80103:7;80088:14;:23::i;:::-;-1:-1:-1;;;;;80088:31:0;;80080:81;;;;-1:-1:-1;;;80080:81:0;;;;;;;:::i;:::-;80233:24;;;;:15;:24;;;;;;;;80226:31;;-1:-1:-1;;;;;;80226:31:0;;;;;;-1:-1:-1;;;;;80709:15:0;;;;;;:9;:15;;;;;:20;;-1:-1:-1;;80709:20:0;;;80744:13;;;;;;;;;:18;;80226:31;80744:18;;;80784:16;;;:7;:16;;;;;;:21;;;;;;;;;;80823:27;;80249:7;;80823:27;;;91433:157;;;:::o;34740:4292::-;34822:14;;;-1:-1:-1;;35367:1:0;35364;35357:20;35411:1;35408;35404:9;35395:18;;35467:5;35463:2;35460:13;35452:5;35448:2;35444:14;35440:34;35431:43;;;35573:5;35582:1;35573:10;35569:373;;35915:11;35907:5;:19;;;;;:::i;:::-;;35900:26;;;;;;35569:373;36069:5;36055:11;:19;36047:53;;;;-1:-1:-1;;;36047:53:0;;20798:2:1;36047:53:0;;;20780:21:1;20837:2;20817:18;;;20810:30;-1:-1:-1;;;20856:18:1;;;20849:51;20917:18;;36047:53:0;20596:345:1;36047:53:0;36363:17;36501:11;36498:1;36495;36488:25;37045:12;;37060:1;37045:16;;;37030:32;;37168:22;;;;;36666:21;;;37269:16;;;36618:20;;;;36607:32;;;37015:12;37419;;;37415:23;;;;37411:31;;;37535:12;;;;37526:21;;;;37889:1;:15;;37908:1;37888:21;;;38145;;;38141:25;;38130:36;38215:21;;;38211:25;;38200:36;38286:21;;;38282:25;;38271:36;38357:21;;;38353:25;;38342:36;38428:21;;;38424:25;;38413:36;38500:21;;;38496:25;;;38485:36;38970:15;;-1:-1:-1;;34740:4292:0;;;;;;:::o;81348:281::-;81469:8;-1:-1:-1;;;;;81460:17:0;:5;-1:-1:-1;;;;;81460:17:0;;81452:55;;;;-1:-1:-1;;;81452:55:0;;21148:2:1;81452:55:0;;;21130:21:1;21187:2;21167:18;;;21160:30;21226:27;21206:18;;;21199:55;21271:18;;81452:55:0;20946:349:1;81452:55:0;-1:-1:-1;;;;;81518:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;81518:46:0;;;;;;;;;;81580:41;;540::1;;;81580::0;;513:18:1;81580:41:0;;;;;;;81348:281;;;:::o;74609:270::-;74722:28;74732:4;74738:2;74742:7;74722:9;:28::i;:::-;74769:47;74792:4;74798:2;74802:7;74811:4;74769:22;:47::i;:::-;74761:110;;;;-1:-1:-1;;;74761:110:0;;;;;;;:::i;43409:948::-;43462:7;;-1:-1:-1;;;43540:17:0;;43536:106;;-1:-1:-1;;;43578:17:0;;;-1:-1:-1;43624:2:0;43614:12;43536:106;43669:8;43660:5;:17;43656:106;;43707:8;43698:17;;;-1:-1:-1;43744:2:0;43734:12;43656:106;43789:8;43780:5;:17;43776:106;;43827:8;43818:17;;;-1:-1:-1;43864:2:0;43854:12;43776:106;43909:7;43900:5;:16;43896:103;;43946:7;43937:16;;;-1:-1:-1;43982:1:0;43972:11;43896:103;44026:7;44017:5;:16;44013:103;;44063:7;44054:16;;;-1:-1:-1;44099:1:0;44089:11;44013:103;44143:7;44134:5;:16;44130:103;;44180:7;44171:16;;;-1:-1:-1;44216:1:0;44206:11;44130:103;44260:7;44251:5;:16;44247:68;;44298:1;44288:11;44343:6;43409:948;-1:-1:-1;;43409:948:0:o;82417:853::-;82571:4;-1:-1:-1;;;;;82592:13:0;;50746:19;:23;82588:675;;82628:71;;-1:-1:-1;;;82628:71:0;;-1:-1:-1;;;;;82628:36:0;;;;;:71;;68174:10;;82679:4;;82685:7;;82694:4;;82628:71;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;82628:71:0;;;;;;;;-1:-1:-1;;82628:71:0;;;;;;;;;;;;:::i;:::-;;;82624:584;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;82869:6;:13;82886:1;82869:18;82865:328;;82912:60;;-1:-1:-1;;;82912:60:0;;;;;;;:::i;82865:328::-;83143:6;83137:13;83128:6;83124:2;83120:15;83113:38;82624:584;-1:-1:-1;;;;;;82750:51:0;-1:-1:-1;;;82750:51:0;;-1:-1:-1;82743:58:0;;82588:675;-1:-1:-1;83247:4:0;83240:11;;14:131:1;-1:-1:-1;;;;;;88:32:1;;78:43;;68:71;;135:1;132;125:12;150:245;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;592:250::-;677:1;687:113;701:6;698:1;695:13;687:113;;;777:11;;;771:18;758:11;;;751:39;723:2;716:10;687:113;;;-1:-1:-1;;834:1:1;816:16;;809:27;592:250::o;847:271::-;889:3;927:5;921:12;954:6;949:3;942:19;970:76;1039:6;1032:4;1027:3;1023:14;1016:4;1009:5;1005:16;970:76;:::i;:::-;1100:2;1079:15;-1:-1:-1;;1075:29:1;1066:39;;;;1107:4;1062:50;;847:271;-1:-1:-1;;847:271:1:o;1123:220::-;1272:2;1261:9;1254:21;1235:4;1292:45;1333:2;1322:9;1318:18;1310:6;1292:45;:::i;1556:180::-;1615:6;1668:2;1656:9;1647:7;1643:23;1639:32;1636:52;;;1684:1;1681;1674:12;1636:52;-1:-1:-1;1707:23:1;;1556:180;-1:-1:-1;1556:180:1:o;1741:173::-;1809:20;;-1:-1:-1;;;;;1858:31:1;;1848:42;;1838:70;;1904:1;1901;1894:12;1838:70;1741:173;;;:::o;1919:254::-;1987:6;1995;2048:2;2036:9;2027:7;2023:23;2019:32;2016:52;;;2064:1;2061;2054:12;2016:52;2087:29;2106:9;2087:29;:::i;:::-;2077:39;2163:2;2148:18;;;;2135:32;;-1:-1:-1;;;1919:254:1:o;2178:186::-;2237:6;2290:2;2278:9;2269:7;2265:23;2261:32;2258:52;;;2306:1;2303;2296:12;2258:52;2329:29;2348:9;2329:29;:::i;2551:328::-;2628:6;2636;2644;2697:2;2685:9;2676:7;2672:23;2668:32;2665:52;;;2713:1;2710;2703:12;2665:52;2736:29;2755:9;2736:29;:::i;:::-;2726:39;;2784:38;2818:2;2807:9;2803:18;2784:38;:::i;:::-;2774:48;;2869:2;2858:9;2854:18;2841:32;2831:42;;2551:328;;;;;:::o;2884:248::-;2952:6;2960;3013:2;3001:9;2992:7;2988:23;2984:32;2981:52;;;3029:1;3026;3019:12;2981:52;-1:-1:-1;;3052:23:1;;;3122:2;3107:18;;;3094:32;;-1:-1:-1;2884:248:1:o;3416:592::-;3487:6;3495;3548:2;3536:9;3527:7;3523:23;3519:32;3516:52;;;3564:1;3561;3554:12;3516:52;3604:9;3591:23;3633:18;3674:2;3666:6;3663:14;3660:34;;;3690:1;3687;3680:12;3660:34;3728:6;3717:9;3713:22;3703:32;;3773:7;3766:4;3762:2;3758:13;3754:27;3744:55;;3795:1;3792;3785:12;3744:55;3835:2;3822:16;3861:2;3853:6;3850:14;3847:34;;;3877:1;3874;3867:12;3847:34;3922:7;3917:2;3908:6;3904:2;3900:15;3896:24;3893:37;3890:57;;;3943:1;3940;3933:12;3890:57;3974:2;3966:11;;;;;3996:6;;-1:-1:-1;3416:592:1;;-1:-1:-1;;;;3416:592:1:o;4013:118::-;4099:5;4092:13;4085:21;4078:5;4075:32;4065:60;;4121:1;4118;4111:12;4136:315;4201:6;4209;4262:2;4250:9;4241:7;4237:23;4233:32;4230:52;;;4278:1;4275;4268:12;4230:52;4301:29;4320:9;4301:29;:::i;:::-;4291:39;;4380:2;4369:9;4365:18;4352:32;4393:28;4415:5;4393:28;:::i;:::-;4440:5;4430:15;;;4136:315;;;;;:::o;4456:127::-;4517:10;4512:3;4508:20;4505:1;4498:31;4548:4;4545:1;4538:15;4572:4;4569:1;4562:15;4588:275;4659:2;4653:9;4724:2;4705:13;;-1:-1:-1;;4701:27:1;4689:40;;4759:18;4744:34;;4780:22;;;4741:62;4738:88;;;4806:18;;:::i;:::-;4842:2;4835:22;4588:275;;-1:-1:-1;4588:275:1:o;4868:186::-;4916:4;4949:18;4941:6;4938:30;4935:56;;;4971:18;;:::i;:::-;-1:-1:-1;5037:2:1;5016:15;-1:-1:-1;;5012:29:1;5043:4;5008:40;;4868:186::o;5059:888::-;5154:6;5162;5170;5178;5231:3;5219:9;5210:7;5206:23;5202:33;5199:53;;;5248:1;5245;5238:12;5199:53;5271:29;5290:9;5271:29;:::i;:::-;5261:39;;5319:38;5353:2;5342:9;5338:18;5319:38;:::i;:::-;5309:48;;5404:2;5393:9;5389:18;5376:32;5366:42;;5459:2;5448:9;5444:18;5431:32;5486:18;5478:6;5475:30;5472:50;;;5518:1;5515;5508:12;5472:50;5541:22;;5594:4;5586:13;;5582:27;-1:-1:-1;5572:55:1;;5623:1;5620;5613:12;5572:55;5659:2;5646:16;5684:48;5700:31;5728:2;5700:31;:::i;:::-;5684:48;:::i;:::-;5755:2;5748:5;5741:17;5795:7;5790:2;5785;5781;5777:11;5773:20;5770:33;5767:53;;;5816:1;5813;5806:12;5767:53;5871:2;5866;5862;5858:11;5853:2;5846:5;5842:14;5829:45;5915:1;5910:2;5905;5898:5;5894:14;5890:23;5883:34;5936:5;5926:15;;;;;5059:888;;;;;;;:::o;5952:260::-;6020:6;6028;6081:2;6069:9;6060:7;6056:23;6052:32;6049:52;;;6097:1;6094;6087:12;6049:52;6120:29;6139:9;6120:29;:::i;:::-;6110:39;;6168:38;6202:2;6191:9;6187:18;6168:38;:::i;6217:380::-;6296:1;6292:12;;;;6339;;;6360:61;;6414:4;6406:6;6402:17;6392:27;;6360:61;6467:2;6459:6;6456:14;6436:18;6433:38;6430:161;;6513:10;6508:3;6504:20;6501:1;6494:31;6548:4;6545:1;6538:15;6576:4;6573:1;6566:15;6430:161;;6217:380;;;:::o;7556:545::-;7658:2;7653:3;7650:11;7647:448;;;7694:1;7719:5;7715:2;7708:17;7764:4;7760:2;7750:19;7834:2;7822:10;7818:19;7815:1;7811:27;7805:4;7801:38;7870:4;7858:10;7855:20;7852:47;;;-1:-1:-1;7893:4:1;7852:47;7948:2;7943:3;7939:12;7936:1;7932:20;7926:4;7922:31;7912:41;;8003:82;8021:2;8014:5;8011:13;8003:82;;;8066:17;;;8047:1;8036:13;8003:82;;;8007:3;;;7556:545;;;:::o;8277:1352::-;8403:3;8397:10;8430:18;8422:6;8419:30;8416:56;;;8452:18;;:::i;:::-;8481:97;8571:6;8531:38;8563:4;8557:11;8531:38;:::i;:::-;8525:4;8481:97;:::i;:::-;8633:4;;8697:2;8686:14;;8714:1;8709:663;;;;9416:1;9433:6;9430:89;;;-1:-1:-1;9485:19:1;;;9479:26;9430:89;-1:-1:-1;;8234:1:1;8230:11;;;8226:24;8222:29;8212:40;8258:1;8254:11;;;8209:57;9532:81;;8679:944;;8709:663;7503:1;7496:14;;;7540:4;7527:18;;-1:-1:-1;;8745:20:1;;;8863:236;8877:7;8874:1;8871:14;8863:236;;;8966:19;;;8960:26;8945:42;;9058:27;;;;9026:1;9014:14;;;;8893:19;;8863:236;;;8867:3;9127:6;9118:7;9115:19;9112:201;;;9188:19;;;9182:26;-1:-1:-1;;9271:1:1;9267:14;;;9283:3;9263:24;9259:37;9255:42;9240:58;9225:74;;9112:201;-1:-1:-1;;;;;9359:1:1;9343:14;;;9339:22;9326:36;;-1:-1:-1;8277:1352:1:o;11775:1206::-;11899:18;11894:3;11891:27;11888:53;;;11921:18;;:::i;:::-;11950:94;12040:3;12000:38;12032:4;12026:11;12000:38;:::i;:::-;11994:4;11950:94;:::i;:::-;12070:1;12095:2;12090:3;12087:11;12112:1;12107:616;;;;12767:1;12784:3;12781:93;;;-1:-1:-1;12840:19:1;;;12827:33;12781:93;-1:-1:-1;;8234:1:1;8230:11;;;8226:24;8222:29;8212:40;8258:1;8254:11;;;8209:57;12887:78;;12080:895;;12107:616;7503:1;7496:14;;;7540:4;7527:18;;-1:-1:-1;;12143:17:1;;;12244:9;12266:229;12280:7;12277:1;12274:14;12266:229;;;12369:19;;;12356:33;12341:49;;12476:4;12461:20;;;;12429:1;12417:14;;;;12296:12;12266:229;;;12270:3;12523;12514:7;12511:16;12508:159;;;12647:1;12643:6;12637:3;12631;12628:1;12624:11;12620:21;12616:34;12612:39;12599:9;12594:3;12590:19;12577:33;12573:79;12565:6;12558:95;12508:159;;;12710:1;12704:3;12701:1;12697:11;12693:19;12687:4;12680:33;12080:895;;11775:1206;;;:::o;12986:1187::-;13263:3;13292:1;13325:6;13319:13;13355:36;13381:9;13355:36;:::i;:::-;13410:1;13427:18;;;13454:133;;;;13601:1;13596:356;;;;13420:532;;13454:133;-1:-1:-1;;13487:24:1;;13475:37;;13560:14;;13553:22;13541:35;;13532:45;;;-1:-1:-1;13454:133:1;;13596:356;13627:6;13624:1;13617:17;13657:4;13702:2;13699:1;13689:16;13727:1;13741:165;13755:6;13752:1;13749:13;13741:165;;;13833:14;;13820:11;;;13813:35;13876:16;;;;13770:10;;13741:165;;;13745:3;;;13935:6;13930:3;13926:16;13919:23;;13420:532;;;;;13983:6;13977:13;13999:68;14058:8;14053:3;14046:4;14038:6;14034:17;13999:68;:::i;:::-;-1:-1:-1;;;14089:18:1;;14116:22;;;14165:1;14154:13;;12986:1187;-1:-1:-1;;;;12986:1187:1:o;14178:648::-;14258:6;14311:2;14299:9;14290:7;14286:23;14282:32;14279:52;;;14327:1;14324;14317:12;14279:52;14360:9;14354:16;14393:18;14385:6;14382:30;14379:50;;;14425:1;14422;14415:12;14379:50;14448:22;;14501:4;14493:13;;14489:27;-1:-1:-1;14479:55:1;;14530:1;14527;14520:12;14479:55;14559:2;14553:9;14584:48;14600:31;14628:2;14600:31;:::i;14584:48::-;14655:2;14648:5;14641:17;14695:7;14690:2;14685;14681;14677:11;14673:20;14670:33;14667:53;;;14716:1;14713;14706:12;14667:53;14729:67;14793:2;14788;14781:5;14777:14;14772:2;14768;14764:11;14729:67;:::i;:::-;14815:5;14178:648;-1:-1:-1;;;;;14178:648:1:o;16719:245::-;16786:6;16839:2;16827:9;16818:7;16814:23;16810:32;16807:52;;;16855:1;16852;16845:12;16807:52;16887:9;16881:16;16906:28;16928:5;16906:28;:::i;18162:409::-;18364:2;18346:21;;;18403:2;18383:18;;;18376:30;18442:34;18437:2;18422:18;;18415:62;-1:-1:-1;;;18508:2:1;18493:18;;18486:43;18561:3;18546:19;;18162:409::o;18576:127::-;18637:10;18632:3;18628:20;18625:1;18618:31;18668:4;18665:1;18658:15;18692:4;18689:1;18682:15;18708:127;18769:10;18764:3;18760:20;18757:1;18750:31;18800:4;18797:1;18790:15;18824:4;18821:1;18814:15;18840:222;18905:9;;;18926:10;;;18923:133;;;18978:10;18973:3;18969:20;18966:1;18959:31;19013:4;19010:1;19003:15;19041:4;19038:1;19031:15;19785:401;19987:2;19969:21;;;20026:2;20006:18;;;19999:30;20065:34;20060:2;20045:18;;20038:62;-1:-1:-1;;;20131:2:1;20116:18;;20109:35;20176:3;20161:19;;19785:401::o;21300:414::-;21502:2;21484:21;;;21541:2;21521:18;;;21514:30;21580:34;21575:2;21560:18;;21553:62;-1:-1:-1;;;21646:2:1;21631:18;;21624:48;21704:3;21689:19;;21300:414::o;21719:489::-;-1:-1:-1;;;;;21988:15:1;;;21970:34;;22040:15;;22035:2;22020:18;;22013:43;22087:2;22072:18;;22065:34;;;22135:3;22130:2;22115:18;;22108:31;;;21913:4;;22156:46;;22182:19;;22174:6;22156:46;:::i;:::-;22148:54;21719:489;-1:-1:-1;;;;;;21719:489:1:o;22213:249::-;22282:6;22335:2;22323:9;22314:7;22310:23;22306:32;22303:52;;;22351:1;22348;22341:12;22303:52;22383:9;22377:16;22402:30;22426:5;22402:30;:::i
Swarm Source
ipfs://648565aa4cb84bb5632c96c4a7a52762d8dc18eff077920a56c560ae6caf5c83
Loading...
Loading
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.