Token
ERC-1155
Overview
Max Total Supply
0
Holders
2
Market
Onchain Market Cap
$0.00
Circulating Supply Market Cap
-
Other Info
Token Contract
Loading...
Loading
Loading...
Loading
Loading...
Loading
# | Exchange | Pair | Price | 24H Volume | % Volume |
---|
Contract Source Code Verified (Exact Match)
Contract Name:
QAA1155
Compiler Version
v0.8.23+commit.f704f362
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2023-11-23 */ // File: @openzeppelin/contracts/interfaces/draft-IERC6093.sol // OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol) pragma solidity ^0.8.20; /** * @dev Standard ERC20 Errors * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens. */ interface IERC20Errors { /** * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers. * @param sender Address whose tokens are being transferred. * @param balance Current balance for the interacting account. * @param needed Minimum amount required to perform a transfer. */ error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed); /** * @dev Indicates a failure with the token `sender`. Used in transfers. * @param sender Address whose tokens are being transferred. */ error ERC20InvalidSender(address sender); /** * @dev Indicates a failure with the token `receiver`. Used in transfers. * @param receiver Address to which tokens are being transferred. */ error ERC20InvalidReceiver(address receiver); /** * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers. * @param spender Address that may be allowed to operate on tokens without being their owner. * @param allowance Amount of tokens a `spender` is allowed to operate with. * @param needed Minimum amount required to perform a transfer. */ error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed); /** * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals. * @param approver Address initiating an approval operation. */ error ERC20InvalidApprover(address approver); /** * @dev Indicates a failure with the `spender` to be approved. Used in approvals. * @param spender Address that may be allowed to operate on tokens without being their owner. */ error ERC20InvalidSpender(address spender); } /** * @dev Standard ERC721 Errors * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC721 tokens. */ interface IERC721Errors { /** * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20. * Used in balance queries. * @param owner Address of the current owner of a token. */ error ERC721InvalidOwner(address owner); /** * @dev Indicates a `tokenId` whose `owner` is the zero address. * @param tokenId Identifier number of a token. */ error ERC721NonexistentToken(uint256 tokenId); /** * @dev Indicates an error related to the ownership over a particular token. Used in transfers. * @param sender Address whose tokens are being transferred. * @param tokenId Identifier number of a token. * @param owner Address of the current owner of a token. */ error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner); /** * @dev Indicates a failure with the token `sender`. Used in transfers. * @param sender Address whose tokens are being transferred. */ error ERC721InvalidSender(address sender); /** * @dev Indicates a failure with the token `receiver`. Used in transfers. * @param receiver Address to which tokens are being transferred. */ error ERC721InvalidReceiver(address receiver); /** * @dev Indicates a failure with the `operator`’s approval. Used in transfers. * @param operator Address that may be allowed to operate on tokens without being their owner. * @param tokenId Identifier number of a token. */ error ERC721InsufficientApproval(address operator, uint256 tokenId); /** * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals. * @param approver Address initiating an approval operation. */ error ERC721InvalidApprover(address approver); /** * @dev Indicates a failure with the `operator` to be approved. Used in approvals. * @param operator Address that may be allowed to operate on tokens without being their owner. */ error ERC721InvalidOperator(address operator); } /** * @dev Standard ERC1155 Errors * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC1155 tokens. */ interface IERC1155Errors { /** * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers. * @param sender Address whose tokens are being transferred. * @param balance Current balance for the interacting account. * @param needed Minimum amount required to perform a transfer. * @param tokenId Identifier number of a token. */ error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId); /** * @dev Indicates a failure with the token `sender`. Used in transfers. * @param sender Address whose tokens are being transferred. */ error ERC1155InvalidSender(address sender); /** * @dev Indicates a failure with the token `receiver`. Used in transfers. * @param receiver Address to which tokens are being transferred. */ error ERC1155InvalidReceiver(address receiver); /** * @dev Indicates a failure with the `operator`’s approval. Used in transfers. * @param operator Address that may be allowed to operate on tokens without being their owner. * @param owner Address of the current owner of a token. */ error ERC1155MissingApprovalForAll(address operator, address owner); /** * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals. * @param approver Address initiating an approval operation. */ error ERC1155InvalidApprover(address approver); /** * @dev Indicates a failure with the `operator` to be approved. Used in approvals. * @param operator Address that may be allowed to operate on tokens without being their owner. */ error ERC1155InvalidOperator(address operator); /** * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation. * Used in batch transfers. * @param idsLength Length of the array of token identifiers * @param valuesLength Length of the array of token amounts */ error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength); } // File: @openzeppelin/contracts/utils/math/Math.sol // OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol) pragma solidity ^0.8.20; /** * @dev Standard math utilities missing in the Solidity language. */ library Math { /** * @dev Muldiv operation overflow. */ error MathOverflowedMulDiv(); enum Rounding { Floor, // Toward negative infinity Ceil, // Toward positive infinity Trunc, // Toward zero Expand // Away from zero } /** * @dev Returns the addition of two unsigned integers, with an overflow flag. */ function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { uint256 c = a + b; if (c < a) return (false, 0); return (true, c); } } /** * @dev Returns the subtraction of two unsigned integers, with an overflow flag. */ function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b > a) return (false, 0); return (true, a - b); } } /** * @dev Returns the multiplication of two unsigned integers, with an overflow flag. */ function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) return (true, 0); uint256 c = a * b; if (c / a != b) return (false, 0); return (true, c); } } /** * @dev Returns the division of two unsigned integers, with a division by zero flag. */ function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a / b); } } /** * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag. */ function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a % b); } } /** * @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 towards infinity instead * of rounding towards zero. */ function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) { if (b == 0) { // Guarantee the same behavior as in a regular Solidity division. return a / b; } // (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 = x * y; // Least significant 256 bits of the product uint256 prod1; // Most significant 256 bits of the product assembly { let mm := mulmod(x, y, not(0)) 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. if (denominator <= prod1) { revert MathOverflowedMulDiv(); } /////////////////////////////////////////////// // 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. uint256 twos = denominator & (0 - denominator); 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 (unsignedRoundsUp(rounding) && 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 * towards zero. * * 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 + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0); } } /** * @dev Return the log in base 2 of a positive value rounded towards zero. * 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 + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0); } } /** * @dev Return the log in base 10 of a positive value rounded towards zero. * 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 + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0); } } /** * @dev Return the log in base 256 of a positive value rounded towards zero. * 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 + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0); } } /** * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers. */ function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) { return uint8(rounding) % 2 == 1; } } // File: @openzeppelin/contracts/utils/StorageSlot.sol // OpenZeppelin Contracts (last updated v5.0.0) (utils/StorageSlot.sol) // This file was procedurally generated from scripts/generate/templates/StorageSlot.js. pragma solidity ^0.8.20; /** * @dev Library for reading and writing primitive types to specific storage slots. * * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts. * This library helps with reading and writing to such slots without the need for inline assembly. * * The functions in this library return Slot structs that contain a `value` member that can be used to read or write. * * Example usage to set ERC1967 implementation slot: * ```solidity * contract ERC1967 { * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc; * * function _getImplementation() internal view returns (address) { * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value; * } * * function _setImplementation(address newImplementation) internal { * require(newImplementation.code.length > 0); * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation; * } * } * ``` */ library StorageSlot { struct AddressSlot { address value; } struct BooleanSlot { bool value; } struct Bytes32Slot { bytes32 value; } struct Uint256Slot { uint256 value; } struct StringSlot { string value; } struct BytesSlot { bytes value; } /** * @dev Returns an `AddressSlot` with member `value` located at `slot`. */ function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `BooleanSlot` with member `value` located at `slot`. */ function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `Bytes32Slot` with member `value` located at `slot`. */ function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `Uint256Slot` with member `value` located at `slot`. */ function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `StringSlot` with member `value` located at `slot`. */ function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `StringSlot` representation of the string storage pointer `store`. */ function getStringSlot(string storage store) internal pure returns (StringSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := store.slot } } /** * @dev Returns an `BytesSlot` with member `value` located at `slot`. */ function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`. */ function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := store.slot } } } // File: @openzeppelin/contracts/utils/Arrays.sol // OpenZeppelin Contracts (last updated v5.0.0) (utils/Arrays.sol) pragma solidity ^0.8.20; /** * @dev Collection of functions related to array types. */ library Arrays { using StorageSlot for bytes32; /** * @dev Searches a sorted `array` and returns the first index that contains * a value greater or equal to `element`. If no such index exists (i.e. all * values in the array are strictly less than `element`), the array length is * returned. Time complexity O(log n). * * `array` is expected to be sorted in ascending order, and to contain no * repeated elements. */ function findUpperBound(uint256[] storage array, uint256 element) internal view returns (uint256) { uint256 low = 0; uint256 high = array.length; if (high == 0) { return 0; } while (low < high) { uint256 mid = Math.average(low, high); // Note that mid will always be strictly less than high (i.e. it will be a valid array index) // because Math.average rounds towards zero (it does integer division with truncation). if (unsafeAccess(array, mid).value > element) { high = mid; } else { low = mid + 1; } } // At this point `low` is the exclusive upper bound. We will return the inclusive upper bound. if (low > 0 && unsafeAccess(array, low - 1).value == element) { return low - 1; } else { return low; } } /** * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check. * * WARNING: Only use if you are certain `pos` is lower than the array length. */ function unsafeAccess(address[] storage arr, uint256 pos) internal pure returns (StorageSlot.AddressSlot storage) { bytes32 slot; // We use assembly to calculate the storage slot of the element at index `pos` of the dynamic array `arr` // following https://docs.soliditylang.org/en/v0.8.20/internals/layout_in_storage.html#mappings-and-dynamic-arrays. /// @solidity memory-safe-assembly assembly { mstore(0, arr.slot) slot := add(keccak256(0, 0x20), pos) } return slot.getAddressSlot(); } /** * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check. * * WARNING: Only use if you are certain `pos` is lower than the array length. */ function unsafeAccess(bytes32[] storage arr, uint256 pos) internal pure returns (StorageSlot.Bytes32Slot storage) { bytes32 slot; // We use assembly to calculate the storage slot of the element at index `pos` of the dynamic array `arr` // following https://docs.soliditylang.org/en/v0.8.20/internals/layout_in_storage.html#mappings-and-dynamic-arrays. /// @solidity memory-safe-assembly assembly { mstore(0, arr.slot) slot := add(keccak256(0, 0x20), pos) } return slot.getBytes32Slot(); } /** * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check. * * WARNING: Only use if you are certain `pos` is lower than the array length. */ function unsafeAccess(uint256[] storage arr, uint256 pos) internal pure returns (StorageSlot.Uint256Slot storage) { bytes32 slot; // We use assembly to calculate the storage slot of the element at index `pos` of the dynamic array `arr` // following https://docs.soliditylang.org/en/v0.8.20/internals/layout_in_storage.html#mappings-and-dynamic-arrays. /// @solidity memory-safe-assembly assembly { mstore(0, arr.slot) slot := add(keccak256(0, 0x20), pos) } return slot.getUint256Slot(); } /** * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check. * * WARNING: Only use if you are certain `pos` is lower than the array length. */ function unsafeMemoryAccess(uint256[] memory arr, uint256 pos) internal pure returns (uint256 res) { assembly { res := mload(add(add(arr, 0x20), mul(pos, 0x20))) } } /** * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check. * * WARNING: Only use if you are certain `pos` is lower than the array length. */ function unsafeMemoryAccess(address[] memory arr, uint256 pos) internal pure returns (address res) { assembly { res := mload(add(add(arr, 0x20), mul(pos, 0x20))) } } } // File: @openzeppelin/contracts/utils/Context.sol // OpenZeppelin Contracts (last updated v5.0.0) (utils/Context.sol) pragma solidity ^0.8.20; /** * @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/access/Ownable.sol // OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol) pragma solidity ^0.8.20; /** * @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. * * The initial owner is set to the address provided by the deployer. 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; /** * @dev The caller account is not authorized to perform an operation. */ error OwnableUnauthorizedAccount(address account); /** * @dev The owner is not a valid owner account. (eg. `address(0)`) */ error OwnableInvalidOwner(address owner); event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the address provided by the deployer as the initial owner. */ constructor(address initialOwner) { if (initialOwner == address(0)) { revert OwnableInvalidOwner(address(0)); } _transferOwnership(initialOwner); } /** * @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 { if (owner() != _msgSender()) { revert OwnableUnauthorizedAccount(_msgSender()); } } /** * @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 { if (newOwner == address(0)) { revert OwnableInvalidOwner(address(0)); } _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } } // File: @openzeppelin/contracts/utils/introspection/IERC165.sol // OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/IERC165.sol) pragma solidity ^0.8.20; /** * @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 (last updated v5.0.0) (utils/introspection/ERC165.sol) pragma solidity ^0.8.20; /** * @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); * } * ``` */ abstract contract ERC165 is IERC165 { /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) { return interfaceId == type(IERC165).interfaceId; } } // File: @openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC1155/IERC1155Receiver.sol) pragma solidity ^0.8.20; /** * @dev Interface that must be implemented by smart contracts in order to receive * ERC-1155 token transfers. */ interface IERC1155Receiver is IERC165 { /** * @dev Handles the receipt of a single ERC1155 token type. This function is * called at the end of a `safeTransferFrom` after the balance has been updated. * * NOTE: To accept the transfer, this must return * `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` * (i.e. 0xf23a6e61, or its own function selector). * * @param operator The address which initiated the transfer (i.e. msg.sender) * @param from The address which previously owned the token * @param id The ID of the token being transferred * @param value The amount of tokens being transferred * @param data Additional data with no specified format * @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed */ function onERC1155Received( address operator, address from, uint256 id, uint256 value, bytes calldata data ) external returns (bytes4); /** * @dev Handles the receipt of a multiple ERC1155 token types. This function * is called at the end of a `safeBatchTransferFrom` after the balances have * been updated. * * NOTE: To accept the transfer(s), this must return * `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` * (i.e. 0xbc197c81, or its own function selector). * * @param operator The address which initiated the batch transfer (i.e. msg.sender) * @param from The address which previously owned the token * @param ids An array containing ids of each token being transferred (order and length must match values array) * @param values An array containing amounts of each token being transferred (order and length must match ids array) * @param data Additional data with no specified format * @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed */ function onERC1155BatchReceived( address operator, address from, uint256[] calldata ids, uint256[] calldata values, bytes calldata data ) external returns (bytes4); } // File: @openzeppelin/contracts/token/ERC1155/IERC1155.sol // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC1155/IERC1155.sol) pragma solidity ^0.8.20; /** * @dev Required interface of an ERC1155 compliant contract, as defined in the * https://eips.ethereum.org/EIPS/eip-1155[EIP]. */ interface IERC1155 is IERC165 { /** * @dev Emitted when `value` amount of tokens of type `id` are transferred from `from` to `to` by `operator`. */ event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value); /** * @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all * transfers. */ event TransferBatch( address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] values ); /** * @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to * `approved`. */ event ApprovalForAll(address indexed account, address indexed operator, bool approved); /** * @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI. * * If an {URI} event was emitted for `id`, the standard * https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value * returned by {IERC1155MetadataURI-uri}. */ event URI(string value, uint256 indexed id); /** * @dev Returns the value of tokens of token type `id` owned by `account`. * * Requirements: * * - `account` cannot be the zero address. */ function balanceOf(address account, uint256 id) external view returns (uint256); /** * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}. * * Requirements: * * - `accounts` and `ids` must have the same length. */ function balanceOfBatch( address[] calldata accounts, uint256[] calldata ids ) external view returns (uint256[] memory); /** * @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`, * * Emits an {ApprovalForAll} event. * * Requirements: * * - `operator` cannot be the caller. */ function setApprovalForAll(address operator, bool approved) external; /** * @dev Returns true if `operator` is approved to transfer ``account``'s tokens. * * See {setApprovalForAll}. */ function isApprovedForAll(address account, address operator) external view returns (bool); /** * @dev Transfers a `value` amount of tokens of type `id` from `from` to `to`. * * WARNING: This function can potentially allow a reentrancy attack when transferring tokens * to an untrusted contract, when invoking {onERC1155Received} on the receiver. * Ensure to follow the checks-effects-interactions pattern and consider employing * reentrancy guards when interacting with untrusted contracts. * * Emits a {TransferSingle} event. * * Requirements: * * - `to` cannot be the zero address. * - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}. * - `from` must have a balance of tokens of type `id` of at least `value` amount. * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the * acceptance magic value. */ function safeTransferFrom(address from, address to, uint256 id, uint256 value, bytes calldata data) external; /** * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}. * * * WARNING: This function can potentially allow a reentrancy attack when transferring tokens * to an untrusted contract, when invoking {onERC1155BatchReceived} on the receiver. * Ensure to follow the checks-effects-interactions pattern and consider employing * reentrancy guards when interacting with untrusted contracts. * * Emits a {TransferBatch} event. * * Requirements: * * - `ids` and `values` must have the same length. * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the * acceptance magic value. */ function safeBatchTransferFrom( address from, address to, uint256[] calldata ids, uint256[] calldata values, bytes calldata data ) external; } // File: @openzeppelin/contracts/token/ERC1155/extensions/IERC1155MetadataURI.sol // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC1155/extensions/IERC1155MetadataURI.sol) pragma solidity ^0.8.20; /** * @dev Interface of the optional ERC1155MetadataExtension interface, as defined * in the https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[EIP]. */ interface IERC1155MetadataURI is IERC1155 { /** * @dev Returns the URI for token type `id`. * * If the `\{id\}` substring is present in the URI, it must be replaced by * clients with the actual token type ID. */ function uri(uint256 id) external view returns (string memory); } // File: @openzeppelin/contracts/token/ERC1155/ERC1155.sol // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC1155/ERC1155.sol) pragma solidity ^0.8.20; /** * @dev Implementation of the basic standard multi-token. * See https://eips.ethereum.org/EIPS/eip-1155 * Originally based on code by Enjin: https://github.com/enjin/erc-1155 */ abstract contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI, IERC1155Errors { using Arrays for uint256[]; using Arrays for address[]; mapping(uint256 id => mapping(address account => uint256)) private _balances; mapping(address account => mapping(address operator => bool)) private _operatorApprovals; // Used as the URI for all token types by relying on ID substitution, e.g. https://token-cdn-domain/{id}.json string private _uri; /** * @dev See {_setURI}. */ constructor(string memory uri_) { _setURI(uri_); } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) { return interfaceId == type(IERC1155).interfaceId || interfaceId == type(IERC1155MetadataURI).interfaceId || super.supportsInterface(interfaceId); } /** * @dev See {IERC1155MetadataURI-uri}. * * This implementation returns the same URI for *all* token types. It relies * on the token type ID substitution mechanism * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP]. * * Clients calling this function must replace the `\{id\}` substring with the * actual token type ID. */ function uri(uint256 /* id */) public view virtual returns (string memory) { return _uri; } /** * @dev See {IERC1155-balanceOf}. */ function balanceOf(address account, uint256 id) public view virtual returns (uint256) { return _balances[id][account]; } /** * @dev See {IERC1155-balanceOfBatch}. * * Requirements: * * - `accounts` and `ids` must have the same length. */ function balanceOfBatch( address[] memory accounts, uint256[] memory ids ) public view virtual returns (uint256[] memory) { if (accounts.length != ids.length) { revert ERC1155InvalidArrayLength(ids.length, accounts.length); } uint256[] memory batchBalances = new uint256[](accounts.length); for (uint256 i = 0; i < accounts.length; ++i) { batchBalances[i] = balanceOf(accounts.unsafeMemoryAccess(i), ids.unsafeMemoryAccess(i)); } return batchBalances; } /** * @dev See {IERC1155-setApprovalForAll}. */ function setApprovalForAll(address operator, bool approved) public virtual { _setApprovalForAll(_msgSender(), operator, approved); } /** * @dev See {IERC1155-isApprovedForAll}. */ function isApprovedForAll(address account, address operator) public view virtual returns (bool) { return _operatorApprovals[account][operator]; } /** * @dev See {IERC1155-safeTransferFrom}. */ function safeTransferFrom(address from, address to, uint256 id, uint256 value, bytes memory data) public virtual { address sender = _msgSender(); if (from != sender && !isApprovedForAll(from, sender)) { revert ERC1155MissingApprovalForAll(sender, from); } _safeTransferFrom(from, to, id, value, data); } /** * @dev See {IERC1155-safeBatchTransferFrom}. */ function safeBatchTransferFrom( address from, address to, uint256[] memory ids, uint256[] memory values, bytes memory data ) public virtual { address sender = _msgSender(); if (from != sender && !isApprovedForAll(from, sender)) { revert ERC1155MissingApprovalForAll(sender, from); } _safeBatchTransferFrom(from, to, ids, values, data); } /** * @dev Transfers a `value` amount of tokens of type `id` from `from` to `to`. Will mint (or burn) if `from` * (or `to`) is the zero address. * * Emits a {TransferSingle} event if the arrays contain one element, and {TransferBatch} otherwise. * * Requirements: * * - If `to` refers to a smart contract, it must implement either {IERC1155Receiver-onERC1155Received} * or {IERC1155Receiver-onERC1155BatchReceived} and return the acceptance magic value. * - `ids` and `values` must have the same length. * * NOTE: The ERC-1155 acceptance check is not performed in this function. See {_updateWithAcceptanceCheck} instead. */ function _update(address from, address to, uint256[] memory ids, uint256[] memory values) internal virtual { if (ids.length != values.length) { revert ERC1155InvalidArrayLength(ids.length, values.length); } address operator = _msgSender(); for (uint256 i = 0; i < ids.length; ++i) { uint256 id = ids.unsafeMemoryAccess(i); uint256 value = values.unsafeMemoryAccess(i); if (from != address(0)) { uint256 fromBalance = _balances[id][from]; if (fromBalance < value) { revert ERC1155InsufficientBalance(from, fromBalance, value, id); } unchecked { // Overflow not possible: value <= fromBalance _balances[id][from] = fromBalance - value; } } if (to != address(0)) { _balances[id][to] += value; } } if (ids.length == 1) { uint256 id = ids.unsafeMemoryAccess(0); uint256 value = values.unsafeMemoryAccess(0); emit TransferSingle(operator, from, to, id, value); } else { emit TransferBatch(operator, from, to, ids, values); } } /** * @dev Version of {_update} that performs the token acceptance check by calling * {IERC1155Receiver-onERC1155Received} or {IERC1155Receiver-onERC1155BatchReceived} on the receiver address if it * contains code (eg. is a smart contract at the moment of execution). * * IMPORTANT: Overriding this function is discouraged because it poses a reentrancy risk from the receiver. So any * update to the contract state after this function would break the check-effect-interaction pattern. Consider * overriding {_update} instead. */ function _updateWithAcceptanceCheck( address from, address to, uint256[] memory ids, uint256[] memory values, bytes memory data ) internal virtual { _update(from, to, ids, values); if (to != address(0)) { address operator = _msgSender(); if (ids.length == 1) { uint256 id = ids.unsafeMemoryAccess(0); uint256 value = values.unsafeMemoryAccess(0); _doSafeTransferAcceptanceCheck(operator, from, to, id, value, data); } else { _doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, values, data); } } } /** * @dev Transfers a `value` tokens of token type `id` from `from` to `to`. * * Emits a {TransferSingle} event. * * Requirements: * * - `to` cannot be the zero address. * - `from` must have a balance of tokens of type `id` of at least `value` amount. * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the * acceptance magic value. */ function _safeTransferFrom(address from, address to, uint256 id, uint256 value, bytes memory data) internal { if (to == address(0)) { revert ERC1155InvalidReceiver(address(0)); } if (from == address(0)) { revert ERC1155InvalidSender(address(0)); } (uint256[] memory ids, uint256[] memory values) = _asSingletonArrays(id, value); _updateWithAcceptanceCheck(from, to, ids, values, data); } /** * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_safeTransferFrom}. * * Emits a {TransferBatch} event. * * Requirements: * * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the * acceptance magic value. * - `ids` and `values` must have the same length. */ function _safeBatchTransferFrom( address from, address to, uint256[] memory ids, uint256[] memory values, bytes memory data ) internal { if (to == address(0)) { revert ERC1155InvalidReceiver(address(0)); } if (from == address(0)) { revert ERC1155InvalidSender(address(0)); } _updateWithAcceptanceCheck(from, to, ids, values, data); } /** * @dev Sets a new URI for all token types, by relying on the token type ID * substitution mechanism * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP]. * * By this mechanism, any occurrence of the `\{id\}` substring in either the * URI or any of the values in the JSON file at said URI will be replaced by * clients with the token type ID. * * For example, the `https://token-cdn-domain/\{id\}.json` URI would be * interpreted by clients as * `https://token-cdn-domain/000000000000000000000000000000000000000000000000000000000004cce0.json` * for token type ID 0x4cce0. * * See {uri}. * * Because these URIs cannot be meaningfully represented by the {URI} event, * this function emits no events. */ function _setURI(string memory newuri) internal virtual { _uri = newuri; } /** * @dev Creates a `value` amount of tokens of type `id`, and assigns them to `to`. * * Emits a {TransferSingle} event. * * Requirements: * * - `to` cannot be the zero address. * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the * acceptance magic value. */ function _mint(address to, uint256 id, uint256 value, bytes memory data) internal { if (to == address(0)) { revert ERC1155InvalidReceiver(address(0)); } (uint256[] memory ids, uint256[] memory values) = _asSingletonArrays(id, value); _updateWithAcceptanceCheck(address(0), to, ids, values, data); } /** * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_mint}. * * Emits a {TransferBatch} event. * * Requirements: * * - `ids` and `values` must have the same length. * - `to` cannot be the zero address. * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the * acceptance magic value. */ function _mintBatch(address to, uint256[] memory ids, uint256[] memory values, bytes memory data) internal { if (to == address(0)) { revert ERC1155InvalidReceiver(address(0)); } _updateWithAcceptanceCheck(address(0), to, ids, values, data); } /** * @dev Destroys a `value` amount of tokens of type `id` from `from` * * Emits a {TransferSingle} event. * * Requirements: * * - `from` cannot be the zero address. * - `from` must have at least `value` amount of tokens of type `id`. */ function _burn(address from, uint256 id, uint256 value) internal { if (from == address(0)) { revert ERC1155InvalidSender(address(0)); } (uint256[] memory ids, uint256[] memory values) = _asSingletonArrays(id, value); _updateWithAcceptanceCheck(from, address(0), ids, values, ""); } /** * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_burn}. * * Emits a {TransferBatch} event. * * Requirements: * * - `from` cannot be the zero address. * - `from` must have at least `value` amount of tokens of type `id`. * - `ids` and `values` must have the same length. */ function _burnBatch(address from, uint256[] memory ids, uint256[] memory values) internal { if (from == address(0)) { revert ERC1155InvalidSender(address(0)); } _updateWithAcceptanceCheck(from, address(0), ids, values, ""); } /** * @dev Approve `operator` to operate on all of `owner` tokens * * Emits an {ApprovalForAll} event. * * Requirements: * * - `operator` cannot be the zero address. */ function _setApprovalForAll(address owner, address operator, bool approved) internal virtual { if (operator == address(0)) { revert ERC1155InvalidOperator(address(0)); } _operatorApprovals[owner][operator] = approved; emit ApprovalForAll(owner, operator, approved); } /** * @dev Performs an acceptance check by calling {IERC1155-onERC1155Received} on the `to` address * if it contains code at the moment of execution. */ function _doSafeTransferAcceptanceCheck( address operator, address from, address to, uint256 id, uint256 value, bytes memory data ) private { if (to.code.length > 0) { try IERC1155Receiver(to).onERC1155Received(operator, from, id, value, data) returns (bytes4 response) { if (response != IERC1155Receiver.onERC1155Received.selector) { // Tokens rejected revert ERC1155InvalidReceiver(to); } } catch (bytes memory reason) { if (reason.length == 0) { // non-ERC1155Receiver implementer revert ERC1155InvalidReceiver(to); } else { /// @solidity memory-safe-assembly assembly { revert(add(32, reason), mload(reason)) } } } } } /** * @dev Performs a batch acceptance check by calling {IERC1155-onERC1155BatchReceived} on the `to` address * if it contains code at the moment of execution. */ function _doSafeBatchTransferAcceptanceCheck( address operator, address from, address to, uint256[] memory ids, uint256[] memory values, bytes memory data ) private { if (to.code.length > 0) { try IERC1155Receiver(to).onERC1155BatchReceived(operator, from, ids, values, data) returns ( bytes4 response ) { if (response != IERC1155Receiver.onERC1155BatchReceived.selector) { // Tokens rejected revert ERC1155InvalidReceiver(to); } } catch (bytes memory reason) { if (reason.length == 0) { // non-ERC1155Receiver implementer revert ERC1155InvalidReceiver(to); } else { /// @solidity memory-safe-assembly assembly { revert(add(32, reason), mload(reason)) } } } } } /** * @dev Creates an array in memory with only one value for each of the elements provided. */ function _asSingletonArrays( uint256 element1, uint256 element2 ) private pure returns (uint256[] memory array1, uint256[] memory array2) { /// @solidity memory-safe-assembly assembly { // Load the free memory pointer array1 := mload(0x40) // Set array length to 1 mstore(array1, 1) // Store the single element at the next word after the length (where content starts) mstore(add(array1, 0x20), element1) // Repeat for next array locating it right after the first array array2 := add(array1, 0x40) mstore(array2, 1) mstore(add(array2, 0x20), element2) // Update the free memory pointer by pointing after the second array mstore(0x40, add(array2, 0x40)) } } } // File: QAA1155.sol pragma solidity ^0.8.0; contract QAA1155 is ERC1155, Ownable { uint256 public currentTokenID = 0; mapping(uint256 => string) private _uris; constructor() ERC1155("") Ownable(msg.sender) { // The ERC1155 constructor takes a URI string (empty in this case) // The Ownable constructor takes the initial owner address (msg.sender) } function uri(uint256 tokenId) override public view returns (string memory) { return(_uris[tokenId]); } function createToken(string memory tokenURI) public returns (uint256) { uint256 newTokenID = currentTokenID; _mint(msg.sender, newTokenID, 1, ""); _setURI(newTokenID, tokenURI); currentTokenID++; return newTokenID; } function mint(address account, uint256 id, uint256 amount) public { require(bytes(_uris[id]).length > 0, "Token must exist"); _mint(account, id, amount, ""); } function _setURI(uint256 tokenId, string memory newuri) private { _uris[tokenId] = newuri; } }
[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ERC1155InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC1155InvalidApprover","type":"error"},{"inputs":[{"internalType":"uint256","name":"idsLength","type":"uint256"},{"internalType":"uint256","name":"valuesLength","type":"uint256"}],"name":"ERC1155InvalidArrayLength","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"ERC1155InvalidOperator","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC1155InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC1155InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"address","name":"owner","type":"address"}],"name":"ERC1155MissingApprovalForAll","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"indexed":false,"internalType":"uint256[]","name":"values","type":"uint256[]"}],"name":"TransferBatch","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"TransferSingle","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"value","type":"string"},{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"}],"name":"URI","type":"event"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"accounts","type":"address[]"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"}],"name":"balanceOfBatch","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"tokenURI","type":"string"}],"name":"createToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"currentTokenID","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"uint256[]","name":"values","type":"uint256[]"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeBatchTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"value","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":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
0x608060405234801561000f575f80fd5b50600436106100e7575f3560e01c8063715018a61161008a578063bb62115e11610064578063bb62115e14610257578063e985e9c514610275578063f242432a146102a5578063f2fde38b146102c1576100e7565b8063715018a6146102135780638da5cb5b1461021d578063a22cb4651461023b576100e7565b8063156e29f6116100c6578063156e29f61461017b5780632eb2c2d61461019757806345576f94146101b35780634e1273f4146101e3576100e7565b8062fdd58e146100eb57806301ffc9a71461011b5780630e89341c1461014b575b5f80fd5b6101056004803603810190610100919061179f565b6102dd565b60405161011291906117ec565b60405180910390f35b6101356004803603810190610130919061185a565b610332565b604051610142919061189f565b60405180910390f35b610165600480360381019061016091906118b8565b610413565b604051610172919061196d565b60405180910390f35b6101956004803603810190610190919061198d565b6104b4565b005b6101b160048036038101906101ac9190611bcd565b610532565b005b6101cd60048036038101906101c89190611d36565b6105d9565b6040516101da91906117ec565b60405180910390f35b6101fd60048036038101906101f89190611e3d565b610625565b60405161020a9190611f6a565b60405180910390f35b61021b61072c565b005b61022561073f565b6040516102329190611f99565b60405180910390f35b61025560048036038101906102509190611fdc565b610767565b005b61025f61077d565b60405161026c91906117ec565b60405180910390f35b61028f600480360381019061028a919061201a565b610783565b60405161029c919061189f565b60405180910390f35b6102bf60048036038101906102ba9190612058565b610811565b005b6102db60048036038101906102d691906120eb565b6108b8565b005b5f805f8381526020019081526020015f205f8473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f2054905092915050565b5f7fd9b67a26000000000000000000000000000000000000000000000000000000007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916827bffffffffffffffffffffffffffffffffffffffffffffffffffffffff191614806103fc57507f0e89341c000000000000000000000000000000000000000000000000000000007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916827bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916145b8061040c575061040b8261093c565b5b9050919050565b606060055f8381526020019081526020015f20805461043190612143565b80601f016020809104026020016040519081016040528092919081815260200182805461045d90612143565b80156104a85780601f1061047f576101008083540402835291602001916104a8565b820191905f5260205f20905b81548152906001019060200180831161048b57829003601f168201915b50505050509050919050565b5f60055f8481526020019081526020015f2080546104d190612143565b905011610513576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161050a906121bd565b60405180910390fd5b61052d83838360405180602001604052805f8152506109a5565b505050565b5f61053b610a3a565b90508073ffffffffffffffffffffffffffffffffffffffff168673ffffffffffffffffffffffffffffffffffffffff1614158015610580575061057e8682610783565b155b156105c45780866040517fe237d9220000000000000000000000000000000000000000000000000000000081526004016105bb9291906121db565b60405180910390fd5b6105d18686868686610a41565b505050505050565b5f8060045490506105fb3382600160405180602001604052805f8152506109a5565b6106058184610b35565b60045f8154809291906106179061222f565b919050555080915050919050565b6060815183511461067157815183516040517f5b059991000000000000000000000000000000000000000000000000000000008152600401610668929190612276565b60405180910390fd5b5f835167ffffffffffffffff81111561068d5761068c6119e1565b5b6040519080825280602002602001820160405280156106bb5781602001602082028036833780820191505090505b5090505f5b8451811015610721576106f76106df8287610b5890919063ffffffff16565b6106f28387610b6b90919063ffffffff16565b6102dd565b82828151811061070a5761070961229d565b5b6020026020010181815250508060010190506106c0565b508091505092915050565b610734610b7e565b61073d5f610c05565b565b5f60035f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b610779610772610a3a565b8383610cc8565b5050565b60045481565b5f60015f8473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f8373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f9054906101000a900460ff16905092915050565b5f61081a610a3a565b90508073ffffffffffffffffffffffffffffffffffffffff168673ffffffffffffffffffffffffffffffffffffffff161415801561085f575061085d8682610783565b155b156108a35780866040517fe237d92200000000000000000000000000000000000000000000000000000000815260040161089a9291906121db565b60405180910390fd5b6108b08686868686610e31565b505050505050565b6108c0610b7e565b5f73ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1603610930575f6040517f1e4fbdf70000000000000000000000000000000000000000000000000000000081526004016109279190611f99565b60405180910390fd5b61093981610c05565b50565b5f7f01ffc9a7000000000000000000000000000000000000000000000000000000007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916827bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916149050919050565b5f73ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff1603610a15575f6040517f57f447ce000000000000000000000000000000000000000000000000000000008152600401610a0c9190611f99565b60405180910390fd5b5f80610a218585610f37565b91509150610a325f87848487610f67565b505050505050565b5f33905090565b5f73ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff1603610ab1575f6040517f57f447ce000000000000000000000000000000000000000000000000000000008152600401610aa89190611f99565b60405180910390fd5b5f73ffffffffffffffffffffffffffffffffffffffff168573ffffffffffffffffffffffffffffffffffffffff1603610b21575f6040517f01a83514000000000000000000000000000000000000000000000000000000008152600401610b189190611f99565b60405180910390fd5b610b2e8585858585610f67565b5050505050565b8060055f8481526020019081526020015f209081610b539190612467565b505050565b5f60208202602084010151905092915050565b5f60208202602084010151905092915050565b610b86610a3a565b73ffffffffffffffffffffffffffffffffffffffff16610ba461073f565b73ffffffffffffffffffffffffffffffffffffffff1614610c0357610bc7610a3a565b6040517f118cdaa7000000000000000000000000000000000000000000000000000000008152600401610bfa9190611f99565b60405180910390fd5b565b5f60035f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1690508160035f6101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b5f73ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1603610d38575f6040517fced3e100000000000000000000000000000000000000000000000000000000008152600401610d2f9190611f99565b60405180910390fd5b8060015f8573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f8473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f6101000a81548160ff0219169083151502179055508173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c3183604051610e24919061189f565b60405180910390a3505050565b5f73ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff1603610ea1575f6040517f57f447ce000000000000000000000000000000000000000000000000000000008152600401610e989190611f99565b60405180910390fd5b5f73ffffffffffffffffffffffffffffffffffffffff168573ffffffffffffffffffffffffffffffffffffffff1603610f11575f6040517f01a83514000000000000000000000000000000000000000000000000000000008152600401610f089190611f99565b60405180910390fd5b5f80610f1d8585610f37565b91509150610f2e8787848487610f67565b50505050505050565b60608060405191506001825283602083015260408201905060018152826020820152604081016040529250929050565b610f7385858585611013565b5f73ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff161461100c575f610faf610a3a565b90506001845103610ffb575f610fce5f86610b6b90919063ffffffff16565b90505f610fe45f86610b6b90919063ffffffff16565b9050610ff48389898585896113a3565b505061100a565b611009818787878787611552565b5b505b5050505050565b805182511461105d57815181516040517f5b059991000000000000000000000000000000000000000000000000000000008152600401611054929190612276565b60405180910390fd5b5f611066610a3a565b90505f5b8351811015611262575f6110878286610b6b90919063ffffffff16565b90505f61109d8386610b6b90919063ffffffff16565b90505f73ffffffffffffffffffffffffffffffffffffffff168873ffffffffffffffffffffffffffffffffffffffff16146111c0575f805f8481526020019081526020015f205f8a73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205490508181101561116c57888183856040517f03dee4c50000000000000000000000000000000000000000000000000000000081526004016111639493929190612536565b60405180910390fd5b8181035f808581526020019081526020015f205f8b73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f2081905550505b5f73ffffffffffffffffffffffffffffffffffffffff168773ffffffffffffffffffffffffffffffffffffffff161461125557805f808481526020019081526020015f205f8973ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f82825461124d9190612579565b925050819055505b505080600101905061106a565b50600183510361131d575f6112805f85610b6b90919063ffffffff16565b90505f6112965f85610b6b90919063ffffffff16565b90508573ffffffffffffffffffffffffffffffffffffffff168773ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff167fc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62858560405161130e929190612276565b60405180910390a4505061139c565b8373ffffffffffffffffffffffffffffffffffffffff168573ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff167f4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb86866040516113939291906125ac565b60405180910390a45b5050505050565b5f8473ffffffffffffffffffffffffffffffffffffffff163b111561154a578373ffffffffffffffffffffffffffffffffffffffff1663f23a6e6187878686866040518663ffffffff1660e01b8152600401611403959493929190612633565b6020604051808303815f875af192505050801561143e57506040513d601f19601f8201168201806040525081019061143b919061269f565b60015b6114bf573d805f811461146c576040519150601f19603f3d011682016040523d82523d5f602084013e611471565b606091505b505f8151036114b757846040517f57f447ce0000000000000000000000000000000000000000000000000000000081526004016114ae9190611f99565b60405180910390fd5b805181602001fd5b63f23a6e6160e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916817bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19161461154857846040517f57f447ce00000000000000000000000000000000000000000000000000000000815260040161153f9190611f99565b60405180910390fd5b505b505050505050565b5f8473ffffffffffffffffffffffffffffffffffffffff163b11156116f9578373ffffffffffffffffffffffffffffffffffffffff1663bc197c8187878686866040518663ffffffff1660e01b81526004016115b29594939291906126ca565b6020604051808303815f875af19250505080156115ed57506040513d601f19601f820116820180604052508101906115ea919061269f565b60015b61166e573d805f811461161b576040519150601f19603f3d011682016040523d82523d5f602084013e611620565b606091505b505f81510361166657846040517f57f447ce00000000000000000000000000000000000000000000000000000000815260040161165d9190611f99565b60405180910390fd5b805181602001fd5b63bc197c8160e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916817bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916146116f757846040517f57f447ce0000000000000000000000000000000000000000000000000000000081526004016116ee9190611f99565b60405180910390fd5b505b505050505050565b5f604051905090565b5f80fd5b5f80fd5b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f61173b82611712565b9050919050565b61174b81611731565b8114611755575f80fd5b50565b5f8135905061176681611742565b92915050565b5f819050919050565b61177e8161176c565b8114611788575f80fd5b50565b5f8135905061179981611775565b92915050565b5f80604083850312156117b5576117b461170a565b5b5f6117c285828601611758565b92505060206117d38582860161178b565b9150509250929050565b6117e68161176c565b82525050565b5f6020820190506117ff5f8301846117dd565b92915050565b5f7fffffffff0000000000000000000000000000000000000000000000000000000082169050919050565b61183981611805565b8114611843575f80fd5b50565b5f8135905061185481611830565b92915050565b5f6020828403121561186f5761186e61170a565b5b5f61187c84828501611846565b91505092915050565b5f8115159050919050565b61189981611885565b82525050565b5f6020820190506118b25f830184611890565b92915050565b5f602082840312156118cd576118cc61170a565b5b5f6118da8482850161178b565b91505092915050565b5f81519050919050565b5f82825260208201905092915050565b5f5b8381101561191a5780820151818401526020810190506118ff565b5f8484015250505050565b5f601f19601f8301169050919050565b5f61193f826118e3565b61194981856118ed565b93506119598185602086016118fd565b61196281611925565b840191505092915050565b5f6020820190508181035f8301526119858184611935565b905092915050565b5f805f606084860312156119a4576119a361170a565b5b5f6119b186828701611758565b93505060206119c28682870161178b565b92505060406119d38682870161178b565b9150509250925092565b5f80fd5b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b611a1782611925565b810181811067ffffffffffffffff82111715611a3657611a356119e1565b5b80604052505050565b5f611a48611701565b9050611a548282611a0e565b919050565b5f67ffffffffffffffff821115611a7357611a726119e1565b5b602082029050602081019050919050565b5f80fd5b5f611a9a611a9584611a59565b611a3f565b90508083825260208201905060208402830185811115611abd57611abc611a84565b5b835b81811015611ae65780611ad2888261178b565b845260208401935050602081019050611abf565b5050509392505050565b5f82601f830112611b0457611b036119dd565b5b8135611b14848260208601611a88565b91505092915050565b5f80fd5b5f67ffffffffffffffff821115611b3b57611b3a6119e1565b5b611b4482611925565b9050602081019050919050565b828183375f83830152505050565b5f611b71611b6c84611b21565b611a3f565b905082815260208101848484011115611b8d57611b8c611b1d565b5b611b98848285611b51565b509392505050565b5f82601f830112611bb457611bb36119dd565b5b8135611bc4848260208601611b5f565b91505092915050565b5f805f805f60a08688031215611be657611be561170a565b5b5f611bf388828901611758565b9550506020611c0488828901611758565b945050604086013567ffffffffffffffff811115611c2557611c2461170e565b5b611c3188828901611af0565b935050606086013567ffffffffffffffff811115611c5257611c5161170e565b5b611c5e88828901611af0565b925050608086013567ffffffffffffffff811115611c7f57611c7e61170e565b5b611c8b88828901611ba0565b9150509295509295909350565b5f67ffffffffffffffff821115611cb257611cb16119e1565b5b611cbb82611925565b9050602081019050919050565b5f611cda611cd584611c98565b611a3f565b905082815260208101848484011115611cf657611cf5611b1d565b5b611d01848285611b51565b509392505050565b5f82601f830112611d1d57611d1c6119dd565b5b8135611d2d848260208601611cc8565b91505092915050565b5f60208284031215611d4b57611d4a61170a565b5b5f82013567ffffffffffffffff811115611d6857611d6761170e565b5b611d7484828501611d09565b91505092915050565b5f67ffffffffffffffff821115611d9757611d966119e1565b5b602082029050602081019050919050565b5f611dba611db584611d7d565b611a3f565b90508083825260208201905060208402830185811115611ddd57611ddc611a84565b5b835b81811015611e065780611df28882611758565b845260208401935050602081019050611ddf565b5050509392505050565b5f82601f830112611e2457611e236119dd565b5b8135611e34848260208601611da8565b91505092915050565b5f8060408385031215611e5357611e5261170a565b5b5f83013567ffffffffffffffff811115611e7057611e6f61170e565b5b611e7c85828601611e10565b925050602083013567ffffffffffffffff811115611e9d57611e9c61170e565b5b611ea985828601611af0565b9150509250929050565b5f81519050919050565b5f82825260208201905092915050565b5f819050602082019050919050565b611ee58161176c565b82525050565b5f611ef68383611edc565b60208301905092915050565b5f602082019050919050565b5f611f1882611eb3565b611f228185611ebd565b9350611f2d83611ecd565b805f5b83811015611f5d578151611f448882611eeb565b9750611f4f83611f02565b925050600181019050611f30565b5085935050505092915050565b5f6020820190508181035f830152611f828184611f0e565b905092915050565b611f9381611731565b82525050565b5f602082019050611fac5f830184611f8a565b92915050565b611fbb81611885565b8114611fc5575f80fd5b50565b5f81359050611fd681611fb2565b92915050565b5f8060408385031215611ff257611ff161170a565b5b5f611fff85828601611758565b925050602061201085828601611fc8565b9150509250929050565b5f80604083850312156120305761202f61170a565b5b5f61203d85828601611758565b925050602061204e85828601611758565b9150509250929050565b5f805f805f60a086880312156120715761207061170a565b5b5f61207e88828901611758565b955050602061208f88828901611758565b94505060406120a08882890161178b565b93505060606120b18882890161178b565b925050608086013567ffffffffffffffff8111156120d2576120d161170e565b5b6120de88828901611ba0565b9150509295509295909350565b5f60208284031215612100576120ff61170a565b5b5f61210d84828501611758565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52602260045260245ffd5b5f600282049050600182168061215a57607f821691505b60208210810361216d5761216c612116565b5b50919050565b7f546f6b656e206d757374206578697374000000000000000000000000000000005f82015250565b5f6121a76010836118ed565b91506121b282612173565b602082019050919050565b5f6020820190508181035f8301526121d48161219b565b9050919050565b5f6040820190506121ee5f830185611f8a565b6121fb6020830184611f8a565b9392505050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f6122398261176c565b91507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff820361226b5761226a612202565b5b600182019050919050565b5f6040820190506122895f8301856117dd565b61229660208301846117dd565b9392505050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52603260045260245ffd5b5f819050815f5260205f209050919050565b5f6020601f8301049050919050565b5f82821b905092915050565b5f600883026123267fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff826122eb565b61233086836122eb565b95508019841693508086168417925050509392505050565b5f819050919050565b5f61236b6123666123618461176c565b612348565b61176c565b9050919050565b5f819050919050565b61238483612351565b61239861239082612372565b8484546122f7565b825550505050565b5f90565b6123ac6123a0565b6123b781848461237b565b505050565b5b818110156123da576123cf5f826123a4565b6001810190506123bd565b5050565b601f82111561241f576123f0816122ca565b6123f9846122dc565b81016020851015612408578190505b61241c612414856122dc565b8301826123bc565b50505b505050565b5f82821c905092915050565b5f61243f5f1984600802612424565b1980831691505092915050565b5f6124578383612430565b9150826002028217905092915050565b612470826118e3565b67ffffffffffffffff811115612489576124886119e1565b5b6124938254612143565b61249e8282856123de565b5f60209050601f8311600181146124cf575f84156124bd578287015190505b6124c7858261244c565b86555061252e565b601f1984166124dd866122ca565b5f5b82811015612504578489015182556001820191506020850194506020810190506124df565b86831015612521578489015161251d601f891682612430565b8355505b6001600288020188555050505b505050505050565b5f6080820190506125495f830187611f8a565b61255660208301866117dd565b61256360408301856117dd565b61257060608301846117dd565b95945050505050565b5f6125838261176c565b915061258e8361176c565b92508282019050808211156125a6576125a5612202565b5b92915050565b5f6040820190508181035f8301526125c48185611f0e565b905081810360208301526125d88184611f0e565b90509392505050565b5f81519050919050565b5f82825260208201905092915050565b5f612605826125e1565b61260f81856125eb565b935061261f8185602086016118fd565b61262881611925565b840191505092915050565b5f60a0820190506126465f830188611f8a565b6126536020830187611f8a565b61266060408301866117dd565b61266d60608301856117dd565b818103608083015261267f81846125fb565b90509695505050505050565b5f8151905061269981611830565b92915050565b5f602082840312156126b4576126b361170a565b5b5f6126c18482850161268b565b91505092915050565b5f60a0820190506126dd5f830188611f8a565b6126ea6020830187611f8a565b81810360408301526126fc8186611f0e565b905081810360608301526127108185611f0e565b9050818103608083015261272481846125fb565b9050969550505050505056fea26469706673582212200f7b208fc5341d58c91f967dc80eb76e94ca94e550024f7ad1cb9678ca8c182764736f6c63430008170033
Deployed Bytecode Sourcemap
62465:1049:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47316:134;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;46425:310;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;62817:116;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;63215:182;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;49139:441;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;62941:266;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;47616:567;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;34508:103;;;:::i;:::-;;33833:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;48256:146;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;62509:33;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;48474:159;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;48705:357;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;34766:220;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;47316:134;47393:7;47420:9;:13;47430:2;47420:13;;;;;;;;;;;:22;47434:7;47420:22;;;;;;;;;;;;;;;;47413:29;;47316:134;;;;:::o;46425:310::-;46527:4;46579:26;46564:41;;;:11;:41;;;;:110;;;;46637:37;46622:52;;;:11;:52;;;;46564:110;:163;;;;46691:36;46715:11;46691:23;:36::i;:::-;46564:163;46544:183;;46425:310;;;:::o;62817:116::-;62877:13;62910:5;:14;62916:7;62910:14;;;;;;;;;;;62903:22;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62817:116;;;:::o;63215:182::-;63326:1;63306:5;:9;63312:2;63306:9;;;;;;;;;;;63300:23;;;;;:::i;:::-;;;:27;63292:56;;;;;;;;;;;;:::i;:::-;;;;;;;;;63359:30;63365:7;63374:2;63378:6;63359:30;;;;;;;;;;;;:5;:30::i;:::-;63215:182;;;:::o;49139:441::-;49340:14;49357:12;:10;:12::i;:::-;49340:29;;49392:6;49384:14;;:4;:14;;;;:49;;;;;49403:30;49420:4;49426:6;49403:16;:30::i;:::-;49402:31;49384:49;49380:131;;;49486:6;49494:4;49457:42;;;;;;;;;;;;:::i;:::-;;;;;;;;49380:131;49521:51;49544:4;49550:2;49554:3;49559:6;49567:4;49521:22;:51::i;:::-;49329:251;49139:441;;;;;:::o;62941:266::-;63002:7;63022:18;63043:14;;63022:35;;63068:36;63074:10;63086;63098:1;63068:36;;;;;;;;;;;;:5;:36::i;:::-;63115:29;63123:10;63135:8;63115:7;:29::i;:::-;63155:14;;:16;;;;;;;;;:::i;:::-;;;;;;63189:10;63182:17;;;62941:266;;;:::o;47616:567::-;47743:16;47795:3;:10;47776:8;:15;:29;47772:123;;47855:3;:10;47867:8;:15;47829:54;;;;;;;;;;;;:::i;:::-;;;;;;;;47772:123;47907:30;47954:8;:15;47940:30;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47907:63;;47988:9;47983:160;48007:8;:15;48003:1;:19;47983:160;;;48063:68;48073:30;48101:1;48073:8;:27;;:30;;;;:::i;:::-;48105:25;48128:1;48105:3;:22;;:25;;;;:::i;:::-;48063:9;:68::i;:::-;48044:13;48058:1;48044:16;;;;;;;;:::i;:::-;;;;;;;:87;;;;;48024:3;;;;;47983:160;;;;48162:13;48155:20;;;47616:567;;;;:::o;34508:103::-;33719:13;:11;:13::i;:::-;34573:30:::1;34600:1;34573:18;:30::i;:::-;34508:103::o:0;33833:87::-;33879:7;33906:6;;;;;;;;;;;33899:13;;33833:87;:::o;48256:146::-;48342:52;48361:12;:10;:12::i;:::-;48375:8;48385;48342:18;:52::i;:::-;48256:146;;:::o;62509:33::-;;;;:::o;48474:159::-;48564:4;48588:18;:27;48607:7;48588:27;;;;;;;;;;;;;;;:37;48616:8;48588:37;;;;;;;;;;;;;;;;;;;;;;;;;48581:44;;48474:159;;;;:::o;48705:357::-;48829:14;48846:12;:10;:12::i;:::-;48829:29;;48881:6;48873:14;;:4;:14;;;;:49;;;;;48892:30;48909:4;48915:6;48892:16;:30::i;:::-;48891:31;48873:49;48869:131;;;48975:6;48983:4;48946:42;;;;;;;;;;;;:::i;:::-;;;;;;;;48869:131;49010:44;49028:4;49034:2;49038;49042:5;49049:4;49010:17;:44::i;:::-;48818:244;48705:357;;;;;:::o;34766:220::-;33719:13;:11;:13::i;:::-;34871:1:::1;34851:22;;:8;:22;;::::0;34847:93:::1;;34925:1;34897:31;;;;;;;;;;;:::i;:::-;;;;;;;;34847:93;34950:28;34969:8;34950:18;:28::i;:::-;34766:220:::0;:::o;37058:148::-;37134:4;37173:25;37158:40;;;:11;:40;;;;37151:47;;37058:148;;;:::o;56048:352::-;56159:1;56145:16;;:2;:16;;;56141:90;;56216:1;56185:34;;;;;;;;;;;:::i;:::-;;;;;;;;56141:90;56242:20;56264:23;56291:29;56310:2;56314:5;56291:18;:29::i;:::-;56241:79;;;;56331:61;56366:1;56370:2;56374:3;56379:6;56387:4;56331:26;:61::i;:::-;56130:270;;56048:352;;;;:::o;31949:98::-;32002:7;32029:10;32022:17;;31949:98;:::o;54267:459::-;54481:1;54467:16;;:2;:16;;;54463:90;;54538:1;54507:34;;;;;;;;;;;:::i;:::-;;;;;;;;54463:90;54583:1;54567:18;;:4;:18;;;54563:90;;54638:1;54609:32;;;;;;;;;;;:::i;:::-;;;;;;;;54563:90;54663:55;54690:4;54696:2;54700:3;54705:6;54713:4;54663:26;:55::i;:::-;54267:459;;;;;:::o;63405:106::-;63497:6;63480:5;:14;63486:7;63480:14;;;;;;;;;;;:23;;;;;;:::i;:::-;;63405:106;;:::o;31046:201::-;31132:11;31222:4;31217:3;31213:14;31206:4;31201:3;31197:14;31193:35;31187:42;31180:49;;31046:201;;;;:::o;30636:::-;30722:11;30812:4;30807:3;30803:14;30796:4;30791:3;30787:14;30783:35;30777:42;30770:49;;30636:201;;;;:::o;33998:166::-;34069:12;:10;:12::i;:::-;34058:23;;:7;:5;:7::i;:::-;:23;;;34054:103;;34132:12;:10;:12::i;:::-;34105:40;;;;;;;;;;;:::i;:::-;;;;;;;;34054:103;33998:166::o;35146:191::-;35220:16;35239:6;;;;;;;;;;;35220:25;;35265:8;35256:6;;:17;;;;;;;;;;;;;;;;;;35320:8;35289:40;;35310:8;35289:40;;;;;;;;;;;;35209:128;35146:191;:::o;58642:321::-;58770:1;58750:22;;:8;:22;;;58746:96;;58827:1;58796:34;;;;;;;;;;;:::i;:::-;;;;;;;;58746:96;58890:8;58852:18;:25;58871:5;58852:25;;;;;;;;;;;;;;;:35;58878:8;58852:35;;;;;;;;;;;;;;;;:46;;;;;;;;;;;;;;;;;;58936:8;58914:41;;58929:5;58914:41;;;58946:8;58914:41;;;;;;:::i;:::-;;;;;;;;58642:321;;;:::o;53381:472::-;53518:1;53504:16;;:2;:16;;;53500:90;;53575:1;53544:34;;;;;;;;;;;:::i;:::-;;;;;;;;53500:90;53620:1;53604:18;;:4;:18;;;53600:90;;53675:1;53646:32;;;;;;;;;;;:::i;:::-;;;;;;;;53600:90;53701:20;53723:23;53750:29;53769:2;53773:5;53750:18;:29::i;:::-;53700:79;;;;53790:55;53817:4;53823:2;53827:3;53832:6;53840:4;53790:26;:55::i;:::-;53489:364;;53381:472;;;;;:::o;61531:870::-;61642:23;61667;61832:4;61826:11;61816:21;;61904:1;61896:6;61889:17;62044:8;62037:4;62029:6;62025:17;62018:35;62169:4;62161:6;62157:17;62147:27;;62203:1;62195:6;62188:17;62245:8;62238:4;62230:6;62226:17;62219:35;62377:4;62369:6;62365:17;62359:4;62352:31;61531:870;;;;;:::o;52202:708::-;52410:30;52418:4;52424:2;52428:3;52433:6;52410:7;:30::i;:::-;52469:1;52455:16;;:2;:16;;;52451:452;;52488:16;52507:12;:10;:12::i;:::-;52488:31;;52552:1;52538:3;:10;:15;52534:358;;52574:10;52587:25;52610:1;52587:3;:22;;:25;;;;:::i;:::-;52574:38;;52631:13;52647:28;52673:1;52647:6;:25;;:28;;;;:::i;:::-;52631:44;;52694:67;52725:8;52735:4;52741:2;52745;52749:5;52756:4;52694:30;:67::i;:::-;52555:222;;52534:358;;;52802:74;52838:8;52848:4;52854:2;52858:3;52863:6;52871:4;52802:35;:74::i;:::-;52534:358;52473:430;52451:452;52202:708;;;;;:::o;50297:1315::-;50433:6;:13;50419:3;:10;:27;50415:119;;50496:3;:10;50508:6;:13;50470:52;;;;;;;;;;;;:::i;:::-;;;;;;;;50415:119;50546:16;50565:12;:10;:12::i;:::-;50546:31;;50595:9;50590:709;50614:3;:10;50610:1;:14;50590:709;;;50646:10;50659:25;50682:1;50659:3;:22;;:25;;;;:::i;:::-;50646:38;;50699:13;50715:28;50741:1;50715:6;:25;;:28;;;;:::i;:::-;50699:44;;50780:1;50764:18;;:4;:18;;;50760:429;;50803:19;50825:9;:13;50835:2;50825:13;;;;;;;;;;;:19;50839:4;50825:19;;;;;;;;;;;;;;;;50803:41;;50881:5;50867:11;:19;50863:131;;;50945:4;50951:11;50964:5;50971:2;50918:56;;;;;;;;;;;;;;:::i;:::-;;;;;;;;50863:131;51149:5;51135:11;:19;51113:9;:13;51123:2;51113:13;;;;;;;;;;;:19;51127:4;51113:19;;;;;;;;;;;;;;;:41;;;;50784:405;50760:429;51223:1;51209:16;;:2;:16;;;51205:83;;51267:5;51246:9;:13;51256:2;51246:13;;;;;;;;;;;:17;51260:2;51246:17;;;;;;;;;;;;;;;;:26;;;;;;;:::i;:::-;;;;;;;;51205:83;50631:668;;50626:3;;;;;50590:709;;;;51329:1;51315:3;:10;:15;51311:294;;51347:10;51360:25;51383:1;51360:3;:22;;:25;;;;:::i;:::-;51347:38;;51400:13;51416:28;51442:1;51416:6;:25;;:28;;;;:::i;:::-;51400:44;;51495:2;51464:45;;51489:4;51464:45;;51479:8;51464:45;;;51499:2;51503:5;51464:45;;;;;;;:::i;:::-;;;;;;;;51332:189;;51311:294;;;51577:2;51547:46;;51571:4;51547:46;;51561:8;51547:46;;;51581:3;51586:6;51547:46;;;;;;;:::i;:::-;;;;;;;;51311:294;50404:1208;50297:1315;;;;:::o;59147:1000::-;59378:1;59361:2;:14;;;:18;59357:783;;;59417:2;59400:38;;;59439:8;59449:4;59455:2;59459:5;59466:4;59400:71;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;59396:733;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59778:1;59761:6;:13;:18;59757:357;;59890:2;59867:26;;;;;;;;;;;:::i;:::-;;;;;;;;59757:357;60064:6;60058:13;60049:6;60045:2;60041:15;60034:38;59396:733;59533:43;;;59521:55;;;:8;:55;;;;59517:177;;59671:2;59648:26;;;;;;;;;;;:::i;:::-;;;;;;;;59517:177;59472:237;59357:783;59147:1000;;;;;;:::o;60341:1069::-;60597:1;60580:2;:14;;;:18;60576:827;;;60636:2;60619:43;;;60663:8;60673:4;60679:3;60684:6;60692:4;60619:78;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;60615:777;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61041:1;61024:6;:13;:18;61020:357;;61153:2;61130:26;;;;;;;;;;;:::i;:::-;;;;;;;;61020:357;61327:6;61321:13;61312:6;61308:2;61304:15;61297:38;60615:777;60791:48;;;60779:60;;;:8;:60;;;;60775:182;;60934:2;60911:26;;;;;;;;;;;:::i;:::-;;;;;;;;60775:182;60698:274;60576:827;60341:1069;;;;;;:::o;7:75:1:-;40:6;73:2;67:9;57:19;;7:75;:::o;88:117::-;197:1;194;187:12;211:117;320:1;317;310:12;334:126;371:7;411:42;404:5;400:54;389:65;;334:126;;;:::o;466:96::-;503:7;532:24;550:5;532:24;:::i;:::-;521:35;;466:96;;;:::o;568:122::-;641:24;659:5;641:24;:::i;:::-;634:5;631:35;621:63;;680:1;677;670:12;621:63;568:122;:::o;696:139::-;742:5;780:6;767:20;758:29;;796:33;823:5;796:33;:::i;:::-;696:139;;;;:::o;841:77::-;878:7;907:5;896:16;;841:77;;;:::o;924:122::-;997:24;1015:5;997:24;:::i;:::-;990:5;987:35;977:63;;1036:1;1033;1026:12;977:63;924:122;:::o;1052:139::-;1098:5;1136:6;1123:20;1114:29;;1152:33;1179:5;1152:33;:::i;:::-;1052:139;;;;:::o;1197:474::-;1265:6;1273;1322:2;1310:9;1301:7;1297:23;1293:32;1290:119;;;1328:79;;:::i;:::-;1290:119;1448:1;1473:53;1518:7;1509:6;1498:9;1494:22;1473:53;:::i;:::-;1463:63;;1419:117;1575:2;1601:53;1646:7;1637:6;1626:9;1622:22;1601:53;:::i;:::-;1591:63;;1546:118;1197:474;;;;;:::o;1677:118::-;1764:24;1782:5;1764:24;:::i;:::-;1759:3;1752:37;1677:118;;:::o;1801:222::-;1894:4;1932:2;1921:9;1917:18;1909:26;;1945:71;2013:1;2002:9;1998:17;1989:6;1945:71;:::i;:::-;1801:222;;;;:::o;2029:149::-;2065:7;2105:66;2098:5;2094:78;2083:89;;2029:149;;;:::o;2184:120::-;2256:23;2273:5;2256:23;:::i;:::-;2249:5;2246:34;2236:62;;2294:1;2291;2284:12;2236:62;2184:120;:::o;2310:137::-;2355:5;2393:6;2380:20;2371:29;;2409:32;2435:5;2409:32;:::i;:::-;2310:137;;;;:::o;2453:327::-;2511:6;2560:2;2548:9;2539:7;2535:23;2531:32;2528:119;;;2566:79;;:::i;:::-;2528:119;2686:1;2711:52;2755:7;2746:6;2735:9;2731:22;2711:52;:::i;:::-;2701:62;;2657:116;2453:327;;;;:::o;2786:90::-;2820:7;2863:5;2856:13;2849:21;2838:32;;2786:90;;;:::o;2882:109::-;2963:21;2978:5;2963:21;:::i;:::-;2958:3;2951:34;2882:109;;:::o;2997:210::-;3084:4;3122:2;3111:9;3107:18;3099:26;;3135:65;3197:1;3186:9;3182:17;3173:6;3135:65;:::i;:::-;2997:210;;;;:::o;3213:329::-;3272:6;3321:2;3309:9;3300:7;3296:23;3292:32;3289:119;;;3327:79;;:::i;:::-;3289:119;3447:1;3472:53;3517:7;3508:6;3497:9;3493:22;3472:53;:::i;:::-;3462:63;;3418:117;3213:329;;;;:::o;3548:99::-;3600:6;3634:5;3628:12;3618:22;;3548:99;;;:::o;3653:169::-;3737:11;3771:6;3766:3;3759:19;3811:4;3806:3;3802:14;3787:29;;3653:169;;;;:::o;3828:246::-;3909:1;3919:113;3933:6;3930:1;3927:13;3919:113;;;4018:1;4013:3;4009:11;4003:18;3999:1;3994:3;3990:11;3983:39;3955:2;3952:1;3948:10;3943:15;;3919:113;;;4066:1;4057:6;4052:3;4048:16;4041:27;3890:184;3828:246;;;:::o;4080:102::-;4121:6;4172:2;4168:7;4163:2;4156:5;4152:14;4148:28;4138:38;;4080:102;;;:::o;4188:377::-;4276:3;4304:39;4337:5;4304:39;:::i;:::-;4359:71;4423:6;4418:3;4359:71;:::i;:::-;4352:78;;4439:65;4497:6;4492:3;4485:4;4478:5;4474:16;4439:65;:::i;:::-;4529:29;4551:6;4529:29;:::i;:::-;4524:3;4520:39;4513:46;;4280:285;4188:377;;;;:::o;4571:313::-;4684:4;4722:2;4711:9;4707:18;4699:26;;4771:9;4765:4;4761:20;4757:1;4746:9;4742:17;4735:47;4799:78;4872:4;4863:6;4799:78;:::i;:::-;4791:86;;4571:313;;;;:::o;4890:619::-;4967:6;4975;4983;5032:2;5020:9;5011:7;5007:23;5003:32;5000:119;;;5038:79;;:::i;:::-;5000:119;5158:1;5183:53;5228:7;5219:6;5208:9;5204:22;5183:53;:::i;:::-;5173:63;;5129:117;5285:2;5311:53;5356:7;5347:6;5336:9;5332:22;5311:53;:::i;:::-;5301:63;;5256:118;5413:2;5439:53;5484:7;5475:6;5464:9;5460:22;5439:53;:::i;:::-;5429:63;;5384:118;4890:619;;;;;:::o;5515:117::-;5624:1;5621;5614:12;5638:180;5686:77;5683:1;5676:88;5783:4;5780:1;5773:15;5807:4;5804:1;5797:15;5824:281;5907:27;5929:4;5907:27;:::i;:::-;5899:6;5895:40;6037:6;6025:10;6022:22;6001:18;5989:10;5986:34;5983:62;5980:88;;;6048:18;;:::i;:::-;5980:88;6088:10;6084:2;6077:22;5867:238;5824:281;;:::o;6111:129::-;6145:6;6172:20;;:::i;:::-;6162:30;;6201:33;6229:4;6221:6;6201:33;:::i;:::-;6111:129;;;:::o;6246:311::-;6323:4;6413:18;6405:6;6402:30;6399:56;;;6435:18;;:::i;:::-;6399:56;6485:4;6477:6;6473:17;6465:25;;6545:4;6539;6535:15;6527:23;;6246:311;;;:::o;6563:117::-;6672:1;6669;6662:12;6703:710;6799:5;6824:81;6840:64;6897:6;6840:64;:::i;:::-;6824:81;:::i;:::-;6815:90;;6925:5;6954:6;6947:5;6940:21;6988:4;6981:5;6977:16;6970:23;;7041:4;7033:6;7029:17;7021:6;7017:30;7070:3;7062:6;7059:15;7056:122;;;7089:79;;:::i;:::-;7056:122;7204:6;7187:220;7221:6;7216:3;7213:15;7187:220;;;7296:3;7325:37;7358:3;7346:10;7325:37;:::i;:::-;7320:3;7313:50;7392:4;7387:3;7383:14;7376:21;;7263:144;7247:4;7242:3;7238:14;7231:21;;7187:220;;;7191:21;6805:608;;6703:710;;;;;:::o;7436:370::-;7507:5;7556:3;7549:4;7541:6;7537:17;7533:27;7523:122;;7564:79;;:::i;:::-;7523:122;7681:6;7668:20;7706:94;7796:3;7788:6;7781:4;7773:6;7769:17;7706:94;:::i;:::-;7697:103;;7513:293;7436:370;;;;:::o;7812:117::-;7921:1;7918;7911:12;7935:307;7996:4;8086:18;8078:6;8075:30;8072:56;;;8108:18;;:::i;:::-;8072:56;8146:29;8168:6;8146:29;:::i;:::-;8138:37;;8230:4;8224;8220:15;8212:23;;7935:307;;;:::o;8248:146::-;8345:6;8340:3;8335;8322:30;8386:1;8377:6;8372:3;8368:16;8361:27;8248:146;;;:::o;8400:423::-;8477:5;8502:65;8518:48;8559:6;8518:48;:::i;:::-;8502:65;:::i;:::-;8493:74;;8590:6;8583:5;8576:21;8628:4;8621:5;8617:16;8666:3;8657:6;8652:3;8648:16;8645:25;8642:112;;;8673:79;;:::i;:::-;8642:112;8763:54;8810:6;8805:3;8800;8763:54;:::i;:::-;8483:340;8400:423;;;;;:::o;8842:338::-;8897:5;8946:3;8939:4;8931:6;8927:17;8923:27;8913:122;;8954:79;;:::i;:::-;8913:122;9071:6;9058:20;9096:78;9170:3;9162:6;9155:4;9147:6;9143:17;9096:78;:::i;:::-;9087:87;;8903:277;8842:338;;;;:::o;9186:1509::-;9340:6;9348;9356;9364;9372;9421:3;9409:9;9400:7;9396:23;9392:33;9389:120;;;9428:79;;:::i;:::-;9389:120;9548:1;9573:53;9618:7;9609:6;9598:9;9594:22;9573:53;:::i;:::-;9563:63;;9519:117;9675:2;9701:53;9746:7;9737:6;9726:9;9722:22;9701:53;:::i;:::-;9691:63;;9646:118;9831:2;9820:9;9816:18;9803:32;9862:18;9854:6;9851:30;9848:117;;;9884:79;;:::i;:::-;9848:117;9989:78;10059:7;10050:6;10039:9;10035:22;9989:78;:::i;:::-;9979:88;;9774:303;10144:2;10133:9;10129:18;10116:32;10175:18;10167:6;10164:30;10161:117;;;10197:79;;:::i;:::-;10161:117;10302:78;10372:7;10363:6;10352:9;10348:22;10302:78;:::i;:::-;10292:88;;10087:303;10457:3;10446:9;10442:19;10429:33;10489:18;10481:6;10478:30;10475:117;;;10511:79;;:::i;:::-;10475:117;10616:62;10670:7;10661:6;10650:9;10646:22;10616:62;:::i;:::-;10606:72;;10400:288;9186:1509;;;;;;;;:::o;10701:308::-;10763:4;10853:18;10845:6;10842:30;10839:56;;;10875:18;;:::i;:::-;10839:56;10913:29;10935:6;10913:29;:::i;:::-;10905:37;;10997:4;10991;10987:15;10979:23;;10701:308;;;:::o;11015:425::-;11093:5;11118:66;11134:49;11176:6;11134:49;:::i;:::-;11118:66;:::i;:::-;11109:75;;11207:6;11200:5;11193:21;11245:4;11238:5;11234:16;11283:3;11274:6;11269:3;11265:16;11262:25;11259:112;;;11290:79;;:::i;:::-;11259:112;11380:54;11427:6;11422:3;11417;11380:54;:::i;:::-;11099:341;11015:425;;;;;:::o;11460:340::-;11516:5;11565:3;11558:4;11550:6;11546:17;11542:27;11532:122;;11573:79;;:::i;:::-;11532:122;11690:6;11677:20;11715:79;11790:3;11782:6;11775:4;11767:6;11763:17;11715:79;:::i;:::-;11706:88;;11522:278;11460:340;;;;:::o;11806:509::-;11875:6;11924:2;11912:9;11903:7;11899:23;11895:32;11892:119;;;11930:79;;:::i;:::-;11892:119;12078:1;12067:9;12063:17;12050:31;12108:18;12100:6;12097:30;12094:117;;;12130:79;;:::i;:::-;12094:117;12235:63;12290:7;12281:6;12270:9;12266:22;12235:63;:::i;:::-;12225:73;;12021:287;11806:509;;;;:::o;12321:311::-;12398:4;12488:18;12480:6;12477:30;12474:56;;;12510:18;;:::i;:::-;12474:56;12560:4;12552:6;12548:17;12540:25;;12620:4;12614;12610:15;12602:23;;12321:311;;;:::o;12655:710::-;12751:5;12776:81;12792:64;12849:6;12792:64;:::i;:::-;12776:81;:::i;:::-;12767:90;;12877:5;12906:6;12899:5;12892:21;12940:4;12933:5;12929:16;12922:23;;12993:4;12985:6;12981:17;12973:6;12969:30;13022:3;13014:6;13011:15;13008:122;;;13041:79;;:::i;:::-;13008:122;13156:6;13139:220;13173:6;13168:3;13165:15;13139:220;;;13248:3;13277:37;13310:3;13298:10;13277:37;:::i;:::-;13272:3;13265:50;13344:4;13339:3;13335:14;13328:21;;13215:144;13199:4;13194:3;13190:14;13183:21;;13139:220;;;13143:21;12757:608;;12655:710;;;;;:::o;13388:370::-;13459:5;13508:3;13501:4;13493:6;13489:17;13485:27;13475:122;;13516:79;;:::i;:::-;13475:122;13633:6;13620:20;13658:94;13748:3;13740:6;13733:4;13725:6;13721:17;13658:94;:::i;:::-;13649:103;;13465:293;13388:370;;;;:::o;13764:894::-;13882:6;13890;13939:2;13927:9;13918:7;13914:23;13910:32;13907:119;;;13945:79;;:::i;:::-;13907:119;14093:1;14082:9;14078:17;14065:31;14123:18;14115:6;14112:30;14109:117;;;14145:79;;:::i;:::-;14109:117;14250:78;14320:7;14311:6;14300:9;14296:22;14250:78;:::i;:::-;14240:88;;14036:302;14405:2;14394:9;14390:18;14377:32;14436:18;14428:6;14425:30;14422:117;;;14458:79;;:::i;:::-;14422:117;14563:78;14633:7;14624:6;14613:9;14609:22;14563:78;:::i;:::-;14553:88;;14348:303;13764:894;;;;;:::o;14664:114::-;14731:6;14765:5;14759:12;14749:22;;14664:114;;;:::o;14784:184::-;14883:11;14917:6;14912:3;14905:19;14957:4;14952:3;14948:14;14933:29;;14784:184;;;;:::o;14974:132::-;15041:4;15064:3;15056:11;;15094:4;15089:3;15085:14;15077:22;;14974:132;;;:::o;15112:108::-;15189:24;15207:5;15189:24;:::i;:::-;15184:3;15177:37;15112:108;;:::o;15226:179::-;15295:10;15316:46;15358:3;15350:6;15316:46;:::i;:::-;15394:4;15389:3;15385:14;15371:28;;15226:179;;;;:::o;15411:113::-;15481:4;15513;15508:3;15504:14;15496:22;;15411:113;;;:::o;15560:732::-;15679:3;15708:54;15756:5;15708:54;:::i;:::-;15778:86;15857:6;15852:3;15778:86;:::i;:::-;15771:93;;15888:56;15938:5;15888:56;:::i;:::-;15967:7;15998:1;15983:284;16008:6;16005:1;16002:13;15983:284;;;16084:6;16078:13;16111:63;16170:3;16155:13;16111:63;:::i;:::-;16104:70;;16197:60;16250:6;16197:60;:::i;:::-;16187:70;;16043:224;16030:1;16027;16023:9;16018:14;;15983:284;;;15987:14;16283:3;16276:10;;15684:608;;;15560:732;;;;:::o;16298:373::-;16441:4;16479:2;16468:9;16464:18;16456:26;;16528:9;16522:4;16518:20;16514:1;16503:9;16499:17;16492:47;16556:108;16659:4;16650:6;16556:108;:::i;:::-;16548:116;;16298:373;;;;:::o;16677:118::-;16764:24;16782:5;16764:24;:::i;:::-;16759:3;16752:37;16677:118;;:::o;16801:222::-;16894:4;16932:2;16921:9;16917:18;16909:26;;16945:71;17013:1;17002:9;16998:17;16989:6;16945:71;:::i;:::-;16801:222;;;;:::o;17029:116::-;17099:21;17114:5;17099:21;:::i;:::-;17092:5;17089:32;17079:60;;17135:1;17132;17125:12;17079:60;17029:116;:::o;17151:133::-;17194:5;17232:6;17219:20;17210:29;;17248:30;17272:5;17248:30;:::i;:::-;17151:133;;;;:::o;17290:468::-;17355:6;17363;17412:2;17400:9;17391:7;17387:23;17383:32;17380:119;;;17418:79;;:::i;:::-;17380:119;17538:1;17563:53;17608:7;17599:6;17588:9;17584:22;17563:53;:::i;:::-;17553:63;;17509:117;17665:2;17691:50;17733:7;17724:6;17713:9;17709:22;17691:50;:::i;:::-;17681:60;;17636:115;17290:468;;;;;:::o;17764:474::-;17832:6;17840;17889:2;17877:9;17868:7;17864:23;17860:32;17857:119;;;17895:79;;:::i;:::-;17857:119;18015:1;18040:53;18085:7;18076:6;18065:9;18061:22;18040:53;:::i;:::-;18030:63;;17986:117;18142:2;18168:53;18213:7;18204:6;18193:9;18189:22;18168:53;:::i;:::-;18158:63;;18113:118;17764:474;;;;;:::o;18244:1089::-;18348:6;18356;18364;18372;18380;18429:3;18417:9;18408:7;18404:23;18400:33;18397:120;;;18436:79;;:::i;:::-;18397:120;18556:1;18581:53;18626:7;18617:6;18606:9;18602:22;18581:53;:::i;:::-;18571:63;;18527:117;18683:2;18709:53;18754:7;18745:6;18734:9;18730:22;18709:53;:::i;:::-;18699:63;;18654:118;18811:2;18837:53;18882:7;18873:6;18862:9;18858:22;18837:53;:::i;:::-;18827:63;;18782:118;18939:2;18965:53;19010:7;19001:6;18990:9;18986:22;18965:53;:::i;:::-;18955:63;;18910:118;19095:3;19084:9;19080:19;19067:33;19127:18;19119:6;19116:30;19113:117;;;19149:79;;:::i;:::-;19113:117;19254:62;19308:7;19299:6;19288:9;19284:22;19254:62;:::i;:::-;19244:72;;19038:288;18244:1089;;;;;;;;:::o;19339:329::-;19398:6;19447:2;19435:9;19426:7;19422:23;19418:32;19415:119;;;19453:79;;:::i;:::-;19415:119;19573:1;19598:53;19643:7;19634:6;19623:9;19619:22;19598:53;:::i;:::-;19588:63;;19544:117;19339:329;;;;:::o;19674:180::-;19722:77;19719:1;19712:88;19819:4;19816:1;19809:15;19843:4;19840:1;19833:15;19860:320;19904:6;19941:1;19935:4;19931:12;19921:22;;19988:1;19982:4;19978:12;20009:18;19999:81;;20065:4;20057:6;20053:17;20043:27;;19999:81;20127:2;20119:6;20116:14;20096:18;20093:38;20090:84;;20146:18;;:::i;:::-;20090:84;19911:269;19860:320;;;:::o;20186:166::-;20326:18;20322:1;20314:6;20310:14;20303:42;20186:166;:::o;20358:366::-;20500:3;20521:67;20585:2;20580:3;20521:67;:::i;:::-;20514:74;;20597:93;20686:3;20597:93;:::i;:::-;20715:2;20710:3;20706:12;20699:19;;20358:366;;;:::o;20730:419::-;20896:4;20934:2;20923:9;20919:18;20911:26;;20983:9;20977:4;20973:20;20969:1;20958:9;20954:17;20947:47;21011:131;21137:4;21011:131;:::i;:::-;21003:139;;20730:419;;;:::o;21155:332::-;21276:4;21314:2;21303:9;21299:18;21291:26;;21327:71;21395:1;21384:9;21380:17;21371:6;21327:71;:::i;:::-;21408:72;21476:2;21465:9;21461:18;21452:6;21408:72;:::i;:::-;21155:332;;;;;:::o;21493:180::-;21541:77;21538:1;21531:88;21638:4;21635:1;21628:15;21662:4;21659:1;21652:15;21679:233;21718:3;21741:24;21759:5;21741:24;:::i;:::-;21732:33;;21787:66;21780:5;21777:77;21774:103;;21857:18;;:::i;:::-;21774:103;21904:1;21897:5;21893:13;21886:20;;21679:233;;;:::o;21918:332::-;22039:4;22077:2;22066:9;22062:18;22054:26;;22090:71;22158:1;22147:9;22143:17;22134:6;22090:71;:::i;:::-;22171:72;22239:2;22228:9;22224:18;22215:6;22171:72;:::i;:::-;21918:332;;;;;:::o;22256:180::-;22304:77;22301:1;22294:88;22401:4;22398:1;22391:15;22425:4;22422:1;22415:15;22442:141;22491:4;22514:3;22506:11;;22537:3;22534:1;22527:14;22571:4;22568:1;22558:18;22550:26;;22442:141;;;:::o;22589:93::-;22626:6;22673:2;22668;22661:5;22657:14;22653:23;22643:33;;22589:93;;;:::o;22688:107::-;22732:8;22782:5;22776:4;22772:16;22751:37;;22688:107;;;;:::o;22801:393::-;22870:6;22920:1;22908:10;22904:18;22943:97;22973:66;22962:9;22943:97;:::i;:::-;23061:39;23091:8;23080:9;23061:39;:::i;:::-;23049:51;;23133:4;23129:9;23122:5;23118:21;23109:30;;23182:4;23172:8;23168:19;23161:5;23158:30;23148:40;;22877:317;;22801:393;;;;;:::o;23200:60::-;23228:3;23249:5;23242:12;;23200:60;;;:::o;23266:142::-;23316:9;23349:53;23367:34;23376:24;23394:5;23376:24;:::i;:::-;23367:34;:::i;:::-;23349:53;:::i;:::-;23336:66;;23266:142;;;:::o;23414:75::-;23457:3;23478:5;23471:12;;23414:75;;;:::o;23495:269::-;23605:39;23636:7;23605:39;:::i;:::-;23666:91;23715:41;23739:16;23715:41;:::i;:::-;23707:6;23700:4;23694:11;23666:91;:::i;:::-;23660:4;23653:105;23571:193;23495:269;;;:::o;23770:73::-;23815:3;23770:73;:::o;23849:189::-;23926:32;;:::i;:::-;23967:65;24025:6;24017;24011:4;23967:65;:::i;:::-;23902:136;23849:189;;:::o;24044:186::-;24104:120;24121:3;24114:5;24111:14;24104:120;;;24175:39;24212:1;24205:5;24175:39;:::i;:::-;24148:1;24141:5;24137:13;24128:22;;24104:120;;;24044:186;;:::o;24236:543::-;24337:2;24332:3;24329:11;24326:446;;;24371:38;24403:5;24371:38;:::i;:::-;24455:29;24473:10;24455:29;:::i;:::-;24445:8;24441:44;24638:2;24626:10;24623:18;24620:49;;;24659:8;24644:23;;24620:49;24682:80;24738:22;24756:3;24738:22;:::i;:::-;24728:8;24724:37;24711:11;24682:80;:::i;:::-;24341:431;;24326:446;24236:543;;;:::o;24785:117::-;24839:8;24889:5;24883:4;24879:16;24858:37;;24785:117;;;;:::o;24908:169::-;24952:6;24985:51;25033:1;25029:6;25021:5;25018:1;25014:13;24985:51;:::i;:::-;24981:56;25066:4;25060;25056:15;25046:25;;24959:118;24908:169;;;;:::o;25082:295::-;25158:4;25304:29;25329:3;25323:4;25304:29;:::i;:::-;25296:37;;25366:3;25363:1;25359:11;25353:4;25350:21;25342:29;;25082:295;;;;:::o;25382:1395::-;25499:37;25532:3;25499:37;:::i;:::-;25601:18;25593:6;25590:30;25587:56;;;25623:18;;:::i;:::-;25587:56;25667:38;25699:4;25693:11;25667:38;:::i;:::-;25752:67;25812:6;25804;25798:4;25752:67;:::i;:::-;25846:1;25870:4;25857:17;;25902:2;25894:6;25891:14;25919:1;25914:618;;;;26576:1;26593:6;26590:77;;;26642:9;26637:3;26633:19;26627:26;26618:35;;26590:77;26693:67;26753:6;26746:5;26693:67;:::i;:::-;26687:4;26680:81;26549:222;25884:887;;25914:618;25966:4;25962:9;25954:6;25950:22;26000:37;26032:4;26000:37;:::i;:::-;26059:1;26073:208;26087:7;26084:1;26081:14;26073:208;;;26166:9;26161:3;26157:19;26151:26;26143:6;26136:42;26217:1;26209:6;26205:14;26195:24;;26264:2;26253:9;26249:18;26236:31;;26110:4;26107:1;26103:12;26098:17;;26073:208;;;26309:6;26300:7;26297:19;26294:179;;;26367:9;26362:3;26358:19;26352:26;26410:48;26452:4;26444:6;26440:17;26429:9;26410:48;:::i;:::-;26402:6;26395:64;26317:156;26294:179;26519:1;26515;26507:6;26503:14;26499:22;26493:4;26486:36;25921:611;;;25884:887;;25474:1303;;;25382:1395;;:::o;26783:553::-;26960:4;26998:3;26987:9;26983:19;26975:27;;27012:71;27080:1;27069:9;27065:17;27056:6;27012:71;:::i;:::-;27093:72;27161:2;27150:9;27146:18;27137:6;27093:72;:::i;:::-;27175;27243:2;27232:9;27228:18;27219:6;27175:72;:::i;:::-;27257;27325:2;27314:9;27310:18;27301:6;27257:72;:::i;:::-;26783:553;;;;;;;:::o;27342:191::-;27382:3;27401:20;27419:1;27401:20;:::i;:::-;27396:25;;27435:20;27453:1;27435:20;:::i;:::-;27430:25;;27478:1;27475;27471:9;27464:16;;27499:3;27496:1;27493:10;27490:36;;;27506:18;;:::i;:::-;27490:36;27342:191;;;;:::o;27539:634::-;27760:4;27798:2;27787:9;27783:18;27775:26;;27847:9;27841:4;27837:20;27833:1;27822:9;27818:17;27811:47;27875:108;27978:4;27969:6;27875:108;:::i;:::-;27867:116;;28030:9;28024:4;28020:20;28015:2;28004:9;28000:18;27993:48;28058:108;28161:4;28152:6;28058:108;:::i;:::-;28050:116;;27539:634;;;;;:::o;28179:98::-;28230:6;28264:5;28258:12;28248:22;;28179:98;;;:::o;28283:168::-;28366:11;28400:6;28395:3;28388:19;28440:4;28435:3;28431:14;28416:29;;28283:168;;;;:::o;28457:373::-;28543:3;28571:38;28603:5;28571:38;:::i;:::-;28625:70;28688:6;28683:3;28625:70;:::i;:::-;28618:77;;28704:65;28762:6;28757:3;28750:4;28743:5;28739:16;28704:65;:::i;:::-;28794:29;28816:6;28794:29;:::i;:::-;28789:3;28785:39;28778:46;;28547:283;28457:373;;;;:::o;28836:751::-;29059:4;29097:3;29086:9;29082:19;29074:27;;29111:71;29179:1;29168:9;29164:17;29155:6;29111:71;:::i;:::-;29192:72;29260:2;29249:9;29245:18;29236:6;29192:72;:::i;:::-;29274;29342:2;29331:9;29327:18;29318:6;29274:72;:::i;:::-;29356;29424:2;29413:9;29409:18;29400:6;29356:72;:::i;:::-;29476:9;29470:4;29466:20;29460:3;29449:9;29445:19;29438:49;29504:76;29575:4;29566:6;29504:76;:::i;:::-;29496:84;;28836:751;;;;;;;;:::o;29593:141::-;29649:5;29680:6;29674:13;29665:22;;29696:32;29722:5;29696:32;:::i;:::-;29593:141;;;;:::o;29740:349::-;29809:6;29858:2;29846:9;29837:7;29833:23;29829:32;29826:119;;;29864:79;;:::i;:::-;29826:119;29984:1;30009:63;30064:7;30055:6;30044:9;30040:22;30009:63;:::i;:::-;29999:73;;29955:127;29740:349;;;;:::o;30095:1053::-;30418:4;30456:3;30445:9;30441:19;30433:27;;30470:71;30538:1;30527:9;30523:17;30514:6;30470:71;:::i;:::-;30551:72;30619:2;30608:9;30604:18;30595:6;30551:72;:::i;:::-;30670:9;30664:4;30660:20;30655:2;30644:9;30640:18;30633:48;30698:108;30801:4;30792:6;30698:108;:::i;:::-;30690:116;;30853:9;30847:4;30843:20;30838:2;30827:9;30823:18;30816:48;30881:108;30984:4;30975:6;30881:108;:::i;:::-;30873:116;;31037:9;31031:4;31027:20;31021:3;31010:9;31006:19;30999:49;31065:76;31136:4;31127:6;31065:76;:::i;:::-;31057:84;;30095:1053;;;;;;;;:::o
Swarm Source
ipfs://0f7b208fc5341d58c91f967dc80eb76e94ca94e550024f7ad1cb9678ca8c1827
[ 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.