FoxTrove (FoxTrove)
Overview
TokenID
45
Total Transfers
-
Market
Onchain Market Cap
$0.00
Circulating Supply Market Cap
-
Other Info
Token Contract
Loading...
Loading
Loading...
Loading
Loading...
Loading
Contract Name:
FoxTrove
Compiler Version
v0.8.20+commit.a1b79de6
Contract Source Code (Solidity)
/**
*Submitted for verification at curtis.apescan.io on 2024-11-19
*/
// File: @openzeppelin/contracts/utils/introspection/IERC165.sol
// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/IERC165.sol)
pragma solidity ^0.8.20;
/**
* @dev Interface of the ERC-165 standard, as defined in the
* https://eips.ethereum.org/EIPS/eip-165[ERC].
*
* 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[ERC section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
// File: @openzeppelin/contracts/token/ERC721/IERC721.sol
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC721/IERC721.sol)
pragma solidity ^0.8.20;
/**
* @dev Required interface of an ERC-721 compliant contract.
*/
interface IERC721 is IERC165 {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
*/
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/**
* @dev Returns the number of tokens in ``owner``'s account.
*/
function balanceOf(address owner) external view returns (uint256 balance);
/**
* @dev Returns the owner of the `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function ownerOf(uint256 tokenId) external view returns (address owner);
/**
* @dev Safely transfers `tokenId` token from `from` to `to`.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon
* a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC-721 protocol to prevent tokens from being forever locked.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must have been allowed to move this token by either {approve} or
* {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon
* a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(address from, address to, uint256 tokenId) external;
/**
* @dev Transfers `tokenId` token from `from` to `to`.
*
* WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC-721
* or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
* understand this adds an external call which potentially creates a reentrancy vulnerability.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
*
* Emits a {Transfer} event.
*/
function transferFrom(address from, address to, uint256 tokenId) external;
/**
* @dev Gives permission to `to` to transfer `tokenId` token to another account.
* The approval is cleared when the token is transferred.
*
* Only a single account can be approved at a time, so approving the zero address clears previous approvals.
*
* Requirements:
*
* - The caller must own the token or be an approved operator.
* - `tokenId` must exist.
*
* Emits an {Approval} event.
*/
function approve(address to, uint256 tokenId) external;
/**
* @dev Approve or remove `operator` as an operator for the caller.
* Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
*
* Requirements:
*
* - The `operator` cannot be the address zero.
*
* Emits an {ApprovalForAll} event.
*/
function setApprovalForAll(address operator, bool approved) external;
/**
* @dev Returns the account approved for `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function getApproved(uint256 tokenId) external view returns (address operator);
/**
* @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
*
* See {setApprovalForAll}
*/
function isApprovedForAll(address owner, address operator) external view returns (bool);
}
// File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/IERC721Metadata.sol)
pragma solidity ^0.8.20;
/**
* @title ERC-721 Non-Fungible Token Standard, optional metadata extension
* @dev See https://eips.ethereum.org/EIPS/eip-721
*/
interface IERC721Metadata is IERC721 {
/**
* @dev Returns the token collection name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the token collection symbol.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 tokenId) external view returns (string memory);
}
// File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC721/IERC721Receiver.sol)
pragma solidity ^0.8.20;
/**
* @title ERC-721 token receiver interface
* @dev Interface for any contract that wants to support safeTransfers
* from ERC-721 asset contracts.
*/
interface IERC721Receiver {
/**
* @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
* by `operator` from `from`, this function is called.
*
* It must return its Solidity selector to confirm the token transfer.
* If any other value is returned or the interface is not implemented by the recipient, the transfer will be
* reverted.
*
* The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
*/
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
// File: @openzeppelin/contracts/interfaces/draft-IERC6093.sol
// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/draft-IERC6093.sol)
pragma solidity ^0.8.20;
/**
* @dev Standard ERC-20 Errors
* Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-20 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 ERC-721 Errors
* Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-721 tokens.
*/
interface IERC721Errors {
/**
* @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-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 ERC-1155 Errors
* Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-1155 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/token/ERC721/utils/ERC721Utils.sol
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC721/utils/ERC721Utils.sol)
pragma solidity ^0.8.20;
/**
* @dev Library that provide common ERC-721 utility functions.
*
* See https://eips.ethereum.org/EIPS/eip-721[ERC-721].
*
* _Available since v5.1._
*/
library ERC721Utils {
/**
* @dev Performs an acceptance check for the provided `operator` by calling {IERC721-onERC721Received}
* on the `to` address. The `operator` is generally the address that initiated the token transfer (i.e. `msg.sender`).
*
* The acceptance call is not executed and treated as a no-op if the target address doesn't contain code (i.e. an EOA).
* Otherwise, the recipient must implement {IERC721Receiver-onERC721Received} and return the acceptance magic value to accept
* the transfer.
*/
function checkOnERC721Received(
address operator,
address from,
address to,
uint256 tokenId,
bytes memory data
) internal {
if (to.code.length > 0) {
try IERC721Receiver(to).onERC721Received(operator, from, tokenId, data) returns (bytes4 retval) {
if (retval != IERC721Receiver.onERC721Received.selector) {
// Token rejected
revert IERC721Errors.ERC721InvalidReceiver(to);
}
} catch (bytes memory reason) {
if (reason.length == 0) {
// non-IERC721Receiver implementer
revert IERC721Errors.ERC721InvalidReceiver(to);
} else {
assembly ("memory-safe") {
revert(add(32, reason), mload(reason))
}
}
}
}
}
}
// File: @openzeppelin/contracts/utils/Context.sol
// OpenZeppelin Contracts (last updated v5.0.1) (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;
}
function _contextSuffixLength() internal view virtual returns (uint256) {
return 0;
}
}
// File: @openzeppelin/contracts/utils/Panic.sol
// OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)
pragma solidity ^0.8.20;
/**
* @dev Helper library for emitting standardized panic codes.
*
* ```solidity
* contract Example {
* using Panic for uint256;
*
* // Use any of the declared internal constants
* function foo() { Panic.GENERIC.panic(); }
*
* // Alternatively
* function foo() { Panic.panic(Panic.GENERIC); }
* }
* ```
*
* Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].
*
* _Available since v5.1._
*/
// slither-disable-next-line unused-state
library Panic {
/// @dev generic / unspecified error
uint256 internal constant GENERIC = 0x00;
/// @dev used by the assert() builtin
uint256 internal constant ASSERT = 0x01;
/// @dev arithmetic underflow or overflow
uint256 internal constant UNDER_OVERFLOW = 0x11;
/// @dev division or modulo by zero
uint256 internal constant DIVISION_BY_ZERO = 0x12;
/// @dev enum conversion error
uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;
/// @dev invalid encoding in storage
uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;
/// @dev empty array pop
uint256 internal constant EMPTY_ARRAY_POP = 0x31;
/// @dev array out of bounds access
uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;
/// @dev resource error (too large allocation or too large array)
uint256 internal constant RESOURCE_ERROR = 0x41;
/// @dev calling invalid internal function
uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;
/// @dev Reverts with a panic code. Recommended to use with
/// the internal constants with predefined codes.
function panic(uint256 code) internal pure {
assembly ("memory-safe") {
mstore(0x00, 0x4e487b71)
mstore(0x20, code)
revert(0x1c, 0x24)
}
}
}
// File: @openzeppelin/contracts/utils/math/SafeCast.sol
// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)
// This file was procedurally generated from scripts/generate/templates/SafeCast.js.
pragma solidity ^0.8.20;
/**
* @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow
* checks.
*
* Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
* easily result in undesired exploitation or bugs, since developers usually
* assume that overflows raise errors. `SafeCast` restores this intuition by
* reverting the transaction when such an operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
library SafeCast {
/**
* @dev Value doesn't fit in an uint of `bits` size.
*/
error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);
/**
* @dev An int value doesn't fit in an uint of `bits` size.
*/
error SafeCastOverflowedIntToUint(int256 value);
/**
* @dev Value doesn't fit in an int of `bits` size.
*/
error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);
/**
* @dev An uint value doesn't fit in an int of `bits` size.
*/
error SafeCastOverflowedUintToInt(uint256 value);
/**
* @dev Returns the downcasted uint248 from uint256, reverting on
* overflow (when the input is greater than largest uint248).
*
* Counterpart to Solidity's `uint248` operator.
*
* Requirements:
*
* - input must fit into 248 bits
*/
function toUint248(uint256 value) internal pure returns (uint248) {
if (value > type(uint248).max) {
revert SafeCastOverflowedUintDowncast(248, value);
}
return uint248(value);
}
/**
* @dev Returns the downcasted uint240 from uint256, reverting on
* overflow (when the input is greater than largest uint240).
*
* Counterpart to Solidity's `uint240` operator.
*
* Requirements:
*
* - input must fit into 240 bits
*/
function toUint240(uint256 value) internal pure returns (uint240) {
if (value > type(uint240).max) {
revert SafeCastOverflowedUintDowncast(240, value);
}
return uint240(value);
}
/**
* @dev Returns the downcasted uint232 from uint256, reverting on
* overflow (when the input is greater than largest uint232).
*
* Counterpart to Solidity's `uint232` operator.
*
* Requirements:
*
* - input must fit into 232 bits
*/
function toUint232(uint256 value) internal pure returns (uint232) {
if (value > type(uint232).max) {
revert SafeCastOverflowedUintDowncast(232, value);
}
return uint232(value);
}
/**
* @dev Returns the downcasted uint224 from uint256, reverting on
* overflow (when the input is greater than largest uint224).
*
* Counterpart to Solidity's `uint224` operator.
*
* Requirements:
*
* - input must fit into 224 bits
*/
function toUint224(uint256 value) internal pure returns (uint224) {
if (value > type(uint224).max) {
revert SafeCastOverflowedUintDowncast(224, value);
}
return uint224(value);
}
/**
* @dev Returns the downcasted uint216 from uint256, reverting on
* overflow (when the input is greater than largest uint216).
*
* Counterpart to Solidity's `uint216` operator.
*
* Requirements:
*
* - input must fit into 216 bits
*/
function toUint216(uint256 value) internal pure returns (uint216) {
if (value > type(uint216).max) {
revert SafeCastOverflowedUintDowncast(216, value);
}
return uint216(value);
}
/**
* @dev Returns the downcasted uint208 from uint256, reverting on
* overflow (when the input is greater than largest uint208).
*
* Counterpart to Solidity's `uint208` operator.
*
* Requirements:
*
* - input must fit into 208 bits
*/
function toUint208(uint256 value) internal pure returns (uint208) {
if (value > type(uint208).max) {
revert SafeCastOverflowedUintDowncast(208, value);
}
return uint208(value);
}
/**
* @dev Returns the downcasted uint200 from uint256, reverting on
* overflow (when the input is greater than largest uint200).
*
* Counterpart to Solidity's `uint200` operator.
*
* Requirements:
*
* - input must fit into 200 bits
*/
function toUint200(uint256 value) internal pure returns (uint200) {
if (value > type(uint200).max) {
revert SafeCastOverflowedUintDowncast(200, value);
}
return uint200(value);
}
/**
* @dev Returns the downcasted uint192 from uint256, reverting on
* overflow (when the input is greater than largest uint192).
*
* Counterpart to Solidity's `uint192` operator.
*
* Requirements:
*
* - input must fit into 192 bits
*/
function toUint192(uint256 value) internal pure returns (uint192) {
if (value > type(uint192).max) {
revert SafeCastOverflowedUintDowncast(192, value);
}
return uint192(value);
}
/**
* @dev Returns the downcasted uint184 from uint256, reverting on
* overflow (when the input is greater than largest uint184).
*
* Counterpart to Solidity's `uint184` operator.
*
* Requirements:
*
* - input must fit into 184 bits
*/
function toUint184(uint256 value) internal pure returns (uint184) {
if (value > type(uint184).max) {
revert SafeCastOverflowedUintDowncast(184, value);
}
return uint184(value);
}
/**
* @dev Returns the downcasted uint176 from uint256, reverting on
* overflow (when the input is greater than largest uint176).
*
* Counterpart to Solidity's `uint176` operator.
*
* Requirements:
*
* - input must fit into 176 bits
*/
function toUint176(uint256 value) internal pure returns (uint176) {
if (value > type(uint176).max) {
revert SafeCastOverflowedUintDowncast(176, value);
}
return uint176(value);
}
/**
* @dev Returns the downcasted uint168 from uint256, reverting on
* overflow (when the input is greater than largest uint168).
*
* Counterpart to Solidity's `uint168` operator.
*
* Requirements:
*
* - input must fit into 168 bits
*/
function toUint168(uint256 value) internal pure returns (uint168) {
if (value > type(uint168).max) {
revert SafeCastOverflowedUintDowncast(168, value);
}
return uint168(value);
}
/**
* @dev Returns the downcasted uint160 from uint256, reverting on
* overflow (when the input is greater than largest uint160).
*
* Counterpart to Solidity's `uint160` operator.
*
* Requirements:
*
* - input must fit into 160 bits
*/
function toUint160(uint256 value) internal pure returns (uint160) {
if (value > type(uint160).max) {
revert SafeCastOverflowedUintDowncast(160, value);
}
return uint160(value);
}
/**
* @dev Returns the downcasted uint152 from uint256, reverting on
* overflow (when the input is greater than largest uint152).
*
* Counterpart to Solidity's `uint152` operator.
*
* Requirements:
*
* - input must fit into 152 bits
*/
function toUint152(uint256 value) internal pure returns (uint152) {
if (value > type(uint152).max) {
revert SafeCastOverflowedUintDowncast(152, value);
}
return uint152(value);
}
/**
* @dev Returns the downcasted uint144 from uint256, reverting on
* overflow (when the input is greater than largest uint144).
*
* Counterpart to Solidity's `uint144` operator.
*
* Requirements:
*
* - input must fit into 144 bits
*/
function toUint144(uint256 value) internal pure returns (uint144) {
if (value > type(uint144).max) {
revert SafeCastOverflowedUintDowncast(144, value);
}
return uint144(value);
}
/**
* @dev Returns the downcasted uint136 from uint256, reverting on
* overflow (when the input is greater than largest uint136).
*
* Counterpart to Solidity's `uint136` operator.
*
* Requirements:
*
* - input must fit into 136 bits
*/
function toUint136(uint256 value) internal pure returns (uint136) {
if (value > type(uint136).max) {
revert SafeCastOverflowedUintDowncast(136, value);
}
return uint136(value);
}
/**
* @dev Returns the downcasted uint128 from uint256, reverting on
* overflow (when the input is greater than largest uint128).
*
* Counterpart to Solidity's `uint128` operator.
*
* Requirements:
*
* - input must fit into 128 bits
*/
function toUint128(uint256 value) internal pure returns (uint128) {
if (value > type(uint128).max) {
revert SafeCastOverflowedUintDowncast(128, value);
}
return uint128(value);
}
/**
* @dev Returns the downcasted uint120 from uint256, reverting on
* overflow (when the input is greater than largest uint120).
*
* Counterpart to Solidity's `uint120` operator.
*
* Requirements:
*
* - input must fit into 120 bits
*/
function toUint120(uint256 value) internal pure returns (uint120) {
if (value > type(uint120).max) {
revert SafeCastOverflowedUintDowncast(120, value);
}
return uint120(value);
}
/**
* @dev Returns the downcasted uint112 from uint256, reverting on
* overflow (when the input is greater than largest uint112).
*
* Counterpart to Solidity's `uint112` operator.
*
* Requirements:
*
* - input must fit into 112 bits
*/
function toUint112(uint256 value) internal pure returns (uint112) {
if (value > type(uint112).max) {
revert SafeCastOverflowedUintDowncast(112, value);
}
return uint112(value);
}
/**
* @dev Returns the downcasted uint104 from uint256, reverting on
* overflow (when the input is greater than largest uint104).
*
* Counterpart to Solidity's `uint104` operator.
*
* Requirements:
*
* - input must fit into 104 bits
*/
function toUint104(uint256 value) internal pure returns (uint104) {
if (value > type(uint104).max) {
revert SafeCastOverflowedUintDowncast(104, value);
}
return uint104(value);
}
/**
* @dev Returns the downcasted uint96 from uint256, reverting on
* overflow (when the input is greater than largest uint96).
*
* Counterpart to Solidity's `uint96` operator.
*
* Requirements:
*
* - input must fit into 96 bits
*/
function toUint96(uint256 value) internal pure returns (uint96) {
if (value > type(uint96).max) {
revert SafeCastOverflowedUintDowncast(96, value);
}
return uint96(value);
}
/**
* @dev Returns the downcasted uint88 from uint256, reverting on
* overflow (when the input is greater than largest uint88).
*
* Counterpart to Solidity's `uint88` operator.
*
* Requirements:
*
* - input must fit into 88 bits
*/
function toUint88(uint256 value) internal pure returns (uint88) {
if (value > type(uint88).max) {
revert SafeCastOverflowedUintDowncast(88, value);
}
return uint88(value);
}
/**
* @dev Returns the downcasted uint80 from uint256, reverting on
* overflow (when the input is greater than largest uint80).
*
* Counterpart to Solidity's `uint80` operator.
*
* Requirements:
*
* - input must fit into 80 bits
*/
function toUint80(uint256 value) internal pure returns (uint80) {
if (value > type(uint80).max) {
revert SafeCastOverflowedUintDowncast(80, value);
}
return uint80(value);
}
/**
* @dev Returns the downcasted uint72 from uint256, reverting on
* overflow (when the input is greater than largest uint72).
*
* Counterpart to Solidity's `uint72` operator.
*
* Requirements:
*
* - input must fit into 72 bits
*/
function toUint72(uint256 value) internal pure returns (uint72) {
if (value > type(uint72).max) {
revert SafeCastOverflowedUintDowncast(72, value);
}
return uint72(value);
}
/**
* @dev Returns the downcasted uint64 from uint256, reverting on
* overflow (when the input is greater than largest uint64).
*
* Counterpart to Solidity's `uint64` operator.
*
* Requirements:
*
* - input must fit into 64 bits
*/
function toUint64(uint256 value) internal pure returns (uint64) {
if (value > type(uint64).max) {
revert SafeCastOverflowedUintDowncast(64, value);
}
return uint64(value);
}
/**
* @dev Returns the downcasted uint56 from uint256, reverting on
* overflow (when the input is greater than largest uint56).
*
* Counterpart to Solidity's `uint56` operator.
*
* Requirements:
*
* - input must fit into 56 bits
*/
function toUint56(uint256 value) internal pure returns (uint56) {
if (value > type(uint56).max) {
revert SafeCastOverflowedUintDowncast(56, value);
}
return uint56(value);
}
/**
* @dev Returns the downcasted uint48 from uint256, reverting on
* overflow (when the input is greater than largest uint48).
*
* Counterpart to Solidity's `uint48` operator.
*
* Requirements:
*
* - input must fit into 48 bits
*/
function toUint48(uint256 value) internal pure returns (uint48) {
if (value > type(uint48).max) {
revert SafeCastOverflowedUintDowncast(48, value);
}
return uint48(value);
}
/**
* @dev Returns the downcasted uint40 from uint256, reverting on
* overflow (when the input is greater than largest uint40).
*
* Counterpart to Solidity's `uint40` operator.
*
* Requirements:
*
* - input must fit into 40 bits
*/
function toUint40(uint256 value) internal pure returns (uint40) {
if (value > type(uint40).max) {
revert SafeCastOverflowedUintDowncast(40, value);
}
return uint40(value);
}
/**
* @dev Returns the downcasted uint32 from uint256, reverting on
* overflow (when the input is greater than largest uint32).
*
* Counterpart to Solidity's `uint32` operator.
*
* Requirements:
*
* - input must fit into 32 bits
*/
function toUint32(uint256 value) internal pure returns (uint32) {
if (value > type(uint32).max) {
revert SafeCastOverflowedUintDowncast(32, value);
}
return uint32(value);
}
/**
* @dev Returns the downcasted uint24 from uint256, reverting on
* overflow (when the input is greater than largest uint24).
*
* Counterpart to Solidity's `uint24` operator.
*
* Requirements:
*
* - input must fit into 24 bits
*/
function toUint24(uint256 value) internal pure returns (uint24) {
if (value > type(uint24).max) {
revert SafeCastOverflowedUintDowncast(24, value);
}
return uint24(value);
}
/**
* @dev Returns the downcasted uint16 from uint256, reverting on
* overflow (when the input is greater than largest uint16).
*
* Counterpart to Solidity's `uint16` operator.
*
* Requirements:
*
* - input must fit into 16 bits
*/
function toUint16(uint256 value) internal pure returns (uint16) {
if (value > type(uint16).max) {
revert SafeCastOverflowedUintDowncast(16, value);
}
return uint16(value);
}
/**
* @dev Returns the downcasted uint8 from uint256, reverting on
* overflow (when the input is greater than largest uint8).
*
* Counterpart to Solidity's `uint8` operator.
*
* Requirements:
*
* - input must fit into 8 bits
*/
function toUint8(uint256 value) internal pure returns (uint8) {
if (value > type(uint8).max) {
revert SafeCastOverflowedUintDowncast(8, value);
}
return uint8(value);
}
/**
* @dev Converts a signed int256 into an unsigned uint256.
*
* Requirements:
*
* - input must be greater than or equal to 0.
*/
function toUint256(int256 value) internal pure returns (uint256) {
if (value < 0) {
revert SafeCastOverflowedIntToUint(value);
}
return uint256(value);
}
/**
* @dev Returns the downcasted int248 from int256, reverting on
* overflow (when the input is less than smallest int248 or
* greater than largest int248).
*
* Counterpart to Solidity's `int248` operator.
*
* Requirements:
*
* - input must fit into 248 bits
*/
function toInt248(int256 value) internal pure returns (int248 downcasted) {
downcasted = int248(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(248, value);
}
}
/**
* @dev Returns the downcasted int240 from int256, reverting on
* overflow (when the input is less than smallest int240 or
* greater than largest int240).
*
* Counterpart to Solidity's `int240` operator.
*
* Requirements:
*
* - input must fit into 240 bits
*/
function toInt240(int256 value) internal pure returns (int240 downcasted) {
downcasted = int240(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(240, value);
}
}
/**
* @dev Returns the downcasted int232 from int256, reverting on
* overflow (when the input is less than smallest int232 or
* greater than largest int232).
*
* Counterpart to Solidity's `int232` operator.
*
* Requirements:
*
* - input must fit into 232 bits
*/
function toInt232(int256 value) internal pure returns (int232 downcasted) {
downcasted = int232(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(232, value);
}
}
/**
* @dev Returns the downcasted int224 from int256, reverting on
* overflow (when the input is less than smallest int224 or
* greater than largest int224).
*
* Counterpart to Solidity's `int224` operator.
*
* Requirements:
*
* - input must fit into 224 bits
*/
function toInt224(int256 value) internal pure returns (int224 downcasted) {
downcasted = int224(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(224, value);
}
}
/**
* @dev Returns the downcasted int216 from int256, reverting on
* overflow (when the input is less than smallest int216 or
* greater than largest int216).
*
* Counterpart to Solidity's `int216` operator.
*
* Requirements:
*
* - input must fit into 216 bits
*/
function toInt216(int256 value) internal pure returns (int216 downcasted) {
downcasted = int216(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(216, value);
}
}
/**
* @dev Returns the downcasted int208 from int256, reverting on
* overflow (when the input is less than smallest int208 or
* greater than largest int208).
*
* Counterpart to Solidity's `int208` operator.
*
* Requirements:
*
* - input must fit into 208 bits
*/
function toInt208(int256 value) internal pure returns (int208 downcasted) {
downcasted = int208(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(208, value);
}
}
/**
* @dev Returns the downcasted int200 from int256, reverting on
* overflow (when the input is less than smallest int200 or
* greater than largest int200).
*
* Counterpart to Solidity's `int200` operator.
*
* Requirements:
*
* - input must fit into 200 bits
*/
function toInt200(int256 value) internal pure returns (int200 downcasted) {
downcasted = int200(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(200, value);
}
}
/**
* @dev Returns the downcasted int192 from int256, reverting on
* overflow (when the input is less than smallest int192 or
* greater than largest int192).
*
* Counterpart to Solidity's `int192` operator.
*
* Requirements:
*
* - input must fit into 192 bits
*/
function toInt192(int256 value) internal pure returns (int192 downcasted) {
downcasted = int192(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(192, value);
}
}
/**
* @dev Returns the downcasted int184 from int256, reverting on
* overflow (when the input is less than smallest int184 or
* greater than largest int184).
*
* Counterpart to Solidity's `int184` operator.
*
* Requirements:
*
* - input must fit into 184 bits
*/
function toInt184(int256 value) internal pure returns (int184 downcasted) {
downcasted = int184(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(184, value);
}
}
/**
* @dev Returns the downcasted int176 from int256, reverting on
* overflow (when the input is less than smallest int176 or
* greater than largest int176).
*
* Counterpart to Solidity's `int176` operator.
*
* Requirements:
*
* - input must fit into 176 bits
*/
function toInt176(int256 value) internal pure returns (int176 downcasted) {
downcasted = int176(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(176, value);
}
}
/**
* @dev Returns the downcasted int168 from int256, reverting on
* overflow (when the input is less than smallest int168 or
* greater than largest int168).
*
* Counterpart to Solidity's `int168` operator.
*
* Requirements:
*
* - input must fit into 168 bits
*/
function toInt168(int256 value) internal pure returns (int168 downcasted) {
downcasted = int168(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(168, value);
}
}
/**
* @dev Returns the downcasted int160 from int256, reverting on
* overflow (when the input is less than smallest int160 or
* greater than largest int160).
*
* Counterpart to Solidity's `int160` operator.
*
* Requirements:
*
* - input must fit into 160 bits
*/
function toInt160(int256 value) internal pure returns (int160 downcasted) {
downcasted = int160(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(160, value);
}
}
/**
* @dev Returns the downcasted int152 from int256, reverting on
* overflow (when the input is less than smallest int152 or
* greater than largest int152).
*
* Counterpart to Solidity's `int152` operator.
*
* Requirements:
*
* - input must fit into 152 bits
*/
function toInt152(int256 value) internal pure returns (int152 downcasted) {
downcasted = int152(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(152, value);
}
}
/**
* @dev Returns the downcasted int144 from int256, reverting on
* overflow (when the input is less than smallest int144 or
* greater than largest int144).
*
* Counterpart to Solidity's `int144` operator.
*
* Requirements:
*
* - input must fit into 144 bits
*/
function toInt144(int256 value) internal pure returns (int144 downcasted) {
downcasted = int144(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(144, value);
}
}
/**
* @dev Returns the downcasted int136 from int256, reverting on
* overflow (when the input is less than smallest int136 or
* greater than largest int136).
*
* Counterpart to Solidity's `int136` operator.
*
* Requirements:
*
* - input must fit into 136 bits
*/
function toInt136(int256 value) internal pure returns (int136 downcasted) {
downcasted = int136(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(136, value);
}
}
/**
* @dev Returns the downcasted int128 from int256, reverting on
* overflow (when the input is less than smallest int128 or
* greater than largest int128).
*
* Counterpart to Solidity's `int128` operator.
*
* Requirements:
*
* - input must fit into 128 bits
*/
function toInt128(int256 value) internal pure returns (int128 downcasted) {
downcasted = int128(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(128, value);
}
}
/**
* @dev Returns the downcasted int120 from int256, reverting on
* overflow (when the input is less than smallest int120 or
* greater than largest int120).
*
* Counterpart to Solidity's `int120` operator.
*
* Requirements:
*
* - input must fit into 120 bits
*/
function toInt120(int256 value) internal pure returns (int120 downcasted) {
downcasted = int120(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(120, value);
}
}
/**
* @dev Returns the downcasted int112 from int256, reverting on
* overflow (when the input is less than smallest int112 or
* greater than largest int112).
*
* Counterpart to Solidity's `int112` operator.
*
* Requirements:
*
* - input must fit into 112 bits
*/
function toInt112(int256 value) internal pure returns (int112 downcasted) {
downcasted = int112(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(112, value);
}
}
/**
* @dev Returns the downcasted int104 from int256, reverting on
* overflow (when the input is less than smallest int104 or
* greater than largest int104).
*
* Counterpart to Solidity's `int104` operator.
*
* Requirements:
*
* - input must fit into 104 bits
*/
function toInt104(int256 value) internal pure returns (int104 downcasted) {
downcasted = int104(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(104, value);
}
}
/**
* @dev Returns the downcasted int96 from int256, reverting on
* overflow (when the input is less than smallest int96 or
* greater than largest int96).
*
* Counterpart to Solidity's `int96` operator.
*
* Requirements:
*
* - input must fit into 96 bits
*/
function toInt96(int256 value) internal pure returns (int96 downcasted) {
downcasted = int96(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(96, value);
}
}
/**
* @dev Returns the downcasted int88 from int256, reverting on
* overflow (when the input is less than smallest int88 or
* greater than largest int88).
*
* Counterpart to Solidity's `int88` operator.
*
* Requirements:
*
* - input must fit into 88 bits
*/
function toInt88(int256 value) internal pure returns (int88 downcasted) {
downcasted = int88(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(88, value);
}
}
/**
* @dev Returns the downcasted int80 from int256, reverting on
* overflow (when the input is less than smallest int80 or
* greater than largest int80).
*
* Counterpart to Solidity's `int80` operator.
*
* Requirements:
*
* - input must fit into 80 bits
*/
function toInt80(int256 value) internal pure returns (int80 downcasted) {
downcasted = int80(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(80, value);
}
}
/**
* @dev Returns the downcasted int72 from int256, reverting on
* overflow (when the input is less than smallest int72 or
* greater than largest int72).
*
* Counterpart to Solidity's `int72` operator.
*
* Requirements:
*
* - input must fit into 72 bits
*/
function toInt72(int256 value) internal pure returns (int72 downcasted) {
downcasted = int72(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(72, value);
}
}
/**
* @dev Returns the downcasted int64 from int256, reverting on
* overflow (when the input is less than smallest int64 or
* greater than largest int64).
*
* Counterpart to Solidity's `int64` operator.
*
* Requirements:
*
* - input must fit into 64 bits
*/
function toInt64(int256 value) internal pure returns (int64 downcasted) {
downcasted = int64(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(64, value);
}
}
/**
* @dev Returns the downcasted int56 from int256, reverting on
* overflow (when the input is less than smallest int56 or
* greater than largest int56).
*
* Counterpart to Solidity's `int56` operator.
*
* Requirements:
*
* - input must fit into 56 bits
*/
function toInt56(int256 value) internal pure returns (int56 downcasted) {
downcasted = int56(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(56, value);
}
}
/**
* @dev Returns the downcasted int48 from int256, reverting on
* overflow (when the input is less than smallest int48 or
* greater than largest int48).
*
* Counterpart to Solidity's `int48` operator.
*
* Requirements:
*
* - input must fit into 48 bits
*/
function toInt48(int256 value) internal pure returns (int48 downcasted) {
downcasted = int48(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(48, value);
}
}
/**
* @dev Returns the downcasted int40 from int256, reverting on
* overflow (when the input is less than smallest int40 or
* greater than largest int40).
*
* Counterpart to Solidity's `int40` operator.
*
* Requirements:
*
* - input must fit into 40 bits
*/
function toInt40(int256 value) internal pure returns (int40 downcasted) {
downcasted = int40(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(40, value);
}
}
/**
* @dev Returns the downcasted int32 from int256, reverting on
* overflow (when the input is less than smallest int32 or
* greater than largest int32).
*
* Counterpart to Solidity's `int32` operator.
*
* Requirements:
*
* - input must fit into 32 bits
*/
function toInt32(int256 value) internal pure returns (int32 downcasted) {
downcasted = int32(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(32, value);
}
}
/**
* @dev Returns the downcasted int24 from int256, reverting on
* overflow (when the input is less than smallest int24 or
* greater than largest int24).
*
* Counterpart to Solidity's `int24` operator.
*
* Requirements:
*
* - input must fit into 24 bits
*/
function toInt24(int256 value) internal pure returns (int24 downcasted) {
downcasted = int24(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(24, value);
}
}
/**
* @dev Returns the downcasted int16 from int256, reverting on
* overflow (when the input is less than smallest int16 or
* greater than largest int16).
*
* Counterpart to Solidity's `int16` operator.
*
* Requirements:
*
* - input must fit into 16 bits
*/
function toInt16(int256 value) internal pure returns (int16 downcasted) {
downcasted = int16(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(16, value);
}
}
/**
* @dev Returns the downcasted int8 from int256, reverting on
* overflow (when the input is less than smallest int8 or
* greater than largest int8).
*
* Counterpart to Solidity's `int8` operator.
*
* Requirements:
*
* - input must fit into 8 bits
*/
function toInt8(int256 value) internal pure returns (int8 downcasted) {
downcasted = int8(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(8, value);
}
}
/**
* @dev Converts an unsigned uint256 into a signed int256.
*
* Requirements:
*
* - input must be less than or equal to maxInt256.
*/
function toInt256(uint256 value) internal pure returns (int256) {
// Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
if (value > uint256(type(int256).max)) {
revert SafeCastOverflowedUintToInt(value);
}
return int256(value);
}
/**
* @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.
*/
function toUint(bool b) internal pure returns (uint256 u) {
assembly ("memory-safe") {
u := iszero(iszero(b))
}
}
}
// File: @openzeppelin/contracts/utils/math/Math.sol
// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/Math.sol)
pragma solidity ^0.8.20;
/**
* @dev Standard math utilities missing in the Solidity language.
*/
library Math {
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 success flag (no overflow).
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
/**
* @dev Returns the subtraction of two unsigned integers, with an success flag (no overflow).
*/
function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
/**
* @dev Returns the multiplication of two unsigned integers, with an success flag (no overflow).
*/
function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
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 success flag (no division by zero).
*/
function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
/**
* @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).
*/
function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
/**
* @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.
*
* IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.
* However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute
* one branch when needed, making this function more expensive.
*/
function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {
unchecked {
// branchless ternary works because:
// b ^ (a ^ b) == a
// b ^ 0 == b
return b ^ ((a ^ b) * SafeCast.toUint(condition));
}
}
/**
* @dev Returns the largest of two numbers.
*/
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return ternary(a > b, a, b);
}
/**
* @dev Returns the smallest of two numbers.
*/
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return ternary(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.
Panic.panic(Panic.DIVISION_BY_ZERO);
}
// The following calculation ensures accurate ceiling division without overflow.
// Since a is non-zero, (a - 1) / b will not overflow.
// The largest possible result occurs when (a - 1) / b is type(uint256).max,
// but the largest value we can obtain is type(uint256).max - 1, which happens
// when a = type(uint256).max and b = 1.
unchecked {
return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);
}
}
/**
* @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or
* denominator == 0.
*
* 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²⁵⁶ and mod 2²⁵⁶ - 1, then use
// the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
// variables such that product = prod1 * 2²⁵⁶ + 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²⁵⁶. Also prevents denominator == 0.
if (denominator <= prod1) {
Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));
}
///////////////////////////////////////////////
// 512 by 256 division.
///////////////////////////////////////////////
// Make division exact by subtracting the remainder from [prod1 prod0].
uint256 remainder;
assembly {
// Compute remainder using mulmod.
remainder := mulmod(x, y, denominator)
// Subtract 256 bit number from 512 bit number.
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
// Factor powers of two out of denominator and compute largest power of two divisor of denominator.
// Always >= 1. See https://cs.stackexchange.com/q/138556/92363.
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²⁵⁶ / 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²⁵⁶. Now that denominator is an odd number, it has an inverse modulo 2²⁵⁶ such
// that denominator * inv ≡ 1 mod 2²⁵⁶. Compute the inverse by starting with a seed that is correct for
// four bits. That is, denominator * inv ≡ 1 mod 2⁴.
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⁸
inverse *= 2 - denominator * inverse; // inverse mod 2¹⁶
inverse *= 2 - denominator * inverse; // inverse mod 2³²
inverse *= 2 - denominator * inverse; // inverse mod 2⁶⁴
inverse *= 2 - denominator * inverse; // inverse mod 2¹²⁸
inverse *= 2 - denominator * inverse; // inverse mod 2²⁵⁶
// 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²⁵⁶. Since the preconditions guarantee that the outcome is
// less than 2²⁵⁶, 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;
}
}
/**
* @dev 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) {
return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);
}
/**
* @dev Calculate the modular multiplicative inverse of a number in Z/nZ.
*
* If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.
* If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.
*
* If the input value is not inversible, 0 is returned.
*
* NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the
* inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.
*/
function invMod(uint256 a, uint256 n) internal pure returns (uint256) {
unchecked {
if (n == 0) return 0;
// The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)
// Used to compute integers x and y such that: ax + ny = gcd(a, n).
// When the gcd is 1, then the inverse of a modulo n exists and it's x.
// ax + ny = 1
// ax = 1 + (-y)n
// ax ≡ 1 (mod n) # x is the inverse of a modulo n
// If the remainder is 0 the gcd is n right away.
uint256 remainder = a % n;
uint256 gcd = n;
// Therefore the initial coefficients are:
// ax + ny = gcd(a, n) = n
// 0a + 1n = n
int256 x = 0;
int256 y = 1;
while (remainder != 0) {
uint256 quotient = gcd / remainder;
(gcd, remainder) = (
// The old remainder is the next gcd to try.
remainder,
// Compute the next remainder.
// Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd
// where gcd is at most n (capped to type(uint256).max)
gcd - remainder * quotient
);
(x, y) = (
// Increment the coefficient of a.
y,
// Decrement the coefficient of n.
// Can overflow, but the result is casted to uint256 so that the
// next value of y is "wrapped around" to a value between 0 and n - 1.
x - y * int256(quotient)
);
}
if (gcd != 1) return 0; // No inverse exists.
return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.
}
}
/**
* @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.
*
* From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is
* prime, then `a**(p-1) ≡ 1 mod p`. As a consequence, we have `a * a**(p-2) ≡ 1 mod p`, which means that
* `a**(p-2)` is the modular multiplicative inverse of a in Fp.
*
* NOTE: this function does NOT check that `p` is a prime greater than `2`.
*/
function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {
unchecked {
return Math.modExp(a, p - 2, p);
}
}
/**
* @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)
*
* Requirements:
* - modulus can't be zero
* - underlying staticcall to precompile must succeed
*
* IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make
* sure the chain you're using it on supports the precompiled contract for modular exponentiation
* at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,
* the underlying function will succeed given the lack of a revert, but the result may be incorrectly
* interpreted as 0.
*/
function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {
(bool success, uint256 result) = tryModExp(b, e, m);
if (!success) {
Panic.panic(Panic.DIVISION_BY_ZERO);
}
return result;
}
/**
* @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).
* It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying
* to operate modulo 0 or if the underlying precompile reverted.
*
* IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain
* you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in
* https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack
* of a revert, but the result may be incorrectly interpreted as 0.
*/
function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {
if (m == 0) return (false, 0);
assembly ("memory-safe") {
let ptr := mload(0x40)
// | Offset | Content | Content (Hex) |
// |-----------|------------|--------------------------------------------------------------------|
// | 0x00:0x1f | size of b | 0x0000000000000000000000000000000000000000000000000000000000000020 |
// | 0x20:0x3f | size of e | 0x0000000000000000000000000000000000000000000000000000000000000020 |
// | 0x40:0x5f | size of m | 0x0000000000000000000000000000000000000000000000000000000000000020 |
// | 0x60:0x7f | value of b | 0x<.............................................................b> |
// | 0x80:0x9f | value of e | 0x<.............................................................e> |
// | 0xa0:0xbf | value of m | 0x<.............................................................m> |
mstore(ptr, 0x20)
mstore(add(ptr, 0x20), 0x20)
mstore(add(ptr, 0x40), 0x20)
mstore(add(ptr, 0x60), b)
mstore(add(ptr, 0x80), e)
mstore(add(ptr, 0xa0), m)
// Given the result < m, it's guaranteed to fit in 32 bytes,
// so we can use the memory scratch space located at offset 0.
success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)
result := mload(0x00)
}
}
/**
* @dev Variant of {modExp} that supports inputs of arbitrary length.
*/
function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {
(bool success, bytes memory result) = tryModExp(b, e, m);
if (!success) {
Panic.panic(Panic.DIVISION_BY_ZERO);
}
return result;
}
/**
* @dev Variant of {tryModExp} that supports inputs of arbitrary length.
*/
function tryModExp(
bytes memory b,
bytes memory e,
bytes memory m
) internal view returns (bool success, bytes memory result) {
if (_zeroBytes(m)) return (false, new bytes(0));
uint256 mLen = m.length;
// Encode call args in result and move the free memory pointer
result = abi.encodePacked(b.length, e.length, mLen, b, e, m);
assembly ("memory-safe") {
let dataPtr := add(result, 0x20)
// Write result on top of args to avoid allocating extra memory.
success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)
// Overwrite the length.
// result.length > returndatasize() is guaranteed because returndatasize() == m.length
mstore(result, mLen)
// Set the memory pointer after the returned data.
mstore(0x40, add(dataPtr, mLen))
}
}
/**
* @dev Returns whether the provided byte array is zero.
*/
function _zeroBytes(bytes memory byteArray) private pure returns (bool) {
for (uint256 i = 0; i < byteArray.length; ++i) {
if (byteArray[i] != 0) {
return false;
}
}
return true;
}
/**
* @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
* towards zero.
*
* This method is based on Newton's method for computing square roots; the algorithm is restricted to only
* using integer operations.
*/
function sqrt(uint256 a) internal pure returns (uint256) {
unchecked {
// Take care of easy edge cases when a == 0 or a == 1
if (a <= 1) {
return a;
}
// In this function, we use Newton's method to get a root of `f(x) := x² - a`. It involves building a
// sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between
// the current value as `ε_n = | x_n - sqrt(a) |`.
//
// For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root
// of the target. (i.e. `2**(e-1) ≤ sqrt(a) < 2**e`). We know that `e ≤ 128` because `(2¹²⁸)² = 2²⁵⁶` is
// bigger than any uint256.
//
// By noticing that
// `2**(e-1) ≤ sqrt(a) < 2**e → (2**(e-1))² ≤ a < (2**e)² → 2**(2*e-2) ≤ a < 2**(2*e)`
// we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar
// to the msb function.
uint256 aa = a;
uint256 xn = 1;
if (aa >= (1 << 128)) {
aa >>= 128;
xn <<= 64;
}
if (aa >= (1 << 64)) {
aa >>= 64;
xn <<= 32;
}
if (aa >= (1 << 32)) {
aa >>= 32;
xn <<= 16;
}
if (aa >= (1 << 16)) {
aa >>= 16;
xn <<= 8;
}
if (aa >= (1 << 8)) {
aa >>= 8;
xn <<= 4;
}
if (aa >= (1 << 4)) {
aa >>= 4;
xn <<= 2;
}
if (aa >= (1 << 2)) {
xn <<= 1;
}
// We now have x_n such that `x_n = 2**(e-1) ≤ sqrt(a) < 2**e = 2 * x_n`. This implies ε_n ≤ 2**(e-1).
//
// We can refine our estimation by noticing that the middle of that interval minimizes the error.
// If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to ε_n ≤ 2**(e-2).
// This is going to be our x_0 (and ε_0)
xn = (3 * xn) >> 1; // ε_0 := | x_0 - sqrt(a) | ≤ 2**(e-2)
// From here, Newton's method give us:
// x_{n+1} = (x_n + a / x_n) / 2
//
// One should note that:
// x_{n+1}² - a = ((x_n + a / x_n) / 2)² - a
// = ((x_n² + a) / (2 * x_n))² - a
// = (x_n⁴ + 2 * a * x_n² + a²) / (4 * x_n²) - a
// = (x_n⁴ + 2 * a * x_n² + a² - 4 * a * x_n²) / (4 * x_n²)
// = (x_n⁴ - 2 * a * x_n² + a²) / (4 * x_n²)
// = (x_n² - a)² / (2 * x_n)²
// = ((x_n² - a) / (2 * x_n))²
// ≥ 0
// Which proves that for all n ≥ 1, sqrt(a) ≤ x_n
//
// This gives us the proof of quadratic convergence of the sequence:
// ε_{n+1} = | x_{n+1} - sqrt(a) |
// = | (x_n + a / x_n) / 2 - sqrt(a) |
// = | (x_n² + a - 2*x_n*sqrt(a)) / (2 * x_n) |
// = | (x_n - sqrt(a))² / (2 * x_n) |
// = | ε_n² / (2 * x_n) |
// = ε_n² / | (2 * x_n) |
//
// For the first iteration, we have a special case where x_0 is known:
// ε_1 = ε_0² / | (2 * x_0) |
// ≤ (2**(e-2))² / (2 * (2**(e-1) + 2**(e-2)))
// ≤ 2**(2*e-4) / (3 * 2**(e-1))
// ≤ 2**(e-3) / 3
// ≤ 2**(e-3-log2(3))
// ≤ 2**(e-4.5)
//
// For the following iterations, we use the fact that, 2**(e-1) ≤ sqrt(a) ≤ x_n:
// ε_{n+1} = ε_n² / | (2 * x_n) |
// ≤ (2**(e-k))² / (2 * 2**(e-1))
// ≤ 2**(2*e-2*k) / 2**e
// ≤ 2**(e-2*k)
xn = (xn + a / xn) >> 1; // ε_1 := | x_1 - sqrt(a) | ≤ 2**(e-4.5) -- special case, see above
xn = (xn + a / xn) >> 1; // ε_2 := | x_2 - sqrt(a) | ≤ 2**(e-9) -- general case with k = 4.5
xn = (xn + a / xn) >> 1; // ε_3 := | x_3 - sqrt(a) | ≤ 2**(e-18) -- general case with k = 9
xn = (xn + a / xn) >> 1; // ε_4 := | x_4 - sqrt(a) | ≤ 2**(e-36) -- general case with k = 18
xn = (xn + a / xn) >> 1; // ε_5 := | x_5 - sqrt(a) | ≤ 2**(e-72) -- general case with k = 36
xn = (xn + a / xn) >> 1; // ε_6 := | x_6 - sqrt(a) | ≤ 2**(e-144) -- general case with k = 72
// Because e ≤ 128 (as discussed during the first estimation phase), we know have reached a precision
// ε_6 ≤ 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either
// sqrt(a) or sqrt(a) + 1.
return xn - SafeCast.toUint(xn > a / xn);
}
}
/**
* @dev 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 + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);
}
}
/**
* @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;
uint256 exp;
unchecked {
exp = 128 * SafeCast.toUint(value > (1 << 128) - 1);
value >>= exp;
result += exp;
exp = 64 * SafeCast.toUint(value > (1 << 64) - 1);
value >>= exp;
result += exp;
exp = 32 * SafeCast.toUint(value > (1 << 32) - 1);
value >>= exp;
result += exp;
exp = 16 * SafeCast.toUint(value > (1 << 16) - 1);
value >>= exp;
result += exp;
exp = 8 * SafeCast.toUint(value > (1 << 8) - 1);
value >>= exp;
result += exp;
exp = 4 * SafeCast.toUint(value > (1 << 4) - 1);
value >>= exp;
result += exp;
exp = 2 * SafeCast.toUint(value > (1 << 2) - 1);
value >>= exp;
result += exp;
result += SafeCast.toUint(value > 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 + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);
}
}
/**
* @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 + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);
}
}
/**
* @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;
uint256 isGt;
unchecked {
isGt = SafeCast.toUint(value > (1 << 128) - 1);
value >>= isGt * 128;
result += isGt * 16;
isGt = SafeCast.toUint(value > (1 << 64) - 1);
value >>= isGt * 64;
result += isGt * 8;
isGt = SafeCast.toUint(value > (1 << 32) - 1);
value >>= isGt * 32;
result += isGt * 4;
isGt = SafeCast.toUint(value > (1 << 16) - 1);
value >>= isGt * 16;
result += isGt * 2;
result += SafeCast.toUint(value > (1 << 8) - 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 + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);
}
}
/**
* @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/math/SignedMath.sol
// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SignedMath.sol)
pragma solidity ^0.8.20;
/**
* @dev Standard signed math utilities missing in the Solidity language.
*/
library SignedMath {
/**
* @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.
*
* IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.
* However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute
* one branch when needed, making this function more expensive.
*/
function ternary(bool condition, int256 a, int256 b) internal pure returns (int256) {
unchecked {
// branchless ternary works because:
// b ^ (a ^ b) == a
// b ^ 0 == b
return b ^ ((a ^ b) * int256(SafeCast.toUint(condition)));
}
}
/**
* @dev Returns the largest of two signed numbers.
*/
function max(int256 a, int256 b) internal pure returns (int256) {
return ternary(a > b, a, b);
}
/**
* @dev Returns the smallest of two signed numbers.
*/
function min(int256 a, int256 b) internal pure returns (int256) {
return ternary(a < b, a, b);
}
/**
* @dev Returns the average of two signed numbers without overflow.
* The result is rounded towards zero.
*/
function average(int256 a, int256 b) internal pure returns (int256) {
// Formula from the book "Hacker's Delight"
int256 x = (a & b) + ((a ^ b) >> 1);
return x + (int256(uint256(x) >> 255) & (a ^ b));
}
/**
* @dev Returns the absolute unsigned value of a signed value.
*/
function abs(int256 n) internal pure returns (uint256) {
unchecked {
// Formula from the "Bit Twiddling Hacks" by Sean Eron Anderson.
// Since `n` is a signed integer, the generated bytecode will use the SAR opcode to perform the right shift,
// taking advantage of the most significant (or "sign" bit) in two's complement representation.
// This opcode adds new most significant bits set to the value of the previous most significant bit. As a result,
// the mask will either be `bytes32(0)` (if n is positive) or `~bytes32(0)` (if n is negative).
int256 mask = n >> 255;
// A `bytes32(0)` mask leaves the input unchanged, while a `~bytes32(0)` mask complements it.
return uint256((n + mask) ^ mask);
}
}
}
// File: @openzeppelin/contracts/utils/Strings.sol
// OpenZeppelin Contracts (last updated v5.1.0) (utils/Strings.sol)
pragma solidity ^0.8.20;
/**
* @dev String operations.
*/
library Strings {
bytes16 private constant HEX_DIGITS = "0123456789abcdef";
uint8 private constant ADDRESS_LENGTH = 20;
/**
* @dev The `value` string doesn't fit in the specified `length`.
*/
error StringsInsufficientHexLength(uint256 value, uint256 length);
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
unchecked {
uint256 length = Math.log10(value) + 1;
string memory buffer = new string(length);
uint256 ptr;
assembly ("memory-safe") {
ptr := add(buffer, add(32, length))
}
while (true) {
ptr--;
assembly ("memory-safe") {
mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
}
/**
* @dev Converts a `int256` to its ASCII `string` decimal representation.
*/
function toStringSigned(int256 value) internal pure returns (string memory) {
return string.concat(value < 0 ? "-" : "", toString(SignedMath.abs(value)));
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
unchecked {
return toHexString(value, Math.log256(value) + 1);
}
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
uint256 localValue = value;
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = HEX_DIGITS[localValue & 0xf];
localValue >>= 4;
}
if (localValue != 0) {
revert StringsInsufficientHexLength(value, length);
}
return string(buffer);
}
/**
* @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal
* representation.
*/
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);
}
/**
* @dev Converts an `address` with fixed length of 20 bytes to its checksummed ASCII `string` hexadecimal
* representation, according to EIP-55.
*/
function toChecksumHexString(address addr) internal pure returns (string memory) {
bytes memory buffer = bytes(toHexString(addr));
// hash the hex part of buffer (skip length + 2 bytes, length 40)
uint256 hashValue;
assembly ("memory-safe") {
hashValue := shr(96, keccak256(add(buffer, 0x22), 40))
}
for (uint256 i = 41; i > 1; --i) {
// possible values for buffer[i] are 48 (0) to 57 (9) and 97 (a) to 102 (f)
if (hashValue & 0xf > 7 && uint8(buffer[i]) > 96) {
// case shift by xoring with 0x20
buffer[i] ^= 0x20;
}
hashValue >>= 4;
}
return string(buffer);
}
/**
* @dev Returns true if the two strings are equal.
*/
function equal(string memory a, string memory b) internal pure returns (bool) {
return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));
}
}
// File: @openzeppelin/contracts/utils/introspection/ERC165.sol
// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/ERC165.sol)
pragma solidity ^0.8.20;
/**
* @dev Implementation of the {IERC165} interface.
*
* Contracts that want to implement ERC-165 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/ERC721/ERC721.sol
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC721/ERC721.sol)
pragma solidity ^0.8.20;
/**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC-721] Non-Fungible Token Standard, including
* the Metadata extension, but not including the Enumerable extension, which is available separately as
* {ERC721Enumerable}.
*/
abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Errors {
using Strings for uint256;
// Token name
string private _name;
// Token symbol
string private _symbol;
mapping(uint256 tokenId => address) private _owners;
mapping(address owner => uint256) private _balances;
mapping(uint256 tokenId => address) private _tokenApprovals;
mapping(address owner => mapping(address operator => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual returns (uint256) {
if (owner == address(0)) {
revert ERC721InvalidOwner(address(0));
}
return _balances[owner];
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual returns (address) {
return _requireOwned(tokenId);
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual returns (string memory) {
return _name;
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual returns (string memory) {
return _symbol;
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual returns (string memory) {
_requireOwned(tokenId);
string memory baseURI = _baseURI();
return bytes(baseURI).length > 0 ? string.concat(baseURI, tokenId.toString()) : "";
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overridden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
return "";
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual {
_approve(to, tokenId, _msgSender());
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual returns (address) {
_requireOwned(tokenId);
return _getApproved(tokenId);
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual {
_setApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual returns (bool) {
return _operatorApprovals[owner][operator];
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(address from, address to, uint256 tokenId) public virtual {
if (to == address(0)) {
revert ERC721InvalidReceiver(address(0));
}
// Setting an "auth" arguments enables the `_isAuthorized` check which verifies that the token exists
// (from != 0). Therefore, it is not needed to verify that the return value is not 0 here.
address previousOwner = _update(to, tokenId, _msgSender());
if (previousOwner != from) {
revert ERC721IncorrectOwner(from, tokenId, previousOwner);
}
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(address from, address to, uint256 tokenId) public {
safeTransferFrom(from, to, tokenId, "");
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public virtual {
transferFrom(from, to, tokenId);
ERC721Utils.checkOnERC721Received(_msgSender(), from, to, tokenId, data);
}
/**
* @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist
*
* IMPORTANT: Any overrides to this function that add ownership of tokens not tracked by the
* core ERC-721 logic MUST be matched with the use of {_increaseBalance} to keep balances
* consistent with ownership. The invariant to preserve is that for any address `a` the value returned by
* `balanceOf(a)` must be equal to the number of tokens such that `_ownerOf(tokenId)` is `a`.
*/
function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
return _owners[tokenId];
}
/**
* @dev Returns the approved address for `tokenId`. Returns 0 if `tokenId` is not minted.
*/
function _getApproved(uint256 tokenId) internal view virtual returns (address) {
return _tokenApprovals[tokenId];
}
/**
* @dev Returns whether `spender` is allowed to manage `owner`'s tokens, or `tokenId` in
* particular (ignoring whether it is owned by `owner`).
*
* WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this
* assumption.
*/
function _isAuthorized(address owner, address spender, uint256 tokenId) internal view virtual returns (bool) {
return
spender != address(0) &&
(owner == spender || isApprovedForAll(owner, spender) || _getApproved(tokenId) == spender);
}
/**
* @dev Checks if `spender` can operate on `tokenId`, assuming the provided `owner` is the actual owner.
* Reverts if:
* - `spender` does not have approval from `owner` for `tokenId`.
* - `spender` does not have approval to manage all of `owner`'s assets.
*
* WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this
* assumption.
*/
function _checkAuthorized(address owner, address spender, uint256 tokenId) internal view virtual {
if (!_isAuthorized(owner, spender, tokenId)) {
if (owner == address(0)) {
revert ERC721NonexistentToken(tokenId);
} else {
revert ERC721InsufficientApproval(spender, tokenId);
}
}
}
/**
* @dev Unsafe write access to the balances, used by extensions that "mint" tokens using an {ownerOf} override.
*
* NOTE: the value is limited to type(uint128).max. This protect against _balance overflow. It is unrealistic that
* a uint256 would ever overflow from increments when these increments are bounded to uint128 values.
*
* WARNING: Increasing an account's balance using this function tends to be paired with an override of the
* {_ownerOf} function to resolve the ownership of the corresponding tokens so that balances and ownership
* remain consistent with one another.
*/
function _increaseBalance(address account, uint128 value) internal virtual {
unchecked {
_balances[account] += value;
}
}
/**
* @dev Transfers `tokenId` from its current owner to `to`, or alternatively mints (or burns) if the current owner
* (or `to`) is the zero address. Returns the owner of the `tokenId` before the update.
*
* The `auth` argument is optional. If the value passed is non 0, then this function will check that
* `auth` is either the owner of the token, or approved to operate on the token (by the owner).
*
* Emits a {Transfer} event.
*
* NOTE: If overriding this function in a way that tracks balances, see also {_increaseBalance}.
*/
function _update(address to, uint256 tokenId, address auth) internal virtual returns (address) {
address from = _ownerOf(tokenId);
// Perform (optional) operator check
if (auth != address(0)) {
_checkAuthorized(from, auth, tokenId);
}
// Execute the update
if (from != address(0)) {
// Clear approval. No need to re-authorize or emit the Approval event
_approve(address(0), tokenId, address(0), false);
unchecked {
_balances[from] -= 1;
}
}
if (to != address(0)) {
unchecked {
_balances[to] += 1;
}
}
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
return from;
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal {
if (to == address(0)) {
revert ERC721InvalidReceiver(address(0));
}
address previousOwner = _update(to, tokenId, address(0));
if (previousOwner != address(0)) {
revert ERC721InvalidSender(address(0));
}
}
/**
* @dev Mints `tokenId`, transfers it to `to` and checks for `to` acceptance.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal {
_safeMint(to, tokenId, "");
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(address to, uint256 tokenId, bytes memory data) internal virtual {
_mint(to, tokenId);
ERC721Utils.checkOnERC721Received(_msgSender(), address(0), to, tokenId, data);
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
* This is an internal function that does not check if the sender is authorized to operate on the token.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal {
address previousOwner = _update(address(0), tokenId, address(0));
if (previousOwner == address(0)) {
revert ERC721NonexistentToken(tokenId);
}
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(address from, address to, uint256 tokenId) internal {
if (to == address(0)) {
revert ERC721InvalidReceiver(address(0));
}
address previousOwner = _update(to, tokenId, address(0));
if (previousOwner == address(0)) {
revert ERC721NonexistentToken(tokenId);
} else if (previousOwner != from) {
revert ERC721IncorrectOwner(from, tokenId, previousOwner);
}
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking that contract recipients
* are aware of the ERC-721 standard to prevent tokens from being forever locked.
*
* `data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is like {safeTransferFrom} in the sense that it invokes
* {IERC721Receiver-onERC721Received} on the receiver, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `tokenId` token must exist and be owned by `from`.
* - `to` cannot be the zero address.
* - `from` cannot be the zero address.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(address from, address to, uint256 tokenId) internal {
_safeTransfer(from, to, tokenId, "");
}
/**
* @dev Same as {xref-ERC721-_safeTransfer-address-address-uint256-}[`_safeTransfer`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeTransfer(address from, address to, uint256 tokenId, bytes memory data) internal virtual {
_transfer(from, to, tokenId);
ERC721Utils.checkOnERC721Received(_msgSender(), from, to, tokenId, data);
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* The `auth` argument is optional. If the value passed is non 0, then this function will check that `auth` is
* either the owner of the token, or approved to operate on all tokens held by this owner.
*
* Emits an {Approval} event.
*
* Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
*/
function _approve(address to, uint256 tokenId, address auth) internal {
_approve(to, tokenId, auth, true);
}
/**
* @dev Variant of `_approve` with an optional flag to enable or disable the {Approval} event. The event is not
* emitted in the context of transfers.
*/
function _approve(address to, uint256 tokenId, address auth, bool emitEvent) internal virtual {
// Avoid reading the owner unless necessary
if (emitEvent || auth != address(0)) {
address owner = _requireOwned(tokenId);
// We do not use _isAuthorized because single-token approvals should not be able to call approve
if (auth != address(0) && owner != auth && !isApprovedForAll(owner, auth)) {
revert ERC721InvalidApprover(auth);
}
if (emitEvent) {
emit Approval(owner, to, tokenId);
}
}
_tokenApprovals[tokenId] = to;
}
/**
* @dev Approve `operator` to operate on all of `owner` tokens
*
* Requirements:
* - operator can't be the address zero.
*
* Emits an {ApprovalForAll} event.
*/
function _setApprovalForAll(address owner, address operator, bool approved) internal virtual {
if (operator == address(0)) {
revert ERC721InvalidOperator(operator);
}
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
/**
* @dev Reverts if the `tokenId` doesn't have a current owner (it hasn't been minted, or it has been burned).
* Returns the owner.
*
* Overrides to ownership logic should be done to {_ownerOf}.
*/
function _requireOwned(uint256 tokenId) internal view returns (address) {
address owner = _ownerOf(tokenId);
if (owner == address(0)) {
revert ERC721NonexistentToken(tokenId);
}
return owner;
}
}
// 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/Counters.sol
// OpenZeppelin Contracts v4.4.1 (utils/Counters.sol)
pragma solidity ^0.8.0;
/**
* @title Counters
* @author Matt Condon (@shrugs)
* @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
* of elements in a mapping, issuing ERC721 ids, or counting request ids.
*
* Include with `using Counters for Counters.Counter;`
*/
library Counters {
struct Counter {
// This variable should never be directly accessed by users of the library: interactions must be restricted to
// the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
// this feature: see https://github.com/ethereum/solidity/issues/4637
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
unchecked {
counter._value += 1;
}
}
function decrement(Counter storage counter) internal {
uint256 value = counter._value;
require(value > 0, "Counter: decrement overflow");
unchecked {
counter._value = value - 1;
}
}
function reset(Counter storage counter) internal {
counter._value = 0;
}
}
// File: contracts/FoxTrove.sol
pragma solidity ^0.8.20;
contract FoxTrove is ERC721, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
constructor(address _admin) ERC721("FoxTrove ", "FoxTrove ") Ownable(_admin) {
//Mint
for (uint i=0; i < 300; i++) {
uint256 tokenId = _tokenIdCounter.current() + 1;
_tokenIdCounter.increment();
_safeMint(_admin, tokenId);
minted++;
}
}
string private uri;
uint public minted;
uint public price = 100;
uint public priceWL = 10;
uint public maxMint = 10000;
uint public maxMintOnce = 10;
bool public saleStatus;
mapping(address => bool) public whiteList;
mapping(address => uint) public mintedCount;
mapping(address => uint) public mintedCountFree;
//mapping(address => uint) public fiveBorder;
//Public payable minting for everyone
function mint(uint quantity) public payable {
require(saleStatus);
require(minted + quantity < maxMint);
require(quantity <= maxMintOnce);
//White list
if(mintedCount[msg.sender] >= 1 && whiteList[msg.sender] == true) {
price = priceWL;
mintedCount[msg.sender]++;
}
//Bunus NFT
uint _countBonus = (mintedCount[msg.sender] + quantity - (mintedCountFree[msg.sender] * 5)) / 5;
uint _price = price * quantity;
require(msg.value >= _price);
//Mint
for (uint i=0; i < quantity + _countBonus; i++) {
uint256 tokenId = _tokenIdCounter.current() + 301;
_tokenIdCounter.increment();
_safeMint(msg.sender, tokenId);
}
//Counting
mintedCountFree[msg.sender] += _countBonus;
mintedCount[msg.sender] += quantity;
minted += quantity + _countBonus;
}
//ADMIN
//Minting for admin, without payments
function mintAdmin(uint _id) public onlyOwner {
_safeMint(msg.sender, _id);
}
//Setting price for the minting
function setPrice(uint _price) public onlyOwner {
price = _price;
}
function setWhiteList(address _address, bool _status) public onlyOwner {
whiteList[_address] = _status;
}
function setPriceWL(uint _price) public onlyOwner {
priceWL = _price;
}
function setSale(bool _status) public onlyOwner {
saleStatus = _status;
}
//Setting max limit of minting for one an address
function setMaxMint(uint _limit) public onlyOwner {
maxMintOnce = _limit;
}
//Withdrawing ETH from contract to admin address
function withdrawFromContract(uint amount) public onlyOwner {
payable(msg.sender).transfer(amount);
}
function _baseURI() internal view override virtual returns (string memory) {
return "https://ipfs.io/ipfs/QmY7zidLDtc5QuiFY5x7KSdtPhVQLvv5qu2isuRMFDzjMu/";
}
function tokenURI(uint256 tokenId) public view override returns (string memory) {
return string(abi.encodePacked(_baseURI(), Strings.toString(tokenId), ".json"));
}
function setUri(string memory _uri) public onlyOwner {
uri = _uri;
}
}[{"inputs":[{"internalType":"address","name":"_admin","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"address","name":"owner","type":"address"}],"name":"ERC721IncorrectOwner","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ERC721InsufficientApproval","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC721InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"ERC721InvalidOperator","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"ERC721InvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC721InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC721InvalidSender","type":"error"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ERC721NonexistentToken","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":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxMint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxMintOnce","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"quantity","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_id","type":"uint256"}],"name":"mintAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"minted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"mintedCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"mintedCountFree","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"price","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"priceWL","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"saleStatus","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_limit","type":"uint256"}],"name":"setMaxMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_price","type":"uint256"}],"name":"setPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_price","type":"uint256"}],"name":"setPriceWL","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_status","type":"bool"}],"name":"setSale","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_uri","type":"string"}],"name":"setUri","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"},{"internalType":"bool","name":"_status","type":"bool"}],"name":"setWhiteList","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"whiteList","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdrawFromContract","outputs":[],"stateMutability":"nonpayable","type":"function"}]Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
000000000000000000000000d3cf3e52e3a64e24cc2b83bfbaede927e52cc469
-----Decoded View---------------
Arg [0] : _admin (address): 0xD3Cf3E52e3A64E24CC2b83BfBaeDe927E52cc469
-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000d3cf3e52e3a64e24cc2b83bfbaede927e52cc469
Deployed Bytecode Sourcemap
113490:3306:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;93463:305;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;94294:91;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;95466:158;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;95285:115;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;115926:87;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;96135:588;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;114119:28;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;114185:41;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;96794:134;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;113999:18;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;116074:89;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;94107:120;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;115481:91;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;93832:213;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;111116:103;;;;;;;;;;;;;:::i;:::-;;114085:27;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;115833:85;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;114285:47;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;115706:119;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;110441:87;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;115617:81;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;94454:95;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;116711:82;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;114024:23;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;114439:974;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;95696:146;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;116223:115;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;96999:236;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;116525:178;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;114054:24;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;95913:155;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;111374:220;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;114154:22;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;114234:43;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;93463:305;93565:4;93617:25;93602:40;;;:11;:40;;;;:105;;;;93674:33;93659:48;;;:11;:48;;;;93602:105;:158;;;;93724:36;93748:11;93724:23;:36::i;:::-;93602:158;93582:178;;93463:305;;;:::o;94294:91::-;94339:13;94372:5;94365:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;94294:91;:::o;95466:158::-;95533:7;95553:22;95567:7;95553:13;:22::i;:::-;;95595:21;95608:7;95595:12;:21::i;:::-;95588:28;;95466:158;;;:::o;95285:115::-;95357:35;95366:2;95370:7;95379:12;:10;:12::i;:::-;95357:8;:35::i;:::-;95285:115;;:::o;115926:87::-;110327:13;:11;:13::i;:::-;115998:7:::1;115985:10;;:20;;;;;;;;;;;;;;;;;;115926:87:::0;:::o;96135:588::-;96244:1;96230:16;;:2;:16;;;96226:89;;96300:1;96270:33;;;;;;;;;;;:::i;:::-;;;;;;;;96226:89;96536:21;96560:34;96568:2;96572:7;96581:12;:10;:12::i;:::-;96560:7;:34::i;:::-;96536:58;;96626:4;96609:21;;:13;:21;;;96605:111;;96675:4;96681:7;96690:13;96654:50;;;;;;;;;;;;;:::i;:::-;;;;;;;;96605:111;96215:508;96135:588;;;:::o;114119:28::-;;;;:::o;114185:41::-;;;;;;;;;;;;;;;;;;;;;;:::o;96794:134::-;96881:39;96898:4;96904:2;96908:7;96881:39;;;;;;;;;;;;:16;:39::i;:::-;96794:134;;;:::o;113999:18::-;;;;:::o;116074:89::-;110327:13;:11;:13::i;:::-;116149:6:::1;116135:11;:20;;;;116074:89:::0;:::o;94107:120::-;94170:7;94197:22;94211:7;94197:13;:22::i;:::-;94190:29;;94107:120;;;:::o;115481:91::-;110327:13;:11;:13::i;:::-;115538:26:::1;115548:10;115560:3;115538:9;:26::i;:::-;115481:91:::0;:::o;93832:213::-;93895:7;93936:1;93919:19;;:5;:19;;;93915:89;;93989:1;93962:30;;;;;;;;;;;:::i;:::-;;;;;;;;93915:89;94021:9;:16;94031:5;94021:16;;;;;;;;;;;;;;;;94014:23;;93832:213;;;:::o;111116:103::-;110327:13;:11;:13::i;:::-;111181:30:::1;111208:1;111181:18;:30::i;:::-;111116:103::o:0;114085:27::-;;;;:::o;115833:85::-;110327:13;:11;:13::i;:::-;115904:6:::1;115894:7;:16;;;;115833:85:::0;:::o;114285:47::-;;;;;;;;;;;;;;;;;:::o;115706:119::-;110327:13;:11;:13::i;:::-;115810:7:::1;115788:9;:19;115798:8;115788:19;;;;;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;115706:119:::0;;:::o;110441:87::-;110487:7;110514:6;;;;;;;;;;;110507:13;;110441:87;:::o;115617:81::-;110327:13;:11;:13::i;:::-;115684:6:::1;115676:5;:14;;;;115617:81:::0;:::o;94454:95::-;94501:13;94534:7;94527:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;94454:95;:::o;116711:82::-;110327:13;:11;:13::i;:::-;116781:4:::1;116775:3;:10;;;;;;:::i;:::-;;116711:82:::0;:::o;114024:23::-;;;;:::o;114439:974::-;114502:10;;;;;;;;;;;114494:19;;;;;;114552:7;;114541:8;114532:6;;:17;;;;:::i;:::-;:27;114524:36;;;;;;114591:11;;114579:8;:23;;114571:32;;;;;;114666:1;114639:11;:23;114651:10;114639:23;;;;;;;;;;;;;;;;:28;;:61;;;;;114696:4;114671:29;;:9;:21;114681:10;114671:21;;;;;;;;;;;;;;;;;;;;;;;;;:29;;;114639:61;114636:148;;;114725:7;;114717:5;:15;;;;114747:11;:23;114759:10;114747:23;;;;;;;;;;;;;;;;:25;;;;;;;;;:::i;:::-;;;;;;114636:148;114817:16;114911:1;114905;114875:15;:27;114891:10;114875:27;;;;;;;;;;;;;;;;:31;;;;:::i;:::-;114863:8;114837:11;:23;114849:10;114837:23;;;;;;;;;;;;;;;;:34;;;;:::i;:::-;:70;;;;:::i;:::-;114836:76;;;;:::i;:::-;114817:95;;114923:11;114945:8;114937:5;;:16;;;;:::i;:::-;114923:30;;114985:6;114972:9;:19;;114964:28;;;;;;115026:6;115021:211;115051:11;115040:8;:22;;;;:::i;:::-;115036:1;:26;115021:211;;;115084:15;115130:3;115102:25;:15;:23;:25::i;:::-;:31;;;;:::i;:::-;115084:49;;115148:27;:15;:25;:27::i;:::-;115190:30;115200:10;115212:7;115190:9;:30::i;:::-;115069:163;115064:3;;;;;:::i;:::-;;;;115021:211;;;;115295:11;115264:15;:27;115280:10;115264:27;;;;;;;;;;;;;;;;:42;;;;;;;:::i;:::-;;;;;;;;115344:8;115317:11;:23;115329:10;115317:23;;;;;;;;;;;;;;;;:35;;;;;;;:::i;:::-;;;;;;;;115384:11;115373:8;:22;;;;:::i;:::-;115363:6;;:32;;;;;;;:::i;:::-;;;;;;;;114483:930;;114439:974;:::o;95696:146::-;95782:52;95801:12;:10;:12::i;:::-;95815:8;95825;95782:18;:52::i;:::-;95696:146;;:::o;116223:115::-;110327:13;:11;:13::i;:::-;116302:10:::1;116294:28;;:36;116323:6;116294:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;116223:115:::0;:::o;96999:236::-;97113:31;97126:4;97132:2;97136:7;97113:12;:31::i;:::-;97155:72;97189:12;:10;:12::i;:::-;97203:4;97209:2;97213:7;97222:4;97155:33;:72::i;:::-;96999:236;;;;:::o;116525:178::-;116590:13;116647:10;:8;:10::i;:::-;116659:25;116676:7;116659:16;:25::i;:::-;116630:64;;;;;;;;;:::i;:::-;;;;;;;;;;;;;116616:79;;116525:178;;;:::o;114054:24::-;;;;:::o;95913:155::-;96001:4;96025:18;:25;96044:5;96025:25;;;;;;;;;;;;;;;:35;96051:8;96025:35;;;;;;;;;;;;;;;;;;;;;;;;;96018:42;;95913:155;;;;:::o;111374:220::-;110327:13;:11;:13::i;:::-;111479:1:::1;111459:22;;:8;:22;;::::0;111455:93:::1;;111533:1;111505:31;;;;;;;;;;;:::i;:::-;;;;;;;;111455:93;111558:28;111577:8;111558:18;:28::i;:::-;111374:220:::0;:::o;114154:22::-;;;;;;;;;;;;;:::o;114234:43::-;;;;;;;;;;;;;;;;;:::o;92061:148::-;92137:4;92176:25;92161:40;;;:11;:40;;;;92154:47;;92061:148;;;:::o;108517:247::-;108580:7;108600:13;108616:17;108625:7;108616:8;:17::i;:::-;108600:33;;108665:1;108648:19;;:5;:19;;;108644:90;;108714:7;108691:31;;;;;;;;;;;:::i;:::-;;;;;;;;108644:90;108751:5;108744:12;;;108517:247;;;:::o;97998:129::-;98068:7;98095:15;:24;98111:7;98095:24;;;;;;;;;;;;;;;;;;;;;98088:31;;97998:129;;;:::o;17169:98::-;17222:7;17249:10;17242:17;;17169:98;:::o;106749:122::-;106830:33;106839:2;106843:7;106852:4;106858;106830:8;:33::i;:::-;106749:122;;;:::o;110606:166::-;110677:12;:10;:12::i;:::-;110666:23;;:7;:5;:7::i;:::-;:23;;;110662:103;;110740:12;:10;:12::i;:::-;110713:40;;;;;;;;;;;:::i;:::-;;;;;;;;110662:103;110606:166::o;100959:824::-;101045:7;101065:12;101080:17;101089:7;101080:8;:17::i;:::-;101065:32;;101176:1;101160:18;;:4;:18;;;101156:88;;101195:37;101212:4;101218;101224:7;101195:16;:37::i;:::-;101156:88;101307:1;101291:18;;:4;:18;;;101287:263;;101409:48;101426:1;101430:7;101447:1;101451:5;101409:8;:48::i;:::-;101522:1;101503:9;:15;101513:4;101503:15;;;;;;;;;;;;;;;;:20;;;;;;;;;;;101287:263;101580:1;101566:16;;:2;:16;;;101562:111;;101645:1;101628:9;:13;101638:2;101628:13;;;;;;;;;;;;;;;;:18;;;;;;;;;;;101562:111;101704:2;101685:7;:16;101693:7;101685:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;101743:7;101739:2;101724:27;;101733:4;101724:27;;;;;;;;;;;;101771:4;101764:11;;;100959:824;;;;;:::o;102817:102::-;102885:26;102895:2;102899:7;102885:26;;;;;;;;;;;;:9;:26::i;:::-;102817:102;;:::o;111754:191::-;111828:16;111847:6;;;;;;;;;;;111828:25;;111873:8;111864:6;;:17;;;;;;;;;;;;;;;;;;111928:8;111897:40;;111918:8;111897:40;;;;;;;;;;;;111817:128;111754:191;:::o;112824:114::-;112889:7;112916;:14;;;112909:21;;112824:114;;;:::o;112946:127::-;113053:1;113035:7;:14;;;:19;;;;;;;;;;;112946:127;:::o;107956:318::-;108084:1;108064:22;;:8;:22;;;108060:93;;108132:8;108110:31;;;;;;;;;;;:::i;:::-;;;;;;;;108060:93;108201:8;108163:18;:25;108182:5;108163:25;;;;;;;;;;;;;;;:35;108189:8;108163:35;;;;;;;;;;;;;;;;:46;;;;;;;;;;;;;;;;;;108247:8;108225:41;;108240:5;108225:41;;;108257:8;108225:41;;;;;;:::i;:::-;;;;;;;;107956:318;;;:::o;15519:948::-;15723:1;15706:2;:14;;;:18;15702:758;;;15761:2;15745:36;;;15782:8;15792:4;15798:7;15807:4;15745:67;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;15741:708;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16125:1;16108:6;:13;:18;16104:330;;16250:2;16214:39;;;;;;;;;;;:::i;:::-;;;;;;;;16104:330;16384:6;16378:13;16369:6;16365:2;16361:15;16354:38;15741:708;15870:41;;;15860:51;;;:6;:51;;;;15856:185;;16018:2;15982:39;;;;;;;;;;;:::i;:::-;;;;;;;;15856:185;15813:243;15702:758;15519:948;;;;;:::o;116346:171::-;116406:13;116432:77;;;;;;;;;;;;;;;;;;;116346:171;:::o;87889:650::-;87945:13;87996:14;88033:1;88013:17;88024:5;88013:10;:17::i;:::-;:21;87996:38;;88049:20;88083:6;88072:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;88049:41;;88105:11;88202:6;88198:2;88194:15;88186:6;88182:28;88175:35;;88239:254;88246:4;88239:254;;;88271:5;;;;;;;;88377:10;88372:2;88365:5;88361:14;88356:32;88351:3;88343:46;88435:2;88426:11;;;;;;:::i;:::-;;;;;88469:1;88460:5;:10;88239:254;88456:21;88239:254;88514:6;88507:13;;;;;87889:650;;;:::o;97760:117::-;97826:7;97853;:16;97861:7;97853:16;;;;;;;;;;;;;;;;;;;;;97846:23;;97760:117;;;:::o;107059:678::-;107221:9;:31;;;;107250:1;107234:18;;:4;:18;;;;107221:31;107217:471;;;107269:13;107285:22;107299:7;107285:13;:22::i;:::-;107269:38;;107454:1;107438:18;;:4;:18;;;;:35;;;;;107469:4;107460:13;;:5;:13;;;;107438:35;:69;;;;;107478:29;107495:5;107502:4;107478:16;:29::i;:::-;107477:30;107438:69;107434:144;;;107557:4;107535:27;;;;;;;;;;;:::i;:::-;;;;;;;;107434:144;107598:9;107594:83;;;107653:7;107649:2;107633:28;;107642:5;107633:28;;;;;;;;;;;;107594:83;107254:434;107217:471;107727:2;107700:15;:24;107716:7;107700:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;107059:678;;;;:::o;99166:376::-;99279:38;99293:5;99300:7;99309;99279:13;:38::i;:::-;99274:261;;99355:1;99338:19;;:5;:19;;;99334:190;;99408:7;99385:31;;;;;;;;;;;:::i;:::-;;;;;;;;99334:190;99491:7;99500;99464:44;;;;;;;;;;;;:::i;:::-;;;;;;;;99274:261;99166:376;;;:::o;103146:210::-;103241:18;103247:2;103251:7;103241:5;:18::i;:::-;103270:78;103304:12;:10;:12::i;:::-;103326:1;103330:2;103334:7;103343:4;103270:33;:78::i;:::-;103146:210;;;:::o;81534:948::-;81587:7;81607:14;81624:1;81607:18;;81674:8;81665:5;:17;81661:106;;81712:8;81703:17;;;;;;:::i;:::-;;;;;81749:2;81739:12;;;;81661:106;81794:8;81785:5;:17;81781:106;;81832:8;81823:17;;;;;;:::i;:::-;;;;;81869:2;81859:12;;;;81781:106;81914:8;81905:5;:17;81901:106;;81952:8;81943:17;;;;;;:::i;:::-;;;;;81989:2;81979:12;;;;81901:106;82034:7;82025:5;:16;82021:103;;82071:7;82062:16;;;;;;:::i;:::-;;;;;82107:1;82097:11;;;;82021:103;82151:7;82142:5;:16;82138:103;;82188:7;82179:16;;;;;;:::i;:::-;;;;;82224:1;82214:11;;;;82138:103;82268:7;82259:5;:16;82255:103;;82305:7;82296:16;;;;;;:::i;:::-;;;;;82341:1;82331:11;;;;82255:103;82385:7;82376:5;:16;82372:68;;82423:1;82413:11;;;;82372:68;82468:6;82461:13;;;81534:948;;;:::o;98447:276::-;98550:4;98606:1;98587:21;;:7;:21;;;;:128;;;;;98635:7;98626:16;;:5;:16;;;:52;;;;98646:32;98663:5;98670:7;98646:16;:32::i;:::-;98626:52;:88;;;;98707:7;98682:32;;:21;98695:7;98682:12;:21::i;:::-;:32;;;98626:88;98587:128;98567:148;;98447:276;;;;;:::o;102119:335::-;102201:1;102187:16;;:2;:16;;;102183:89;;102257:1;102227:33;;;;;;;;;;;:::i;:::-;;;;;;;;102183:89;102282:21;102306:32;102314:2;102318:7;102335:1;102306:7;:32::i;:::-;102282:56;;102378:1;102353:27;;:13;:27;;;102349:98;;102432:1;102404:31;;;;;;;;;;;:::i;:::-;;;;;;;;102349:98;102172:282;102119:335;;:::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:149;370:7;410:66;403:5;399:78;388:89;;334:149;;;:::o;489:120::-;561:23;578:5;561:23;:::i;:::-;554:5;551:34;541:62;;599:1;596;589:12;541:62;489:120;:::o;615:137::-;660:5;698:6;685:20;676:29;;714:32;740:5;714:32;:::i;:::-;615:137;;;;:::o;758:327::-;816:6;865:2;853:9;844:7;840:23;836:32;833:119;;;871:79;;:::i;:::-;833:119;991:1;1016:52;1060:7;1051:6;1040:9;1036:22;1016:52;:::i;:::-;1006:62;;962:116;758:327;;;;:::o;1091:90::-;1125:7;1168:5;1161:13;1154:21;1143:32;;1091:90;;;:::o;1187:109::-;1268:21;1283:5;1268:21;:::i;:::-;1263:3;1256:34;1187:109;;:::o;1302:210::-;1389:4;1427:2;1416:9;1412:18;1404:26;;1440:65;1502:1;1491:9;1487:17;1478:6;1440:65;:::i;:::-;1302:210;;;;:::o;1518:99::-;1570:6;1604:5;1598:12;1588:22;;1518:99;;;:::o;1623:169::-;1707:11;1741:6;1736:3;1729:19;1781:4;1776:3;1772:14;1757:29;;1623:169;;;;:::o;1798:246::-;1879:1;1889:113;1903:6;1900:1;1897:13;1889:113;;;1988:1;1983:3;1979:11;1973:18;1969:1;1964:3;1960:11;1953:39;1925:2;1922:1;1918:10;1913:15;;1889:113;;;2036:1;2027:6;2022:3;2018:16;2011:27;1860:184;1798:246;;;:::o;2050:102::-;2091:6;2142:2;2138:7;2133:2;2126:5;2122:14;2118:28;2108:38;;2050:102;;;:::o;2158:377::-;2246:3;2274:39;2307:5;2274:39;:::i;:::-;2329:71;2393:6;2388:3;2329:71;:::i;:::-;2322:78;;2409:65;2467:6;2462:3;2455:4;2448:5;2444:16;2409:65;:::i;:::-;2499:29;2521:6;2499:29;:::i;:::-;2494:3;2490:39;2483:46;;2250:285;2158:377;;;;:::o;2541:313::-;2654:4;2692:2;2681:9;2677:18;2669:26;;2741:9;2735:4;2731:20;2727:1;2716:9;2712:17;2705:47;2769:78;2842:4;2833:6;2769:78;:::i;:::-;2761:86;;2541:313;;;;:::o;2860:77::-;2897:7;2926:5;2915:16;;2860:77;;;:::o;2943:122::-;3016:24;3034:5;3016:24;:::i;:::-;3009:5;3006:35;2996:63;;3055:1;3052;3045:12;2996:63;2943:122;:::o;3071:139::-;3117:5;3155:6;3142:20;3133:29;;3171:33;3198:5;3171:33;:::i;:::-;3071:139;;;;:::o;3216:329::-;3275:6;3324:2;3312:9;3303:7;3299:23;3295:32;3292:119;;;3330:79;;:::i;:::-;3292:119;3450:1;3475:53;3520:7;3511:6;3500:9;3496:22;3475:53;:::i;:::-;3465:63;;3421:117;3216:329;;;;:::o;3551:126::-;3588:7;3628:42;3621:5;3617:54;3606:65;;3551:126;;;:::o;3683:96::-;3720:7;3749:24;3767:5;3749:24;:::i;:::-;3738:35;;3683:96;;;:::o;3785:118::-;3872:24;3890:5;3872:24;:::i;:::-;3867:3;3860:37;3785:118;;:::o;3909:222::-;4002:4;4040:2;4029:9;4025:18;4017:26;;4053:71;4121:1;4110:9;4106:17;4097:6;4053:71;:::i;:::-;3909:222;;;;:::o;4137:122::-;4210:24;4228:5;4210:24;:::i;:::-;4203:5;4200:35;4190:63;;4249:1;4246;4239:12;4190:63;4137:122;:::o;4265:139::-;4311:5;4349:6;4336:20;4327:29;;4365:33;4392:5;4365:33;:::i;:::-;4265:139;;;;:::o;4410:474::-;4478:6;4486;4535:2;4523:9;4514:7;4510:23;4506:32;4503:119;;;4541:79;;:::i;:::-;4503:119;4661:1;4686:53;4731:7;4722:6;4711:9;4707:22;4686:53;:::i;:::-;4676:63;;4632:117;4788:2;4814:53;4859:7;4850:6;4839:9;4835:22;4814:53;:::i;:::-;4804:63;;4759:118;4410:474;;;;;:::o;4890:116::-;4960:21;4975:5;4960:21;:::i;:::-;4953:5;4950:32;4940:60;;4996:1;4993;4986:12;4940:60;4890:116;:::o;5012:133::-;5055:5;5093:6;5080:20;5071:29;;5109:30;5133:5;5109:30;:::i;:::-;5012:133;;;;:::o;5151:323::-;5207:6;5256:2;5244:9;5235:7;5231:23;5227:32;5224:119;;;5262:79;;:::i;:::-;5224:119;5382:1;5407:50;5449:7;5440:6;5429:9;5425:22;5407:50;:::i;:::-;5397:60;;5353:114;5151:323;;;;:::o;5480:619::-;5557:6;5565;5573;5622:2;5610:9;5601:7;5597:23;5593:32;5590:119;;;5628:79;;:::i;:::-;5590:119;5748:1;5773:53;5818:7;5809:6;5798:9;5794:22;5773:53;:::i;:::-;5763:63;;5719:117;5875:2;5901:53;5946:7;5937:6;5926:9;5922:22;5901:53;:::i;:::-;5891:63;;5846:118;6003:2;6029:53;6074:7;6065:6;6054:9;6050:22;6029:53;:::i;:::-;6019:63;;5974:118;5480:619;;;;;:::o;6105:118::-;6192:24;6210:5;6192:24;:::i;:::-;6187:3;6180:37;6105:118;;:::o;6229:222::-;6322:4;6360:2;6349:9;6345:18;6337:26;;6373:71;6441:1;6430:9;6426:17;6417:6;6373:71;:::i;:::-;6229:222;;;;:::o;6457:329::-;6516:6;6565:2;6553:9;6544:7;6540:23;6536:32;6533:119;;;6571:79;;:::i;:::-;6533:119;6691:1;6716:53;6761:7;6752:6;6741:9;6737:22;6716:53;:::i;:::-;6706:63;;6662:117;6457:329;;;;:::o;6792:468::-;6857:6;6865;6914:2;6902:9;6893:7;6889:23;6885:32;6882:119;;;6920:79;;:::i;:::-;6882:119;7040:1;7065:53;7110:7;7101:6;7090:9;7086:22;7065:53;:::i;:::-;7055:63;;7011:117;7167:2;7193:50;7235:7;7226:6;7215:9;7211:22;7193:50;:::i;:::-;7183:60;;7138:115;6792:468;;;;;:::o;7266:117::-;7375:1;7372;7365:12;7389:117;7498:1;7495;7488:12;7512:180;7560:77;7557:1;7550:88;7657:4;7654:1;7647:15;7681:4;7678:1;7671:15;7698:281;7781:27;7803:4;7781:27;:::i;:::-;7773:6;7769:40;7911:6;7899:10;7896:22;7875:18;7863:10;7860:34;7857:62;7854:88;;;7922:18;;:::i;:::-;7854:88;7962:10;7958:2;7951:22;7741:238;7698:281;;:::o;7985:129::-;8019:6;8046:20;;:::i;:::-;8036:30;;8075:33;8103:4;8095:6;8075:33;:::i;:::-;7985:129;;;:::o;8120:308::-;8182:4;8272:18;8264:6;8261:30;8258:56;;;8294:18;;:::i;:::-;8258:56;8332:29;8354:6;8332:29;:::i;:::-;8324:37;;8416:4;8410;8406:15;8398:23;;8120:308;;;:::o;8434:146::-;8531:6;8526:3;8521;8508:30;8572:1;8563:6;8558:3;8554:16;8547:27;8434:146;;;:::o;8586:425::-;8664:5;8689:66;8705:49;8747:6;8705:49;:::i;:::-;8689:66;:::i;:::-;8680:75;;8778:6;8771:5;8764:21;8816:4;8809:5;8805:16;8854:3;8845:6;8840:3;8836:16;8833:25;8830:112;;;8861:79;;:::i;:::-;8830:112;8951:54;8998:6;8993:3;8988;8951:54;:::i;:::-;8670:341;8586:425;;;;;:::o;9031:340::-;9087:5;9136:3;9129:4;9121:6;9117:17;9113:27;9103:122;;9144:79;;:::i;:::-;9103:122;9261:6;9248:20;9286:79;9361:3;9353:6;9346:4;9338:6;9334:17;9286:79;:::i;:::-;9277:88;;9093:278;9031:340;;;;:::o;9377:509::-;9446:6;9495:2;9483:9;9474:7;9470:23;9466:32;9463:119;;;9501:79;;:::i;:::-;9463:119;9649:1;9638:9;9634:17;9621:31;9679:18;9671:6;9668:30;9665:117;;;9701:79;;:::i;:::-;9665:117;9806:63;9861:7;9852:6;9841:9;9837:22;9806:63;:::i;:::-;9796:73;;9592:287;9377:509;;;;:::o;9892:307::-;9953:4;10043:18;10035:6;10032:30;10029:56;;;10065:18;;:::i;:::-;10029:56;10103:29;10125:6;10103:29;:::i;:::-;10095:37;;10187:4;10181;10177:15;10169:23;;9892:307;;;:::o;10205:423::-;10282:5;10307:65;10323:48;10364:6;10323:48;:::i;:::-;10307:65;:::i;:::-;10298:74;;10395:6;10388:5;10381:21;10433:4;10426:5;10422:16;10471:3;10462:6;10457:3;10453:16;10450:25;10447:112;;;10478:79;;:::i;:::-;10447:112;10568:54;10615:6;10610:3;10605;10568:54;:::i;:::-;10288:340;10205:423;;;;;:::o;10647:338::-;10702:5;10751:3;10744:4;10736:6;10732:17;10728:27;10718:122;;10759:79;;:::i;:::-;10718:122;10876:6;10863:20;10901:78;10975:3;10967:6;10960:4;10952:6;10948:17;10901:78;:::i;:::-;10892:87;;10708:277;10647:338;;;;:::o;10991:943::-;11086:6;11094;11102;11110;11159:3;11147:9;11138:7;11134:23;11130:33;11127:120;;;11166:79;;:::i;:::-;11127:120;11286:1;11311:53;11356:7;11347:6;11336:9;11332:22;11311:53;:::i;:::-;11301:63;;11257:117;11413:2;11439:53;11484:7;11475:6;11464:9;11460:22;11439:53;:::i;:::-;11429:63;;11384:118;11541:2;11567:53;11612:7;11603:6;11592:9;11588:22;11567:53;:::i;:::-;11557:63;;11512:118;11697:2;11686:9;11682:18;11669:32;11728:18;11720:6;11717:30;11714:117;;;11750:79;;:::i;:::-;11714:117;11855:62;11909:7;11900:6;11889:9;11885:22;11855:62;:::i;:::-;11845:72;;11640:287;10991:943;;;;;;;:::o;11940:474::-;12008:6;12016;12065:2;12053:9;12044:7;12040:23;12036:32;12033:119;;;12071:79;;:::i;:::-;12033:119;12191:1;12216:53;12261:7;12252:6;12241:9;12237:22;12216:53;:::i;:::-;12206:63;;12162:117;12318:2;12344:53;12389:7;12380:6;12369:9;12365:22;12344:53;:::i;:::-;12334:63;;12289:118;11940:474;;;;;:::o;12420:180::-;12468:77;12465:1;12458:88;12565:4;12562:1;12555:15;12589:4;12586:1;12579:15;12606:320;12650:6;12687:1;12681:4;12677:12;12667:22;;12734:1;12728:4;12724:12;12755:18;12745:81;;12811:4;12803:6;12799:17;12789:27;;12745:81;12873:2;12865:6;12862:14;12842:18;12839:38;12836:84;;12892:18;;:::i;:::-;12836:84;12657:269;12606:320;;;:::o;12932:442::-;13081:4;13119:2;13108:9;13104:18;13096:26;;13132:71;13200:1;13189:9;13185:17;13176:6;13132:71;:::i;:::-;13213:72;13281:2;13270:9;13266:18;13257:6;13213:72;:::i;:::-;13295;13363:2;13352:9;13348:18;13339:6;13295:72;:::i;:::-;12932:442;;;;;;:::o;13380:141::-;13429:4;13452:3;13444:11;;13475:3;13472:1;13465:14;13509:4;13506:1;13496:18;13488:26;;13380:141;;;:::o;13527:93::-;13564:6;13611:2;13606;13599:5;13595:14;13591:23;13581:33;;13527:93;;;:::o;13626:107::-;13670:8;13720:5;13714:4;13710:16;13689:37;;13626:107;;;;:::o;13739:393::-;13808:6;13858:1;13846:10;13842:18;13881:97;13911:66;13900:9;13881:97;:::i;:::-;13999:39;14029:8;14018:9;13999:39;:::i;:::-;13987:51;;14071:4;14067:9;14060:5;14056:21;14047:30;;14120:4;14110:8;14106:19;14099:5;14096:30;14086:40;;13815:317;;13739:393;;;;;:::o;14138:60::-;14166:3;14187:5;14180:12;;14138:60;;;:::o;14204:142::-;14254:9;14287:53;14305:34;14314:24;14332:5;14314:24;:::i;:::-;14305:34;:::i;:::-;14287:53;:::i;:::-;14274:66;;14204:142;;;:::o;14352:75::-;14395:3;14416:5;14409:12;;14352:75;;;:::o;14433:269::-;14543:39;14574:7;14543:39;:::i;:::-;14604:91;14653:41;14677:16;14653:41;:::i;:::-;14645:6;14638:4;14632:11;14604:91;:::i;:::-;14598:4;14591:105;14509:193;14433:269;;;:::o;14708:73::-;14753:3;14708:73;:::o;14787:189::-;14864:32;;:::i;:::-;14905:65;14963:6;14955;14949:4;14905:65;:::i;:::-;14840:136;14787:189;;:::o;14982:186::-;15042:120;15059:3;15052:5;15049:14;15042:120;;;15113:39;15150:1;15143:5;15113:39;:::i;:::-;15086:1;15079:5;15075:13;15066:22;;15042:120;;;14982:186;;:::o;15174:543::-;15275:2;15270:3;15267:11;15264:446;;;15309:38;15341:5;15309:38;:::i;:::-;15393:29;15411:10;15393:29;:::i;:::-;15383:8;15379:44;15576:2;15564:10;15561:18;15558:49;;;15597:8;15582:23;;15558:49;15620:80;15676:22;15694:3;15676:22;:::i;:::-;15666:8;15662:37;15649:11;15620:80;:::i;:::-;15279:431;;15264:446;15174:543;;;:::o;15723:117::-;15777:8;15827:5;15821:4;15817:16;15796:37;;15723:117;;;;:::o;15846:169::-;15890:6;15923:51;15971:1;15967:6;15959:5;15956:1;15952:13;15923:51;:::i;:::-;15919:56;16004:4;15998;15994:15;15984:25;;15897:118;15846:169;;;;:::o;16020:295::-;16096:4;16242:29;16267:3;16261:4;16242:29;:::i;:::-;16234:37;;16304:3;16301:1;16297:11;16291:4;16288:21;16280:29;;16020:295;;;;:::o;16320:1395::-;16437:37;16470:3;16437:37;:::i;:::-;16539:18;16531:6;16528:30;16525:56;;;16561:18;;:::i;:::-;16525:56;16605:38;16637:4;16631:11;16605:38;:::i;:::-;16690:67;16750:6;16742;16736:4;16690:67;:::i;:::-;16784:1;16808:4;16795:17;;16840:2;16832:6;16829:14;16857:1;16852:618;;;;17514:1;17531:6;17528:77;;;17580:9;17575:3;17571:19;17565:26;17556:35;;17528:77;17631:67;17691:6;17684:5;17631:67;:::i;:::-;17625:4;17618:81;17487:222;16822:887;;16852:618;16904:4;16900:9;16892:6;16888:22;16938:37;16970:4;16938:37;:::i;:::-;16997:1;17011:208;17025:7;17022:1;17019:14;17011:208;;;17104:9;17099:3;17095:19;17089:26;17081:6;17074:42;17155:1;17147:6;17143:14;17133:24;;17202:2;17191:9;17187:18;17174:31;;17048:4;17045:1;17041:12;17036:17;;17011:208;;;17247:6;17238:7;17235:19;17232:179;;;17305:9;17300:3;17296:19;17290:26;17348:48;17390:4;17382:6;17378:17;17367:9;17348:48;:::i;:::-;17340:6;17333:64;17255:156;17232:179;17457:1;17453;17445:6;17441:14;17437:22;17431:4;17424:36;16859:611;;;16822:887;;16412:1303;;;16320:1395;;:::o;17721:180::-;17769:77;17766:1;17759:88;17866:4;17863:1;17856:15;17890:4;17887:1;17880:15;17907:191;17947:3;17966:20;17984:1;17966:20;:::i;:::-;17961:25;;18000:20;18018:1;18000:20;:::i;:::-;17995:25;;18043:1;18040;18036:9;18029:16;;18064:3;18061:1;18058:10;18055:36;;;18071:18;;:::i;:::-;18055:36;17907:191;;;;:::o;18104:233::-;18143:3;18166:24;18184:5;18166:24;:::i;:::-;18157:33;;18212:66;18205:5;18202:77;18199:103;;18282:18;;:::i;:::-;18199:103;18329:1;18322:5;18318:13;18311:20;;18104:233;;;:::o;18343:410::-;18383:7;18406:20;18424:1;18406:20;:::i;:::-;18401:25;;18440:20;18458:1;18440:20;:::i;:::-;18435:25;;18495:1;18492;18488:9;18517:30;18535:11;18517:30;:::i;:::-;18506:41;;18696:1;18687:7;18683:15;18680:1;18677:22;18657:1;18650:9;18630:83;18607:139;;18726:18;;:::i;:::-;18607:139;18391:362;18343:410;;;;:::o;18759:194::-;18799:4;18819:20;18837:1;18819:20;:::i;:::-;18814:25;;18853:20;18871:1;18853:20;:::i;:::-;18848:25;;18897:1;18894;18890:9;18882:17;;18921:1;18915:4;18912:11;18909:37;;;18926:18;;:::i;:::-;18909:37;18759:194;;;;:::o;18959:180::-;19007:77;19004:1;18997:88;19104:4;19101:1;19094:15;19128:4;19125:1;19118:15;19145:185;19185:1;19202:20;19220:1;19202:20;:::i;:::-;19197:25;;19236:20;19254:1;19236:20;:::i;:::-;19231:25;;19275:1;19265:35;;19280:18;;:::i;:::-;19265:35;19322:1;19319;19315:9;19310:14;;19145:185;;;;:::o;19336:148::-;19438:11;19475:3;19460:18;;19336:148;;;;:::o;19490:390::-;19596:3;19624:39;19657:5;19624:39;:::i;:::-;19679:89;19761:6;19756:3;19679:89;:::i;:::-;19672:96;;19777:65;19835:6;19830:3;19823:4;19816:5;19812:16;19777:65;:::i;:::-;19867:6;19862:3;19858:16;19851:23;;19600:280;19490:390;;;;:::o;19886:155::-;20026:7;20022:1;20014:6;20010:14;20003:31;19886:155;:::o;20047:400::-;20207:3;20228:84;20310:1;20305:3;20228:84;:::i;:::-;20221:91;;20321:93;20410:3;20321:93;:::i;:::-;20439:1;20434:3;20430:11;20423:18;;20047:400;;;:::o;20453:701::-;20734:3;20756:95;20847:3;20838:6;20756:95;:::i;:::-;20749:102;;20868:95;20959:3;20950:6;20868:95;:::i;:::-;20861:102;;20980:148;21124:3;20980:148;:::i;:::-;20973:155;;21145:3;21138:10;;20453:701;;;;;:::o;21160:98::-;21211:6;21245:5;21239:12;21229:22;;21160:98;;;:::o;21264:168::-;21347:11;21381:6;21376:3;21369:19;21421:4;21416:3;21412:14;21397:29;;21264:168;;;;:::o;21438:373::-;21524:3;21552:38;21584:5;21552:38;:::i;:::-;21606:70;21669:6;21664:3;21606:70;:::i;:::-;21599:77;;21685:65;21743:6;21738:3;21731:4;21724:5;21720:16;21685:65;:::i;:::-;21775:29;21797:6;21775:29;:::i;:::-;21770:3;21766:39;21759:46;;21528:283;21438:373;;;;:::o;21817:640::-;22012:4;22050:3;22039:9;22035:19;22027:27;;22064:71;22132:1;22121:9;22117:17;22108:6;22064:71;:::i;:::-;22145:72;22213:2;22202:9;22198:18;22189:6;22145:72;:::i;:::-;22227;22295:2;22284:9;22280:18;22271:6;22227:72;:::i;:::-;22346:9;22340:4;22336:20;22331:2;22320:9;22316:18;22309:48;22374:76;22445:4;22436:6;22374:76;:::i;:::-;22366:84;;21817:640;;;;;;;:::o;22463:141::-;22519:5;22550:6;22544:13;22535:22;;22566:32;22592:5;22566:32;:::i;:::-;22463:141;;;;:::o;22610:349::-;22679:6;22728:2;22716:9;22707:7;22703:23;22699:32;22696:119;;;22734:79;;:::i;:::-;22696:119;22854:1;22879:63;22934:7;22925:6;22914:9;22910:22;22879:63;:::i;:::-;22869:73;;22825:127;22610:349;;;;:::o;22965:332::-;23086:4;23124:2;23113:9;23109:18;23101:26;;23137:71;23205:1;23194:9;23190:17;23181:6;23137:71;:::i;:::-;23218:72;23286:2;23275:9;23271:18;23262:6;23218:72;:::i;:::-;22965:332;;;;;:::o
Swarm Source
ipfs://b2baea14a538f8b3cc8bc83539e99f8f232445f87c6edb736f2701bd6831ecb6
[ 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.