Overview
ETH Balance
0.18 ETH
Eth Value
$458.09 (@ $2,544.93/ETH)More Info
Private Name Tags
ContractCreator
TokenTracker
Latest 25 from a total of 67 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Withdraw Unclaim... | 19558693 | 206 days ago | IN | 0 ETH | 0.00075263 | ||||
Buy Game | 19260034 | 248 days ago | IN | 0.01 ETH | 0.00153036 | ||||
Buy Game | 19257747 | 248 days ago | IN | 0.01 ETH | 0.00152206 | ||||
Buy Game | 19257731 | 248 days ago | IN | 0.01 ETH | 0.00148375 | ||||
Buy Game | 19244485 | 250 days ago | IN | 0.01 ETH | 0.00113338 | ||||
Withdraw Treasur... | 18647849 | 333 days ago | IN | 0 ETH | 0.00089566 | ||||
Withdraw Creator... | 18624721 | 337 days ago | IN | 0 ETH | 0.00130203 | ||||
Buy Game | 18101697 | 410 days ago | IN | 0.01 ETH | 0.00069732 | ||||
Buy Game | 17782647 | 455 days ago | IN | 0.01 ETH | 0.00139631 | ||||
Buy Game | 17782636 | 455 days ago | IN | 0.01 ETH | 0.0010348 | ||||
Create Game | 17748610 | 459 days ago | IN | 0 ETH | 0.0014824 | ||||
Buy Game | 17720474 | 463 days ago | IN | 0.01 ETH | 0.00243379 | ||||
Buy Game | 17707719 | 465 days ago | IN | 0.01 ETH | 0.00112524 | ||||
Buy Game | 17610775 | 479 days ago | IN | 0.01 ETH | 0.00123287 | ||||
Set URI | 17599587 | 480 days ago | IN | 0 ETH | 0.00080022 | ||||
Set URI | 17599455 | 480 days ago | IN | 0 ETH | 0.00102199 | ||||
Buy Game | 17588888 | 482 days ago | IN | 0.01 ETH | 0.00139163 | ||||
Buy Game | 17588200 | 482 days ago | IN | 0.01 ETH | 0.00189778 | ||||
Buy Game | 17588173 | 482 days ago | IN | 0.01 ETH | 0.00196257 | ||||
Buy Game | 17583921 | 482 days ago | IN | 0.01 ETH | 0.00118469 | ||||
Claim Reward | 17581761 | 483 days ago | IN | 0 ETH | 0.00177205 | ||||
Claim Reward | 17581667 | 483 days ago | IN | 0 ETH | 0.00187745 | ||||
Buy Game | 17581608 | 483 days ago | IN | 0.01 ETH | 0.00157089 | ||||
Claim Reward | 17581602 | 483 days ago | IN | 0 ETH | 0.00224571 | ||||
Buy Game | 17577636 | 483 days ago | IN | 0.01 ETH | 0.00125034 |
Loading...
Loading
Contract Name:
Passphrase
Compiler Version
v0.8.17+commit.8df45f5f
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2023-06-20 */ // SPDX-License-Identifier: MIT pragma solidity 0.8.17; // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC1155/extensions/ERC1155Supply.sol) // OpenZeppelin Contracts (last updated v4.8.0) (token/ERC1155/ERC1155.sol) // OpenZeppelin Contracts (last updated v4.7.0) (token/ERC1155/IERC1155.sol) // OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol) /** * @dev Interface of the ERC165 standard, as defined in the * https://eips.ethereum.org/EIPS/eip-165[EIP]. * * Implementers can declare support of contract interfaces, which can then be * queried by others ({ERC165Checker}). * * For an implementation, see {ERC165}. */ interface IERC165 { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); } /** * @dev Required interface of an ERC1155 compliant contract, as defined in the * https://eips.ethereum.org/EIPS/eip-1155[EIP]. * * _Available since v3.1._ */ interface IERC1155 is IERC165 { /** * @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`. */ event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value); /** * @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all * transfers. */ event TransferBatch( address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] values ); /** * @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to * `approved`. */ event ApprovalForAll(address indexed account, address indexed operator, bool approved); /** * @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI. * * If an {URI} event was emitted for `id`, the standard * https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value * returned by {IERC1155MetadataURI-uri}. */ event URI(string value, uint256 indexed id); /** * @dev Returns the amount of tokens of token type `id` owned by `account`. * * Requirements: * * - `account` cannot be the zero address. */ function balanceOf(address account, uint256 id) external view returns (uint256); /** * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}. * * Requirements: * * - `accounts` and `ids` must have the same length. */ function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids) external view returns (uint256[] memory); /** * @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`, * * Emits an {ApprovalForAll} event. * * Requirements: * * - `operator` cannot be the caller. */ function setApprovalForAll(address operator, bool approved) external; /** * @dev Returns true if `operator` is approved to transfer ``account``'s tokens. * * See {setApprovalForAll}. */ function isApprovedForAll(address account, address operator) external view returns (bool); /** * @dev Transfers `amount` tokens of token type `id` from `from` to `to`. * * Emits a {TransferSingle} event. * * Requirements: * * - `to` cannot be the zero address. * - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}. * - `from` must have a balance of tokens of type `id` of at least `amount`. * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the * acceptance magic value. */ function safeTransferFrom( address from, address to, uint256 id, uint256 amount, bytes calldata data ) external; /** * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}. * * Emits a {TransferBatch} event. * * Requirements: * * - `ids` and `amounts` must have the same length. * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the * acceptance magic value. */ function safeBatchTransferFrom( address from, address to, uint256[] calldata ids, uint256[] calldata amounts, bytes calldata data ) external; } // OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/IERC1155Receiver.sol) /** * @dev _Available since v3.1._ */ interface IERC1155Receiver is IERC165 { /** * @dev Handles the receipt of a single ERC1155 token type. This function is * called at the end of a `safeTransferFrom` after the balance has been updated. * * NOTE: To accept the transfer, this must return * `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` * (i.e. 0xf23a6e61, or its own function selector). * * @param operator The address which initiated the transfer (i.e. msg.sender) * @param from The address which previously owned the token * @param id The ID of the token being transferred * @param value The amount of tokens being transferred * @param data Additional data with no specified format * @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed */ function onERC1155Received( address operator, address from, uint256 id, uint256 value, bytes calldata data ) external returns (bytes4); /** * @dev Handles the receipt of a multiple ERC1155 token types. This function * is called at the end of a `safeBatchTransferFrom` after the balances have * been updated. * * NOTE: To accept the transfer(s), this must return * `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` * (i.e. 0xbc197c81, or its own function selector). * * @param operator The address which initiated the batch transfer (i.e. msg.sender) * @param from The address which previously owned the token * @param ids An array containing ids of each token being transferred (order and length must match values array) * @param values An array containing amounts of each token being transferred (order and length must match ids array) * @param data Additional data with no specified format * @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed */ function onERC1155BatchReceived( address operator, address from, uint256[] calldata ids, uint256[] calldata values, bytes calldata data ) external returns (bytes4); } // OpenZeppelin Contracts v4.4.1 (token/ERC1155/extensions/IERC1155MetadataURI.sol) /** * @dev Interface of the optional ERC1155MetadataExtension interface, as defined * in the https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[EIP]. * * _Available since v3.1._ */ interface IERC1155MetadataURI is IERC1155 { /** * @dev Returns the URI for token type `id`. * * If the `\{id\}` substring is present in the URI, it must be replaced by * clients with the actual token type ID. */ function uri(uint256 id) external view returns (string memory); } // OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol) /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== * * [IMPORTANT] * ==== * You shouldn't rely on `isContract` to protect against flash loan attacks! * * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract * constructor. * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize/address.code.length, which returns 0 // for contracts in construction, since the code is only stored at the end // of the constructor execution. return account.code.length > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); (bool success, ) = recipient.call{value: amount}(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value ) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage ) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall( address target, bytes memory data, string memory errorMessage ) internal view returns (bytes memory) { (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract. * * _Available since v4.8._ */ function verifyCallResultFromTarget( address target, bool success, bytes memory returndata, string memory errorMessage ) internal view returns (bytes memory) { if (success) { if (returndata.length == 0) { // only check isContract if the call was successful and the return data is empty // otherwise we already know that it was a contract require(isContract(target), "Address: call to non-contract"); } return returndata; } else { _revert(returndata, errorMessage); } } /** * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason or using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal pure returns (bytes memory) { if (success) { return returndata; } else { _revert(returndata, errorMessage); } } function _revert(bytes memory returndata, string memory errorMessage) private pure { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } // OpenZeppelin Contracts v4.4.1 (utils/Context.sol) /** * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } } // OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol) /** * @dev Implementation of the {IERC165} interface. * * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check * for the additional interface id that will be supported. For example: * * ```solidity * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId); * } * ``` * * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation. */ abstract contract ERC165 is IERC165 { /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IERC165).interfaceId; } } /** * @dev Implementation of the basic standard multi-token. * See https://eips.ethereum.org/EIPS/eip-1155 * Originally based on code by Enjin: https://github.com/enjin/erc-1155 * * _Available since v3.1._ */ contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI { using Address for address; // Mapping from token ID to account balances mapping(uint256 => mapping(address => uint256)) private _balances; // Mapping from account to operator approvals mapping(address => mapping(address => bool)) private _operatorApprovals; // Used as the URI for all token types by relying on ID substitution, e.g. https://token-cdn-domain/{id}.json string private _uri; /** * @dev See {_setURI}. */ constructor(string memory uri_) { _setURI(uri_); } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) { return interfaceId == type(IERC1155).interfaceId || interfaceId == type(IERC1155MetadataURI).interfaceId || super.supportsInterface(interfaceId); } /** * @dev See {IERC1155MetadataURI-uri}. * * This implementation returns the same URI for *all* token types. It relies * on the token type ID substitution mechanism * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP]. * * Clients calling this function must replace the `\{id\}` substring with the * actual token type ID. */ function uri(uint256) public view virtual override returns (string memory) { return _uri; } /** * @dev See {IERC1155-balanceOf}. * * Requirements: * * - `account` cannot be the zero address. */ function balanceOf(address account, uint256 id) public view virtual override returns (uint256) { require(account != address(0), "ERC1155: address zero is not a valid owner"); return _balances[id][account]; } /** * @dev See {IERC1155-balanceOfBatch}. * * Requirements: * * - `accounts` and `ids` must have the same length. */ function balanceOfBatch(address[] memory accounts, uint256[] memory ids) public view virtual override returns (uint256[] memory) { require(accounts.length == ids.length, "ERC1155: accounts and ids length mismatch"); uint256[] memory batchBalances = new uint256[](accounts.length); for (uint256 i = 0; i < accounts.length; ++i) { batchBalances[i] = balanceOf(accounts[i], ids[i]); } return batchBalances; } /** * @dev See {IERC1155-setApprovalForAll}. */ function setApprovalForAll(address operator, bool approved) public virtual override { _setApprovalForAll(_msgSender(), operator, approved); } /** * @dev See {IERC1155-isApprovedForAll}. */ function isApprovedForAll(address account, address operator) public view virtual override returns (bool) { return _operatorApprovals[account][operator]; } /** * @dev See {IERC1155-safeTransferFrom}. */ function safeTransferFrom( address from, address to, uint256 id, uint256 amount, bytes memory data ) public virtual override { require( from == _msgSender() || isApprovedForAll(from, _msgSender()), "ERC1155: caller is not token owner or approved" ); _safeTransferFrom(from, to, id, amount, data); } /** * @dev See {IERC1155-safeBatchTransferFrom}. */ function safeBatchTransferFrom( address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data ) public virtual override { require( from == _msgSender() || isApprovedForAll(from, _msgSender()), "ERC1155: caller is not token owner or approved" ); _safeBatchTransferFrom(from, to, ids, amounts, data); } /** * @dev Transfers `amount` tokens of token type `id` from `from` to `to`. * * Emits a {TransferSingle} event. * * Requirements: * * - `to` cannot be the zero address. * - `from` must have a balance of tokens of type `id` of at least `amount`. * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the * acceptance magic value. */ function _safeTransferFrom( address from, address to, uint256 id, uint256 amount, bytes memory data ) internal virtual { require(to != address(0), "ERC1155: transfer to the zero address"); address operator = _msgSender(); uint256[] memory ids = _asSingletonArray(id); uint256[] memory amounts = _asSingletonArray(amount); _beforeTokenTransfer(operator, from, to, ids, amounts, data); uint256 fromBalance = _balances[id][from]; require(fromBalance >= amount, "ERC1155: insufficient balance for transfer"); unchecked { _balances[id][from] = fromBalance - amount; } _balances[id][to] += amount; emit TransferSingle(operator, from, to, id, amount); _afterTokenTransfer(operator, from, to, ids, amounts, data); _doSafeTransferAcceptanceCheck(operator, from, to, id, amount, data); } /** * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_safeTransferFrom}. * * Emits a {TransferBatch} event. * * Requirements: * * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the * acceptance magic value. */ function _safeBatchTransferFrom( address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data ) internal virtual { require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch"); require(to != address(0), "ERC1155: transfer to the zero address"); address operator = _msgSender(); _beforeTokenTransfer(operator, from, to, ids, amounts, data); for (uint256 i = 0; i < ids.length; ++i) { uint256 id = ids[i]; uint256 amount = amounts[i]; uint256 fromBalance = _balances[id][from]; require(fromBalance >= amount, "ERC1155: insufficient balance for transfer"); unchecked { _balances[id][from] = fromBalance - amount; } _balances[id][to] += amount; } emit TransferBatch(operator, from, to, ids, amounts); _afterTokenTransfer(operator, from, to, ids, amounts, data); _doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, amounts, data); } /** * @dev Sets a new URI for all token types, by relying on the token type ID * substitution mechanism * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP]. * * By this mechanism, any occurrence of the `\{id\}` substring in either the * URI or any of the amounts in the JSON file at said URI will be replaced by * clients with the token type ID. * * For example, the `https://token-cdn-domain/\{id\}.json` URI would be * interpreted by clients as * `https://token-cdn-domain/000000000000000000000000000000000000000000000000000000000004cce0.json` * for token type ID 0x4cce0. * * See {uri}. * * Because these URIs cannot be meaningfully represented by the {URI} event, * this function emits no events. */ function _setURI(string memory newuri) internal virtual { _uri = newuri; } /** * @dev Creates `amount` tokens of token type `id`, and assigns them to `to`. * * Emits a {TransferSingle} event. * * Requirements: * * - `to` cannot be the zero address. * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the * acceptance magic value. */ function _mint( address to, uint256 id, uint256 amount, bytes memory data ) internal virtual { require(to != address(0), "ERC1155: mint to the zero address"); address operator = _msgSender(); uint256[] memory ids = _asSingletonArray(id); uint256[] memory amounts = _asSingletonArray(amount); _beforeTokenTransfer(operator, address(0), to, ids, amounts, data); _balances[id][to] += amount; emit TransferSingle(operator, address(0), to, id, amount); _afterTokenTransfer(operator, address(0), to, ids, amounts, data); _doSafeTransferAcceptanceCheck(operator, address(0), to, id, amount, data); } /** * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_mint}. * * Emits a {TransferBatch} event. * * Requirements: * * - `ids` and `amounts` must have the same length. * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the * acceptance magic value. */ function _mintBatch( address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data ) internal virtual { require(to != address(0), "ERC1155: mint to the zero address"); require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch"); address operator = _msgSender(); _beforeTokenTransfer(operator, address(0), to, ids, amounts, data); for (uint256 i = 0; i < ids.length; i++) { _balances[ids[i]][to] += amounts[i]; } emit TransferBatch(operator, address(0), to, ids, amounts); _afterTokenTransfer(operator, address(0), to, ids, amounts, data); _doSafeBatchTransferAcceptanceCheck(operator, address(0), to, ids, amounts, data); } /** * @dev Destroys `amount` tokens of token type `id` from `from` * * Emits a {TransferSingle} event. * * Requirements: * * - `from` cannot be the zero address. * - `from` must have at least `amount` tokens of token type `id`. */ function _burn( address from, uint256 id, uint256 amount ) internal virtual { require(from != address(0), "ERC1155: burn from the zero address"); address operator = _msgSender(); uint256[] memory ids = _asSingletonArray(id); uint256[] memory amounts = _asSingletonArray(amount); _beforeTokenTransfer(operator, from, address(0), ids, amounts, ""); uint256 fromBalance = _balances[id][from]; require(fromBalance >= amount, "ERC1155: burn amount exceeds balance"); unchecked { _balances[id][from] = fromBalance - amount; } emit TransferSingle(operator, from, address(0), id, amount); _afterTokenTransfer(operator, from, address(0), ids, amounts, ""); } /** * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_burn}. * * Emits a {TransferBatch} event. * * Requirements: * * - `ids` and `amounts` must have the same length. */ function _burnBatch( address from, uint256[] memory ids, uint256[] memory amounts ) internal virtual { require(from != address(0), "ERC1155: burn from the zero address"); require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch"); address operator = _msgSender(); _beforeTokenTransfer(operator, from, address(0), ids, amounts, ""); for (uint256 i = 0; i < ids.length; i++) { uint256 id = ids[i]; uint256 amount = amounts[i]; uint256 fromBalance = _balances[id][from]; require(fromBalance >= amount, "ERC1155: burn amount exceeds balance"); unchecked { _balances[id][from] = fromBalance - amount; } } emit TransferBatch(operator, from, address(0), ids, amounts); _afterTokenTransfer(operator, from, address(0), ids, amounts, ""); } /** * @dev Approve `operator` to operate on all of `owner` tokens * * Emits an {ApprovalForAll} event. */ function _setApprovalForAll( address owner, address operator, bool approved ) internal virtual { require(owner != operator, "ERC1155: setting approval status for self"); _operatorApprovals[owner][operator] = approved; emit ApprovalForAll(owner, operator, approved); } /** * @dev Hook that is called before any token transfer. This includes minting * and burning, as well as batched variants. * * The same hook is called on both single and batched variants. For single * transfers, the length of the `ids` and `amounts` arrays will be 1. * * Calling conditions (for each `id` and `amount` pair): * * - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens * of token type `id` will be transferred to `to`. * - When `from` is zero, `amount` tokens of token type `id` will be minted * for `to`. * - when `to` is zero, `amount` of ``from``'s tokens of token type `id` * will be burned. * - `from` and `to` are never both zero. * - `ids` and `amounts` have the same, non-zero length. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer( address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data ) internal virtual {} /** * @dev Hook that is called after any token transfer. This includes minting * and burning, as well as batched variants. * * The same hook is called on both single and batched variants. For single * transfers, the length of the `id` and `amount` arrays will be 1. * * Calling conditions (for each `id` and `amount` pair): * * - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens * of token type `id` will be transferred to `to`. * - When `from` is zero, `amount` tokens of token type `id` will be minted * for `to`. * - when `to` is zero, `amount` of ``from``'s tokens of token type `id` * will be burned. * - `from` and `to` are never both zero. * - `ids` and `amounts` have the same, non-zero length. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _afterTokenTransfer( address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data ) internal virtual {} function _doSafeTransferAcceptanceCheck( address operator, address from, address to, uint256 id, uint256 amount, bytes memory data ) private { if (to.isContract()) { try IERC1155Receiver(to).onERC1155Received(operator, from, id, amount, data) returns (bytes4 response) { if (response != IERC1155Receiver.onERC1155Received.selector) { revert("ERC1155: ERC1155Receiver rejected tokens"); } } catch Error(string memory reason) { revert(reason); } catch { revert("ERC1155: transfer to non-ERC1155Receiver implementer"); } } } function _doSafeBatchTransferAcceptanceCheck( address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data ) private { if (to.isContract()) { try IERC1155Receiver(to).onERC1155BatchReceived(operator, from, ids, amounts, data) returns ( bytes4 response ) { if (response != IERC1155Receiver.onERC1155BatchReceived.selector) { revert("ERC1155: ERC1155Receiver rejected tokens"); } } catch Error(string memory reason) { revert(reason); } catch { revert("ERC1155: transfer to non-ERC1155Receiver implementer"); } } } function _asSingletonArray(uint256 element) private pure returns (uint256[] memory) { uint256[] memory array = new uint256[](1); array[0] = element; return array; } } /** * @dev Extension of ERC1155 that adds tracking of total supply per id. * * Useful for scenarios where Fungible and Non-fungible tokens have to be * clearly identified. Note: While a totalSupply of 1 might mean the * corresponding is an NFT, there is no guarantees that no other token with the * same id are not going to be minted. */ abstract contract ERC1155Supply is ERC1155 { mapping(uint256 => uint256) private _totalSupply; /** * @dev Total amount of tokens in with a given id. */ function totalSupply(uint256 id) public view virtual returns (uint256) { return _totalSupply[id]; } /** * @dev Indicates whether any token exist with a given id, or not. */ function exists(uint256 id) public view virtual returns (bool) { return ERC1155Supply.totalSupply(id) > 0; } /** * @dev See {ERC1155-_beforeTokenTransfer}. */ function _beforeTokenTransfer( address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data ) internal virtual override { super._beforeTokenTransfer(operator, from, to, ids, amounts, data); if (from == address(0)) { for (uint256 i = 0; i < ids.length; ++i) { _totalSupply[ids[i]] += amounts[i]; } } if (to == address(0)) { for (uint256 i = 0; i < ids.length; ++i) { uint256 id = ids[i]; uint256 amount = amounts[i]; uint256 supply = _totalSupply[id]; require(supply >= amount, "ERC1155: burn amount exceeds totalSupply"); unchecked { _totalSupply[id] = supply - amount; } } } } } // OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/ECDSA.sol) // OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol) // OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol) /** * @dev Standard math utilities missing in the Solidity language. */ library Math { enum Rounding { Down, // Toward negative infinity Up, // Toward infinity Zero // Toward zero } /** * @dev Returns the largest of two numbers. */ function max(uint256 a, uint256 b) internal pure returns (uint256) { return a > b ? a : b; } /** * @dev Returns the smallest of two numbers. */ function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } /** * @dev Returns the average of two numbers. The result is rounded towards * zero. */ function average(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b) / 2 can overflow. return (a & b) + (a ^ b) / 2; } /** * @dev Returns the ceiling of the division of two numbers. * * This differs from standard division with `/` in that it rounds up instead * of rounding down. */ function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b - 1) / b can overflow on addition, so we distribute. return a == 0 ? 0 : (a - 1) / b + 1; } /** * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0 * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) * with further edits by Uniswap Labs also under MIT license. */ function mulDiv( uint256 x, uint256 y, uint256 denominator ) internal pure returns (uint256 result) { unchecked { // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256 // variables such that product = prod1 * 2^256 + prod0. uint256 prod0; // Least significant 256 bits of the product uint256 prod1; // Most significant 256 bits of the product assembly { let mm := mulmod(x, y, not(0)) prod0 := mul(x, y) prod1 := sub(sub(mm, prod0), lt(mm, prod0)) } // Handle non-overflow cases, 256 by 256 division. if (prod1 == 0) { return prod0 / denominator; } // Make sure the result is less than 2^256. Also prevents denominator == 0. require(denominator > prod1); /////////////////////////////////////////////// // 512 by 256 division. /////////////////////////////////////////////// // Make division exact by subtracting the remainder from [prod1 prod0]. uint256 remainder; assembly { // Compute remainder using mulmod. remainder := mulmod(x, y, denominator) // Subtract 256 bit number from 512 bit number. prod1 := sub(prod1, gt(remainder, prod0)) prod0 := sub(prod0, remainder) } // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1. // See https://cs.stackexchange.com/q/138556/92363. // Does not overflow because the denominator cannot be zero at this stage in the function. uint256 twos = denominator & (~denominator + 1); assembly { // Divide denominator by twos. denominator := div(denominator, twos) // Divide [prod1 prod0] by twos. prod0 := div(prod0, twos) // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one. twos := add(div(sub(0, twos), twos), 1) } // Shift in bits from prod1 into prod0. prod0 |= prod1 * twos; // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for // four bits. That is, denominator * inv = 1 mod 2^4. uint256 inverse = (3 * denominator) ^ 2; // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works // in modular arithmetic, doubling the correct bits in each step. inverse *= 2 - denominator * inverse; // inverse mod 2^8 inverse *= 2 - denominator * inverse; // inverse mod 2^16 inverse *= 2 - denominator * inverse; // inverse mod 2^32 inverse *= 2 - denominator * inverse; // inverse mod 2^64 inverse *= 2 - denominator * inverse; // inverse mod 2^128 inverse *= 2 - denominator * inverse; // inverse mod 2^256 // Because the division is now exact we can divide by multiplying with the modular inverse of denominator. // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1 // is no longer required. result = prod0 * inverse; return result; } } /** * @notice Calculates x * y / denominator with full precision, following the selected rounding direction. */ function mulDiv( uint256 x, uint256 y, uint256 denominator, Rounding rounding ) internal pure returns (uint256) { uint256 result = mulDiv(x, y, denominator); if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) { result += 1; } return result; } /** * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down. * * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11). */ function sqrt(uint256 a) internal pure returns (uint256) { if (a == 0) { return 0; } // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target. // // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`. // // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)` // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))` // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)` // // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit. uint256 result = 1 << (log2(a) >> 1); // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128, // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision // into the expected uint128 result. unchecked { result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; return min(result, a / result); } } /** * @notice Calculates sqrt(a), following the selected rounding direction. */ function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = sqrt(a); return result + (rounding == Rounding.Up && result * result < a ? 1 : 0); } } /** * @dev Return the log in base 2, rounded down, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 128; } if (value >> 64 > 0) { value >>= 64; result += 64; } if (value >> 32 > 0) { value >>= 32; result += 32; } if (value >> 16 > 0) { value >>= 16; result += 16; } if (value >> 8 > 0) { value >>= 8; result += 8; } if (value >> 4 > 0) { value >>= 4; result += 4; } if (value >> 2 > 0) { value >>= 2; result += 2; } if (value >> 1 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 2, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log2(value); return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0); } } /** * @dev Return the log in base 10, rounded down, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >= 10**64) { value /= 10**64; result += 64; } if (value >= 10**32) { value /= 10**32; result += 32; } if (value >= 10**16) { value /= 10**16; result += 16; } if (value >= 10**8) { value /= 10**8; result += 8; } if (value >= 10**4) { value /= 10**4; result += 4; } if (value >= 10**2) { value /= 10**2; result += 2; } if (value >= 10**1) { result += 1; } } return result; } /** * @dev Return the log in base 10, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log10(value); return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0); } } /** * @dev Return the log in base 256, rounded down, of a positive value. * Returns 0 if given 0. * * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string. */ function log256(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 16; } if (value >> 64 > 0) { value >>= 64; result += 8; } if (value >> 32 > 0) { value >>= 32; result += 4; } if (value >> 16 > 0) { value >>= 16; result += 2; } if (value >> 8 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 10, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log256(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log256(value); return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0); } } } /** * @dev String operations. */ library Strings { bytes16 private constant _SYMBOLS = "0123456789abcdef"; uint8 private constant _ADDRESS_LENGTH = 20; /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function toString(uint256 value) internal pure returns (string memory) { unchecked { uint256 length = Math.log10(value) + 1; string memory buffer = new string(length); uint256 ptr; /// @solidity memory-safe-assembly assembly { ptr := add(buffer, add(32, length)) } while (true) { ptr--; /// @solidity memory-safe-assembly assembly { mstore8(ptr, byte(mod(value, 10), _SYMBOLS)) } value /= 10; if (value == 0) break; } return buffer; } } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { unchecked { return toHexString(value, Math.log256(value) + 1); } } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length. */ function toHexString(uint256 value, uint256 length) internal pure returns (string memory) { bytes memory buffer = new bytes(2 * length + 2); buffer[0] = "0"; buffer[1] = "x"; for (uint256 i = 2 * length + 1; i > 1; --i) { buffer[i] = _SYMBOLS[value & 0xf]; value >>= 4; } require(value == 0, "Strings: hex length insufficient"); return string(buffer); } /** * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation. */ function toHexString(address addr) internal pure returns (string memory) { return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH); } } /** * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations. * * These functions can be used to verify that a message was signed by the holder * of the private keys of a given address. */ library ECDSA { enum RecoverError { NoError, InvalidSignature, InvalidSignatureLength, InvalidSignatureS, InvalidSignatureV // Deprecated in v4.8 } function _throwError(RecoverError error) private pure { if (error == RecoverError.NoError) { return; // no error: do nothing } else if (error == RecoverError.InvalidSignature) { revert("ECDSA: invalid signature"); } else if (error == RecoverError.InvalidSignatureLength) { revert("ECDSA: invalid signature length"); } else if (error == RecoverError.InvalidSignatureS) { revert("ECDSA: invalid signature 's' value"); } } /** * @dev Returns the address that signed a hashed message (`hash`) with * `signature` or error string. This address can then be used for verification purposes. * * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures: * this function rejects them by requiring the `s` value to be in the lower * half order, and the `v` value to be either 27 or 28. * * IMPORTANT: `hash` _must_ be the result of a hash operation for the * verification to be secure: it is possible to craft signatures that * recover to arbitrary addresses for non-hashed data. A safe way to ensure * this is by receiving a hash of the original message (which may otherwise * be too long), and then calling {toEthSignedMessageHash} on it. * * Documentation for signature generation: * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js] * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers] * * _Available since v4.3._ */ function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) { if (signature.length == 65) { bytes32 r; bytes32 s; uint8 v; // ecrecover takes the signature parameters, and the only way to get them // currently is to use assembly. /// @solidity memory-safe-assembly assembly { r := mload(add(signature, 0x20)) s := mload(add(signature, 0x40)) v := byte(0, mload(add(signature, 0x60))) } return tryRecover(hash, v, r, s); } else { return (address(0), RecoverError.InvalidSignatureLength); } } /** * @dev Returns the address that signed a hashed message (`hash`) with * `signature`. This address can then be used for verification purposes. * * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures: * this function rejects them by requiring the `s` value to be in the lower * half order, and the `v` value to be either 27 or 28. * * IMPORTANT: `hash` _must_ be the result of a hash operation for the * verification to be secure: it is possible to craft signatures that * recover to arbitrary addresses for non-hashed data. A safe way to ensure * this is by receiving a hash of the original message (which may otherwise * be too long), and then calling {toEthSignedMessageHash} on it. */ function recover(bytes32 hash, bytes memory signature) internal pure returns (address) { (address recovered, RecoverError error) = tryRecover(hash, signature); _throwError(error); return recovered; } /** * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately. * * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures] * * _Available since v4.3._ */ function tryRecover( bytes32 hash, bytes32 r, bytes32 vs ) internal pure returns (address, RecoverError) { bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); uint8 v = uint8((uint256(vs) >> 255) + 27); return tryRecover(hash, v, r, s); } /** * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately. * * _Available since v4.2._ */ function recover( bytes32 hash, bytes32 r, bytes32 vs ) internal pure returns (address) { (address recovered, RecoverError error) = tryRecover(hash, r, vs); _throwError(error); return recovered; } /** * @dev Overload of {ECDSA-tryRecover} that receives the `v`, * `r` and `s` signature fields separately. * * _Available since v4.3._ */ function tryRecover( bytes32 hash, uint8 v, bytes32 r, bytes32 s ) internal pure returns (address, RecoverError) { // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most // signatures from current libraries generate a unique signature with an s-value in the lower half order. // // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept // these malleable signatures as well. if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) { return (address(0), RecoverError.InvalidSignatureS); } // If the signature is valid (and not malleable), return the signer address address signer = ecrecover(hash, v, r, s); if (signer == address(0)) { return (address(0), RecoverError.InvalidSignature); } return (signer, RecoverError.NoError); } /** * @dev Overload of {ECDSA-recover} that receives the `v`, * `r` and `s` signature fields separately. */ function recover( bytes32 hash, uint8 v, bytes32 r, bytes32 s ) internal pure returns (address) { (address recovered, RecoverError error) = tryRecover(hash, v, r, s); _throwError(error); return recovered; } /** * @dev Returns an Ethereum Signed Message, created from a `hash`. This * produces hash corresponding to the one signed with the * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] * JSON-RPC method as part of EIP-191. * * See {recover}. */ function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) { // 32 is the length in bytes of hash, // enforced by the type signature above return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash)); } /** * @dev Returns an Ethereum Signed Message, created from `s`. This * produces hash corresponding to the one signed with the * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] * JSON-RPC method as part of EIP-191. * * See {recover}. */ function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) { return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s)); } /** * @dev Returns an Ethereum Signed Typed Data, created from a * `domainSeparator` and a `structHash`. This produces hash corresponding * to the one signed with the * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`] * JSON-RPC method as part of EIP-712. * * See {recover}. */ function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) { return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash)); } } // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol) /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor() { _transferOwnership(_msgSender()); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { require(owner() == _msgSender(), "Ownable: caller is not the owner"); } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions anymore. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby removing any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } } contract Passphrase is ERC1155Supply, Ownable { using ECDSA for bytes32; /*////////////////////////////////////////////////////////////// STATE VARIABLES //////////////////////////////////////////////////////////////*/ struct Game { address gameCreator; // Creator of the game. bool creatorEarningsCollected; // Whether creator earnings have been claimed. bool treasuryEarningsCollected; // Whether treasury earnings have been claimed. uint64 gameStartTime; // Start time of the game. uint56 maxPlayers; // Maximum number of players that can participate in the game. uint128 gamePrice; // Price to buy a game. uint256 totalRewardsClaimed; // Keeps track of the accumulated rewards claimed for the game. } /// @notice Address linked to the private key utilized for signing the message. address public signer; /// @notice This tracks the overall count of games that have been created up to this point. uint256 public totalGamesCreated; // @notice Percentage of the total game price that the game creator (game creation fee) and the contract owner (treasury fee) are entitled to take. uint256 public constant CREATOR_AND_TREASURY_FEE = 1000; //10% // @notice Maximum percentage of the reward that a player can claim in the game. uint256 public constant MAX_PLAYER_REWARD_PCT = 8000; //80% /// @notice Utilized to calculate fees and is measured in basis points. uint256 public constant PERCENTAGE_CALCULATION = 10000; // 100% /// @notice Stores the number of days that must elapse after the game starts before an admin can claim unclaimed rewards for the game. uint256 public constant GRACE_PERIOD = 90 days; /// @notice Stores the maximum number of players that can participate in a game. uint256 public constant MAX_PLAYERS = 1000; /// @notice Tracks message hashes that have been used, to prevent message replay. mapping(bytes32 => bool) public messageHashUsed; /// @notice Tracks the eligibility of an address to create a game. mapping(address => bool) public isWhitelisted; /// @notice Tracks all the game's details associated with its ID. mapping(uint256 => Game) public gameDetails; /*////////////////////////////////////////////////////////////// EVENTS //////////////////////////////////////////////////////////////*/ event GameCreated( address indexed gameCreator, uint256 gameId, uint256 indexed totalPlayers, uint256 indexed gamePrice ); event GameBought( address indexed player, uint256 indexed gameId, uint256 totalGamesCreatedSoFar ); event RewardsClaimed( address indexed player, uint256 indexed gameId, uint256 indexed rank, uint256 rewardAmount ); event SignerChanged(address oldSigner, address newSigner); event GameCreationAccessSet(address indexed authorized, bool access); event CreatorEarningsWithdrawn(uint256 gameId); event TreasuryEarningsWithdrawn(address indexed recipient, uint256 gameId); event UnclaimedRewardsWithdrawn( uint256 gameId, address indexed recipient, uint256 indexed unclaimedRewards, uint256 indexed creatorEarnings ); event URIChanged(string newURI); /*////////////////////////////////////////////////////////////// ERRORS //////////////////////////////////////////////////////////////*/ error AlreadyOwnOne(); error AlreadyWithdrawn(); error AlreadyUsedMessageHash(); error CantBeTransferred(); error CantClaimBeforeGracePeriod(); error DoesnotOwnThisGame(); error ExceedsMaxPlayersCap(); error GameDoesnotExists(); error GameNotStartedYet(); error GameNotFullySoldOut(); error NotGameCreator(); error NotWhitelisted(); error RewardAmountTooHigh(); error RewardAlreadyDistributed(); error SignerCantBuyGame(); error SlotsFull(); error TransferFailed(); error WrongEthSent(); error WrongSigner(); error ZeroAddress(); error ZeroAmount(); /*////////////////////////////////////////////////////////////// MODIFIER //////////////////////////////////////////////////////////////*/ /// @notice Reverts if the caller is not eligible to create a game. modifier onlyWhitelisted() { if (!isWhitelisted[msg.sender]) { revert NotWhitelisted(); } _; } /*////////////////////////////////////////////////////////////// CONSTRUCTOR //////////////////////////////////////////////////////////////*/ /// @notice Sets the signer address. /// @param _uri URI of all tokens. /// @param _signer Address of the signer. constructor(string memory _uri, address _signer) ERC1155(_uri) { if (_signer == address(0)) { revert ZeroAddress(); } signer = _signer; emit SignerChanged(address(0), _signer); } /*////////////////////////////////////////////////////////////// SETTER FUNCTIONS //////////////////////////////////////////////////////////////*/ /// @notice Changes the signer address. Can only be called by the owner of this contract. /// @param _newSigner Address of the new signer. function changeSigner(address _newSigner) external onlyOwner { if (_newSigner == address(0)) { revert ZeroAddress(); } emit SignerChanged(signer, _newSigner); // Overwrites the old signer address signer = _newSigner; } /// @notice Whitelists or dewhitelists an address for creating games. Can only be called by the owner of this contract. /// @param _address Address to give or revoke access of creating games. /// @param _access true to give access, false otherwise. function setGameCreationAccess( address _address, bool _access ) external onlyOwner { if (_address == address(0)) { revert ZeroAddress(); } // Overwrites the access previously granted. isWhitelisted[_address] = _access; emit GameCreationAccessSet(_address, _access); } /*////////////////////////////////////////////////////////////// GAME RELATED LOGIC //////////////////////////////////////////////////////////////*/ /// @notice Creates a new game. Can only be called by whitelisted addresses. /// @param _maxPlayers Maximum slots available/ maximum players that can participate. /// @param _gamePrice Price to buy one slot. function createGame( uint56 _maxPlayers, uint128 _gamePrice ) external onlyWhitelisted { // Revert if either max players/ participants or game price is zero. if (_maxPlayers == 0 || _gamePrice == 0) { revert ZeroAmount(); } if (_maxPlayers > MAX_PLAYERS) { revert ExceedsMaxPlayersCap(); } // Increment total games created counter. /// @dev Game id of the first game would be 1. uint256 _gameId = ++totalGamesCreated; // Creating a new game/ setting game details. Game storage _game = gameDetails[_gameId]; _game.gameCreator = msg.sender; _game.maxPlayers = _maxPlayers; _game.gamePrice = _gamePrice; emit GameCreated(msg.sender, _gameId, _maxPlayers, _gamePrice); } /// @notice Purchase a game or reserve a slot for a game. /// @param _gameId ID of the game for which to reserve a slot. function buyGame(uint256 _gameId) external payable { // Revert if signer address is trying to buy a game. if (msg.sender == signer) { revert SignerCantBuyGame(); } // Reading or writing directly from the storage is more gas-efficient than loading it into memory first. Game storage game = gameDetails[_gameId]; // Revert if a game is not created with the provided gameId. if (game.gameCreator == address(0)) { revert GameDoesnotExists(); } // Revert if all the slots of the game are full. if (game.gameStartTime != 0) { revert SlotsFull(); } // Token cannot be transferred or burnt so the check is sufficient. if (balanceOf(msg.sender, _gameId) != 0) { revert AlreadyOwnOne(); } // Revert if eth received is more or less than game price. if (msg.value != game.gamePrice) { revert WrongEthSent(); } // Commence the game 24 hours after all slots are full. if (totalSupply(_gameId) + 1 == game.maxPlayers) { game.gameStartTime = uint64(block.timestamp) + 24 hours; } // Only mint one copy of an ERC-1155 token to the caller /// @dev Token ID would be equal to game ID. _mint(msg.sender, _gameId, 1, ""); // The last logged parameter represents the total slots filled. emit GameBought(msg.sender, _gameId, totalSupply(_gameId)); } /// @notice Redeem the game's prize. /// @param _gameId ID of the game for which to claim a reward. /// @param _rank Attained rank within the game. /// @param _rewardAmount The prize earned from the game. /// @param _signature Signed message by the admin. function claimReward( uint256 _gameId, uint256 _rank, uint256 _rewardAmount, bytes calldata _signature ) external { // Reading or writing directly from the storage is more gas-efficient than loading it into memory first. Game storage _game = gameDetails[_gameId]; // Revert if game id is invalid. if (_game.gameCreator == address(0)) { revert GameDoesnotExists(); } // Revert if caller does not own the Token required to play the game. if (balanceOf(msg.sender, _gameId) == 0) { revert DoesnotOwnThisGame(); } // Revert if all slots are not filled or if the game start time has not passed. if (_game.gameStartTime == 0 || block.timestamp < _game.gameStartTime) { revert GameNotStartedYet(); } // Maximum amount of rewards that can be claimed for the game. (i.e. 80% of the total game price pool) uint256 _totalClaimableRewards = ((_game.gamePrice * _game.maxPlayers) * MAX_PLAYER_REWARD_PCT) / PERCENTAGE_CALCULATION; // Revert incase if the reward amount is more than 80% of the total game price pool. if (_rewardAmount > _totalClaimableRewards) revert RewardAmountTooHigh(); // Revert if all rewards allocated for the game have been claimed. if (_totalClaimableRewards == _game.totalRewardsClaimed) { revert RewardAlreadyDistributed(); } // Generating hash of the message. bytes32 messageHash = keccak256( abi.encodePacked( msg.sender, _gameId, _rank, _rewardAmount, block.chainid, address(this) ) ); // Revert if the generated message hash has been used already. if (messageHashUsed[messageHash]) { revert AlreadyUsedMessageHash(); } // Signing message hash. bytes32 signedMessageHash = messageHash.toEthSignedMessageHash(); // Recover address used to sign the message. address recoveredAddress = signedMessageHash.recover(_signature); // Revert if the message was signed with an address other than the signer address. if (recoveredAddress != signer) { revert WrongSigner(); } messageHashUsed[messageHash] = true; _game.totalRewardsClaimed += _rewardAmount; // Transfer reward to the player (bool success, ) = msg.sender.call{value: _rewardAmount}(""); if (!success) { revert TransferFailed(); } emit RewardsClaimed(msg.sender, _gameId, _rank, _rewardAmount); } /*////////////////////////////////////////////////////////////// WITHDRAW FEES LOGIC //////////////////////////////////////////////////////////////*/ /// @notice Withdraw game creation earnings. Can only be called by the creator of the game. /// @param _gameId ID of the game for which to withdraw game creation earning. function withdrawCreatorEarning(uint256 _gameId) external { // Reading or writing directly from the storage is more gas-efficient than loading it into memory first. Game storage _game = gameDetails[_gameId]; // Revert if game id is invalid or if caller is not the creator of the game. if (msg.sender != _game.gameCreator) { revert NotGameCreator(); } // Revert if game creator is trying to withdraw creator earnings before all the slots are filled. if (_game.gameStartTime == 0) { revert GameNotFullySoldOut(); } // Revert if creator earnings have already been collected by the game creator. if (_game.creatorEarningsCollected) { revert AlreadyWithdrawn(); } _game.creatorEarningsCollected = true; // Using msg.sender instead of gameCreator to save same gas. // Transferring 10% of the total game price pool to the creator of the game. (bool success, ) = msg.sender.call{ value: ((_game.gamePrice * _game.maxPlayers) * CREATOR_AND_TREASURY_FEE) / PERCENTAGE_CALCULATION }(""); if (!success) { revert TransferFailed(); } emit CreatorEarningsWithdrawn(_gameId); } /// @notice Withdraw game treasury earnings. Can only be called by the owner of this contract. /// @param _recipient Address of the recipient of the game treasury earnings. /// @param _gameId ID of the game for which to withdraw game treasury earning. function withdrawTreasuryEarning( address _recipient, uint256 _gameId ) external onlyOwner { if (_recipient == address(0)) { revert ZeroAddress(); } // Reading or writing directly from the storage is more gas-efficient than loading it into memory first. Game storage _game = gameDetails[_gameId]; // Revert if game id is invalid. if (_game.gameCreator == address(0)) { revert GameDoesnotExists(); } // Revert if owner is trying to withdraw treasury earnings before all the slots are filled. if (_game.gameStartTime == 0) { revert GameNotFullySoldOut(); } // Revert if treasury earnings have already been collected by the owner. if (_game.treasuryEarningsCollected) { revert AlreadyWithdrawn(); } _game.treasuryEarningsCollected = true; // Transferring 10% of the total game price pool to the recipient. (bool success, ) = _recipient.call{ value: ((_game.gamePrice * _game.maxPlayers) * CREATOR_AND_TREASURY_FEE) / PERCENTAGE_CALCULATION }(""); if (!success) { revert TransferFailed(); } emit TreasuryEarningsWithdrawn(_recipient, _gameId); } /// @notice Claim unclaimed rewards & creator earnings for a game if 90 days have passed since the game start time. Can only be called by the owner of this contract. /// @param _recipient The address of the recipient who will receive the unclaimed rewards & creator earnings. /// @param _gameId The ID of the game for which unclaimed rewards are being claimed. function withdrawUnclaimedRewards( address _recipient, uint256 _gameId ) external onlyOwner { if (_recipient == address(0)) { revert ZeroAddress(); } // Reading or writing directly from the storage is more gas-efficient than loading it into memory first. Game storage _game = gameDetails[_gameId]; // Revert if game id is invalid. if (_game.gameCreator == address(0)) { revert GameDoesnotExists(); } // Revert if the owner tries to claim unclaimed rewards before all the slots are filled. if (_game.gameStartTime == 0) { revert GameNotFullySoldOut(); } // Reverts if the owner tries to withdraw unclaimed rewards before the grace period of 90 days since the game start time has passed. if (_game.gameStartTime + GRACE_PERIOD > block.timestamp) { revert CantClaimBeforeGracePeriod(); } // Maximum amount of rewards that can be claimed for the game. (i.e. 80% of the total game price pool) uint256 _totalClaimableRewards = ((_game.gamePrice * _game.maxPlayers) * MAX_PLAYER_REWARD_PCT) / PERCENTAGE_CALCULATION; uint256 _gameCreatorEarnings; // If the creator's earnings have not been collected by the game creator. if (!_game.creatorEarningsCollected) { // 10% of the total game price pool (allocated for game creator). _gameCreatorEarnings = ((_game.gamePrice * _game.maxPlayers) * CREATOR_AND_TREASURY_FEE) / PERCENTAGE_CALCULATION; _game.creatorEarningsCollected = true; } uint256 _unclaimedGameRewards = _totalClaimableRewards - _game.totalRewardsClaimed; // Revert if all rewards of the game and creator earnings have been collected. if (_unclaimedGameRewards == 0 && _gameCreatorEarnings == 0) { revert RewardAlreadyDistributed(); } // Only accumulate rewards if there are any unclaimed rewards. if (_unclaimedGameRewards != 0) { _game.totalRewardsClaimed += _unclaimedGameRewards; } // Transfer unclaimed rewards and creator earnings of the game to the recipient. (bool success, ) = _recipient.call{ value: _unclaimedGameRewards + _gameCreatorEarnings }(""); if (!success) { revert TransferFailed(); } emit UnclaimedRewardsWithdrawn( _gameId, _recipient, _unclaimedGameRewards, _gameCreatorEarnings ); } /*////////////////////////////////////////////////////////////// ERC1155 FUNCTIONS //////////////////////////////////////////////////////////////*/ /// @notice Sets a new URI for all token types. Can only be called by the owner of this contract. /// @param _newuri URL of the new URI. function setURI(string calldata _newuri) external onlyOwner { // Overwrites old uri. _setURI(_newuri); emit URIChanged(_newuri); } function setApprovalForAll(address, bool) public virtual override { revert CantBeTransferred(); } function safeTransferFrom( address, address, uint256, uint256, bytes memory ) public virtual override { revert CantBeTransferred(); } function safeBatchTransferFrom( address, address, uint256[] memory, uint256[] memory, bytes memory ) public virtual override { revert CantBeTransferred(); } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"string","name":"_uri","type":"string"},{"internalType":"address","name":"_signer","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AlreadyOwnOne","type":"error"},{"inputs":[],"name":"AlreadyUsedMessageHash","type":"error"},{"inputs":[],"name":"AlreadyWithdrawn","type":"error"},{"inputs":[],"name":"CantBeTransferred","type":"error"},{"inputs":[],"name":"CantClaimBeforeGracePeriod","type":"error"},{"inputs":[],"name":"DoesnotOwnThisGame","type":"error"},{"inputs":[],"name":"ExceedsMaxPlayersCap","type":"error"},{"inputs":[],"name":"GameDoesnotExists","type":"error"},{"inputs":[],"name":"GameNotFullySoldOut","type":"error"},{"inputs":[],"name":"GameNotStartedYet","type":"error"},{"inputs":[],"name":"NotGameCreator","type":"error"},{"inputs":[],"name":"NotWhitelisted","type":"error"},{"inputs":[],"name":"RewardAlreadyDistributed","type":"error"},{"inputs":[],"name":"RewardAmountTooHigh","type":"error"},{"inputs":[],"name":"SignerCantBuyGame","type":"error"},{"inputs":[],"name":"SlotsFull","type":"error"},{"inputs":[],"name":"TransferFailed","type":"error"},{"inputs":[],"name":"WrongEthSent","type":"error"},{"inputs":[],"name":"WrongSigner","type":"error"},{"inputs":[],"name":"ZeroAddress","type":"error"},{"inputs":[],"name":"ZeroAmount","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"gameId","type":"uint256"}],"name":"CreatorEarningsWithdrawn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"player","type":"address"},{"indexed":true,"internalType":"uint256","name":"gameId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"totalGamesCreatedSoFar","type":"uint256"}],"name":"GameBought","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"gameCreator","type":"address"},{"indexed":false,"internalType":"uint256","name":"gameId","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"totalPlayers","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"gamePrice","type":"uint256"}],"name":"GameCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"authorized","type":"address"},{"indexed":false,"internalType":"bool","name":"access","type":"bool"}],"name":"GameCreationAccessSet","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":"player","type":"address"},{"indexed":true,"internalType":"uint256","name":"gameId","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"rank","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"rewardAmount","type":"uint256"}],"name":"RewardsClaimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"oldSigner","type":"address"},{"indexed":false,"internalType":"address","name":"newSigner","type":"address"}],"name":"SignerChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"indexed":false,"internalType":"uint256[]","name":"values","type":"uint256[]"}],"name":"TransferBatch","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"TransferSingle","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"gameId","type":"uint256"}],"name":"TreasuryEarningsWithdrawn","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"value","type":"string"},{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"}],"name":"URI","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"newURI","type":"string"}],"name":"URIChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"gameId","type":"uint256"},{"indexed":true,"internalType":"address","name":"recipient","type":"address"},{"indexed":true,"internalType":"uint256","name":"unclaimedRewards","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"creatorEarnings","type":"uint256"}],"name":"UnclaimedRewardsWithdrawn","type":"event"},{"inputs":[],"name":"CREATOR_AND_TREASURY_FEE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"GRACE_PERIOD","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_PLAYERS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_PLAYER_REWARD_PCT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PERCENTAGE_CALCULATION","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"accounts","type":"address[]"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"}],"name":"balanceOfBatch","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_gameId","type":"uint256"}],"name":"buyGame","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"_newSigner","type":"address"}],"name":"changeSigner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_gameId","type":"uint256"},{"internalType":"uint256","name":"_rank","type":"uint256"},{"internalType":"uint256","name":"_rewardAmount","type":"uint256"},{"internalType":"bytes","name":"_signature","type":"bytes"}],"name":"claimReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint56","name":"_maxPlayers","type":"uint56"},{"internalType":"uint128","name":"_gamePrice","type":"uint128"}],"name":"createGame","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"exists","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"gameDetails","outputs":[{"internalType":"address","name":"gameCreator","type":"address"},{"internalType":"bool","name":"creatorEarningsCollected","type":"bool"},{"internalType":"bool","name":"treasuryEarningsCollected","type":"bool"},{"internalType":"uint64","name":"gameStartTime","type":"uint64"},{"internalType":"uint56","name":"maxPlayers","type":"uint56"},{"internalType":"uint128","name":"gamePrice","type":"uint128"},{"internalType":"uint256","name":"totalRewardsClaimed","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isWhitelisted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"messageHashUsed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"safeBatchTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"bool","name":"","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"},{"internalType":"bool","name":"_access","type":"bool"}],"name":"setGameCreationAccess","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newuri","type":"string"}],"name":"setURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"signer","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalGamesCreated","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_gameId","type":"uint256"}],"name":"withdrawCreatorEarning","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_recipient","type":"address"},{"internalType":"uint256","name":"_gameId","type":"uint256"}],"name":"withdrawTreasuryEarning","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_recipient","type":"address"},{"internalType":"uint256","name":"_gameId","type":"uint256"}],"name":"withdrawUnclaimedRewards","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)
00000000000000000000000000000000000000000000000000000000000000400000000000000000000000001ef5e3c23bb482b3f34e137c88e59d20083be836000000000000000000000000000000000000000000000000000000000000002f68747470733a2f2f7777772e706173737068726173652e6c6976652f6e6674732f506c6179506173734f472e6769660000000000000000000000000000000000
-----Decoded View---------------
Arg [0] : _uri (string): https://www.passphrase.live/nfts/PlayPassOG.gif
Arg [1] : _signer (address): 0x1ef5E3c23bB482B3f34e137c88E59D20083Be836
-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000040
Arg [1] : 0000000000000000000000001ef5e3c23bb482b3f34e137c88e59d20083be836
Arg [2] : 000000000000000000000000000000000000000000000000000000000000002f
Arg [3] : 68747470733a2f2f7777772e706173737068726173652e6c6976652f6e667473
Arg [4] : 2f506c6179506173734f472e6769660000000000000000000000000000000000
Deployed Bytecode Sourcemap
64998:20149:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21249:230;;;;;;;;;;-1:-1:-1;21249:230:0;;;;;:::i;:::-;;:::i;:::-;;;597:25:1;;;585:2;570:18;21249:230:0;;;;;;;;20272:310;;;;;;;;;;-1:-1:-1;20272:310:0;;;;;:::i;:::-;;:::i;:::-;;;1184:14:1;;1177:22;1159:41;;1147:2;1132:18;20272:310:0;1019:187:1;84428:164:0;;;;;;;;;;-1:-1:-1;84428:164:0;;;;;:::i;:::-;;:::i;:::-;;20993:105;;;;;;;;;;-1:-1:-1;20993:105:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;71957:854::-;;;;;;;;;;-1:-1:-1;71957:854:0;;;;;:::i;:::-;;:::i;71182:358::-;;;;;;;;;;-1:-1:-1;71182:358:0;;;;;:::i;:::-;;:::i;65916:21::-;;;;;;;;;;-1:-1:-1;65916:21:0;;;;-1:-1:-1;;;;;65916:21:0;;;;;;-1:-1:-1;;;;;3818:32:1;;;3800:51;;3788:2;3773:18;65916:21:0;3654:203:1;66237:55:0;;;;;;;;;;;;66288:4;66237:55;;84924:220;;;;;;;;;;-1:-1:-1;84924:220:0;;;;;:::i;:::-;;:::i;67155:45::-;;;;;;;;;;-1:-1:-1;67155:45:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;66537:54;;;;;;;;;;;;66586:5;66537:54;;21645:524;;;;;;;;;;-1:-1:-1;21645:524:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;37521:122::-;;;;;;;;;;-1:-1:-1;37521:122:0;;;;;:::i;:::-;37578:4;37399:16;;;:12;:16;;;;;;-1:-1:-1;;;37521:122:0;74789:2829;;;;;;;;;;-1:-1:-1;74789:2829:0;;;;;:::i;:::-;;:::i;66393:52::-;;;;;;;;;;;;66441:4;66393:52;;67280:43;;;;;;;;;;-1:-1:-1;67280:43:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;67280:43:0;;;-1:-1:-1;;;67280:43:0;;;;;;;-1:-1:-1;;;67280:43:0;;;;;;-1:-1:-1;;;67280:43:0;;;-1:-1:-1;;;;;67280:43:0;;;;;;-1:-1:-1;;;67280:43:0;;;-1:-1:-1;;;;;67280:43:0;;;;;;;;-1:-1:-1;;;;;9651:32:1;;;9633:51;;9727:14;;9720:22;9715:2;9700:18;;9693:50;9786:14;;9779:22;9759:18;;;9752:50;;;;-1:-1:-1;;;;;9838:31:1;;;9833:2;9818:18;;9811:59;9919:16;9907:29;9901:3;9886:19;;9879:58;-1:-1:-1;;;;;9974:47:1;;;9671:3;9953:19;;9946:76;10053:3;10038:19;;10031:35;9620:3;9605:19;67280:43:0;9334:738:1;64179:103:0;;;;;;;;;;;;;:::i;77996:1333::-;;;;;;;;;;-1:-1:-1;77996:1333:0;;;;;:::i;:::-;;:::i;63531:87::-;;;;;;;;;;-1:-1:-1;63604:6:0;;-1:-1:-1;;;;;63604:6:0;63531:87;;66043:32;;;;;;;;;;;;;;;;84600:111;;;;;;;;;;-1:-1:-1;84600:111:0;;;;;:::i;70625:285::-;;;;;;;;;;-1:-1:-1;70625:285:0;;;;;:::i;:::-;;:::i;81348:2738::-;;;;;;;;;;-1:-1:-1;81348:2738:0;;;;;:::i;:::-;;:::i;67027:47::-;;;;;;;;;;-1:-1:-1;67027:47:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;37310:113;;;;;;;;;;-1:-1:-1;37310:113:0;;;;;:::i;:::-;37372:7;37399:16;;;:12;:16;;;;;;;37310:113;79604:1360;;;;;;;;;;-1:-1:-1;79604:1360:0;;;;;:::i;:::-;;:::i;66748:46::-;;;;;;;;;;;;66787:7;66748:46;;22469:168;;;;;;;;;;-1:-1:-1;22469:168:0;;;;;:::i;:::-;-1:-1:-1;;;;;22592:27:0;;;22568:4;22592:27;;;:18;:27;;;;;;;;:37;;;;;;;;;;;;;;;22469:168;84719:197;;;;;;;;;;-1:-1:-1;84719:197:0;;;;;:::i;64437:201::-;;;;;;;;;;-1:-1:-1;64437:201:0;;;;;:::i;:::-;;:::i;72950:1550::-;;;;;;:::i;:::-;;:::i;21249:230::-;21335:7;-1:-1:-1;;;;;21363:21:0;;21355:76;;;;-1:-1:-1;;;21355:76:0;;11340:2:1;21355:76:0;;;11322:21:1;11379:2;11359:18;;;11352:30;11418:34;11398:18;;;11391:62;-1:-1:-1;;;11469:18:1;;;11462:40;11519:19;;21355:76:0;;;;;;;;;-1:-1:-1;21449:9:0;:13;;;;;;;;;;;-1:-1:-1;;;;;21449:22:0;;;;;;;;;;21249:230;;;;;:::o;20272:310::-;20374:4;-1:-1:-1;;;;;;20411:41:0;;-1:-1:-1;;;20411:41:0;;:110;;-1:-1:-1;;;;;;;20469:52:0;;-1:-1:-1;;;20469:52:0;20411:110;:163;;;-1:-1:-1;;;;;;;;;;19305:40:0;;;20538:36;19196:157;84428:164;63417:13;:11;:13::i;:::-;84531:16:::1;84539:7;;84531:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;84531:7:0::1;::::0;-1:-1:-1;;;84531:16:0:i:1;:::-;84565:19;84576:7;;84565:19;;;;;;;:::i;:::-;;;;;;;;84428:164:::0;;:::o;20993:105::-;21053:13;21086:4;21079:11;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20993:105;;;:::o;71957:854::-;69643:10;69629:25;;;;:13;:25;;;;;;;;69624:82;;69678:16;;-1:-1:-1;;;69678:16:0;;;;;;;;;;;69624:82;72160:16:::1;::::0;::::1;::::0;;:35:::1;;-1:-1:-1::0;;;;;;72180:15:0;::::1;::::0;72160:35:::1;72156:87;;;72219:12;;-1:-1:-1::0;;;72219:12:0::1;;;;;;;;;;;72156:87;66927:4;72259:11;:25;;;72255:87;;;72308:22;;-1:-1:-1::0;;;72308:22:0::1;;;;;;;;;;;72255:87;72461:15;72481:17;;72479:19;;;;;:::i;:::-;::::0;;;;-1:-1:-1;72566:18:0::1;72587:20:::0;;;:11:::1;:20;::::0;;;;;;72618:30;;-1:-1:-1;;;;;;72618:30:0::1;72638:10;72618:30:::0;;::::1;::::0;;;72659:16;::::1;:30:::0;;-1:-1:-1;;;;;72700:28:0;::::1;-1:-1:-1::0;;;72700:28:0;::::1;-1:-1:-1::0;;;;;;72700:28:0;;;72659:30:::1;::::0;::::1;72700:28:::0;;;;;;::::1;::::0;;;72746:57;;72479:19;;-1:-1:-1;72587:20:0;;72700:28;;72659:30;72746:57:::1;::::0;::::1;::::0;72479:19;597:25:1;;585:2;570:18;;451:177;72746:57:0::1;;;;;;;;72067:744;;71957:854:::0;;:::o;71182:358::-;63417:13;:11;:13::i;:::-;-1:-1:-1;;;;;71304:22:0;::::1;71300:75;;71350:13;;-1:-1:-1::0;;;71350:13:0::1;;;;;;;;;;;71300:75;-1:-1:-1::0;;;;;71441:23:0;::::1;;::::0;;;:13:::1;:23;::::0;;;;;;;;:33;;-1:-1:-1;;71441:33:0::1;::::0;::::1;;::::0;;::::1;::::0;;;71492:40;;1159:41:1;;;71492:40:0::1;::::0;1132:18:1;71492:40:0::1;;;;;;;71182:358:::0;;:::o;84924:220::-;85117:19;;-1:-1:-1;;;85117:19:0;;;;;;;;;;;21645:524;21801:16;21862:3;:10;21843:8;:15;:29;21835:83;;;;-1:-1:-1;;;21835:83:0;;12803:2:1;21835:83:0;;;12785:21:1;12842:2;12822:18;;;12815:30;12881:34;12861:18;;;12854:62;-1:-1:-1;;;12932:18:1;;;12925:39;12981:19;;21835:83:0;12601:405:1;21835:83:0;21931:30;21978:8;:15;-1:-1:-1;;;;;21964:30:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;21964:30:0;;21931:63;;22012:9;22007:122;22031:8;:15;22027:1;:19;22007:122;;;22087:30;22097:8;22106:1;22097:11;;;;;;;;:::i;:::-;;;;;;;22110:3;22114:1;22110:6;;;;;;;;:::i;:::-;;;;;;;22087:9;:30::i;:::-;22068:13;22082:1;22068:16;;;;;;;;:::i;:::-;;;;;;;;;;:49;22048:3;;;:::i;:::-;;;22007:122;;;-1:-1:-1;22148:13:0;21645:524;-1:-1:-1;;;21645:524:0:o;74789:2829::-;75069:18;75090:20;;;:11;:20;;;;;75169:17;;-1:-1:-1;;;;;75169:17:0;75165:90;;75224:19;;-1:-1:-1;;;75224:19:0;;;;;;;;;;;75165:90;75350:30;75360:10;75372:7;75350:9;:30::i;:::-;75384:1;75350:35;75346:95;;75409:20;;-1:-1:-1;;;75409:20:0;;;;;;;;;;;75346:95;75546:19;;-1:-1:-1;;;75546:19:0;;-1:-1:-1;;;;;75546:19:0;:24;;:65;;-1:-1:-1;75592:19:0;;-1:-1:-1;;;75592:19:0;;-1:-1:-1;;;;;75592:19:0;75574:15;:37;75546:65;75542:124;;;75635:19;;-1:-1:-1;;;75635:19:0;;;;;;;;;;;75542:124;75843:16;;;;75790:30;;66586:5;;66441:4;;75825:34;;75843:16;;;;-1:-1:-1;;;75825:15:0;;-1:-1:-1;;;;;75825:15:0;:34;:::i;:::-;-1:-1:-1;;;;;75824:73:0;;;;;:::i;:::-;75823:100;;;;:::i;:::-;75790:133;;76050:22;76034:13;:38;76030:85;;;76094:21;;-1:-1:-1;;;76094:21:0;;;;;;;;;;;76030:85;76234:5;:25;;;76208:22;:51;76204:117;;76283:26;;-1:-1:-1;;;76283:26:0;;;;;;;;;;;76204:117;76423:206;;-1:-1:-1;;76458:10:0;14156:2:1;14152:15;;;14148:24;;76423:206:0;;;14136:37:1;14189:12;;;14182:28;;;14226:12;;;14219:28;;;14263:12;;;14256:28;;;76569:13:0;14300::1;;;14293:29;76609:4:0;14357:15:1;;14353:24;14338:13;;;14331:47;76377:19:0;;14394:13:1;;76423:206:0;;;-1:-1:-1;;76423:206:0;;;;;;;;;76399:241;;76423:206;76399:241;;;;76729:28;;;;:15;:28;;;;;;76399:241;;-1:-1:-1;76729:28:0;;76725:92;;;76781:24;;-1:-1:-1;;;76781:24:0;;;;;;;;;;;76725:92;76863:25;76891:36;:11;61259:58;;18599:66:1;61259:58:0;;;18587:79:1;18682:12;;;18675:28;;;61126:7:0;;18719:12:1;;61259:58:0;;;;;;;;;;;;61249:69;;;;;;61242:76;;61057:269;;;;76891:36;76863:64;;76994:24;77021:37;77047:10;;77021:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;77021:17:0;;:37;-1:-1:-1;;77021:25:0;:37;-1:-1:-1;77021:37:0:i;:::-;77187:6;;76994:64;;-1:-1:-1;;;;;;77167:26:0;;;77187:6;;77167:26;77163:79;;77217:13;;-1:-1:-1;;;77217:13:0;;;;;;;;;;;77163:79;77254:28;;;;:15;:28;;;;;:35;;-1:-1:-1;;77254:35:0;77285:4;77254:35;;;77302:25;;;:42;;77331:13;;77254:28;77302:42;;77331:13;;77302:42;:::i;:::-;;;;-1:-1:-1;;77418:41:0;;77400:12;;77418:10;;77441:13;;77400:12;77418:41;77400:12;77418:41;77441:13;77418:10;:41;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;77399:60;;;77477:7;77472:64;;77508:16;;-1:-1:-1;;;77508:16:0;;;;;;;;;;;77472:64;77589:5;77580:7;77568:10;-1:-1:-1;;;;;77553:57:0;;77596:13;77553:57;;;;597:25:1;;585:2;570:18;;451:177;77553:57:0;;;;;;;;74944:2674;;;;;;74789:2829;;;;;:::o;64179:103::-;63417:13;:11;:13::i;:::-;64244:30:::1;64271:1;64244:18;:30::i;:::-;64179:103::o:0;77996:1333::-;78179:18;78200:20;;;:11;:20;;;;;78337:17;;-1:-1:-1;;;;;78337:17:0;78323:10;:31;78319:87;;78378:16;;-1:-1:-1;;;78378:16:0;;;;;;;;;;;78319:87;78529:19;;-1:-1:-1;;;78529:19:0;;-1:-1:-1;;;;;78529:19:0;;:24;78525:85;;78577:21;;-1:-1:-1;;;78577:21:0;;;;;;;;;;;78525:85;78714:30;;-1:-1:-1;;;78714:30:0;;;;78710:88;;;78768:18;;-1:-1:-1;;;78768:18:0;;;;;;;;;;;78710:88;78810:37;;-1:-1:-1;;;;78810:37:0;-1:-1:-1;;;78810:37:0;;;78843:4;79092:16;;;78810:30;;79035:10;;66586:5;;66288:4;;79074:34;;79092:16;;;;-1:-1:-1;;;;;;;;79074:15:0;;;;:34;:::i;:::-;-1:-1:-1;;;;;79073:80:0;;;;;:::i;:::-;79072:107;;;;:::i;:::-;79035:159;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;79016:178;;;79212:7;79207:64;;79243:16;;-1:-1:-1;;;79243:16:0;;;;;;;;;;;79207:64;79288:33;;597:25:1;;;79288:33:0;;585:2:1;570:18;79288:33:0;;;;;;;78054:1275;;77996:1333;:::o;70625:285::-;63417:13;:11;:13::i;:::-;-1:-1:-1;;;;;70701:24:0;::::1;70697:77;;70749:13;;-1:-1:-1::0;;;70749:13:0::1;;;;;;;;;;;70697:77;70805:6;::::0;70791:33:::1;::::0;;-1:-1:-1;;;;;70805:6:0;;::::1;14970:34:1::0;;15040:15;;;15035:2;15020:18;;15013:43;70791:33:0::1;::::0;14905:18:1;70791:33:0::1;;;;;;;70883:6;:19:::0;;-1:-1:-1;;;;;;70883:19:0::1;-1:-1:-1::0;;;;;70883:19:0;;;::::1;::::0;;;::::1;::::0;;70625:285::o;81348:2738::-;63417:13;:11;:13::i;:::-;-1:-1:-1;;;;;81478:24:0;::::1;81474:77;;81526:13;;-1:-1:-1::0;;;81526:13:0::1;;;;;;;;;;;81474:77;81677:18;81698:20:::0;;;:11:::1;:20;::::0;;;;81777:17;;-1:-1:-1;;;;;81777:17:0::1;81773:90;;81832:19;;-1:-1:-1::0;;;81832:19:0::1;;;;;;;;;;;81773:90;81977:19:::0;;-1:-1:-1;;;81977:19:0;::::1;-1:-1:-1::0;;;;;81977:19:0::1;;:24:::0;81973:85:::1;;82025:21;;-1:-1:-1::0;;;82025:21:0::1;;;;;;;;;;;81973:85;82216:19:::0;;82253:15:::1;::::0;82216:34:::1;::::0;66787:7:::1;::::0;-1:-1:-1;;;82216:19:0;::::1;-1:-1:-1::0;;;;;82216:19:0::1;:34;:::i;:::-;:52;82212:120;;;82292:28;;-1:-1:-1::0;;;82292:28:0::1;;;;;;;;;;;82212:120;82509:16;::::0;::::1;::::0;82456:30:::1;::::0;66586:5:::1;::::0;66441:4:::1;::::0;82491:34:::1;::::0;82509:16:::1;::::0;::::1;::::0;-1:-1:-1;;;82491:15:0;::::1;-1:-1:-1::0;;;;;82491:15:0::1;:34;:::i;:::-;-1:-1:-1::0;;;;;82490:73:0::1;;;;;:::i;:::-;82489:100;;;;:::i;:::-;82731:30:::0;;82456:133;;-1:-1:-1;82602:28:0::1;::::0;-1:-1:-1;;;82731:30:0;::::1;;;82726:365;;82917:16;::::0;::::1;::::0;66586:5:::1;::::0;66288:4:::1;::::0;82899:34:::1;::::0;82917:16:::1;::::0;::::1;::::0;-1:-1:-1;;;82899:15:0;::::1;-1:-1:-1::0;;;;;82899:15:0::1;:34;:::i;:::-;-1:-1:-1::0;;;;;82898:84:0::1;;;;;:::i;:::-;82897:128;;;;:::i;:::-;83042:37:::0;;-1:-1:-1;;;;83042:37:0::1;-1:-1:-1::0;;;83042:37:0::1;::::0;;82857:168;-1:-1:-1;82726:365:0::1;83103:29;83173:5;:25;;;83135:22;:63;;;;:::i;:::-;83103:95:::0;-1:-1:-1;83303:26:0;;:55;::::1;;;-1:-1:-1::0;83333:25:0;;83303:55:::1;83299:121;;;83382:26;;-1:-1:-1::0;;;83382:26:0::1;;;;;;;;;;;83299:121;83508:26:::0;;83504:109:::1;;83580:21;83551:5;:25;;;:50;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;83504:109:0::1;83716:12;-1:-1:-1::0;;;;;83734:15:0;::::1;83771:44;83795:20:::0;83771:21;:44:::1;:::i;:::-;83734:96;::::0;::::1;::::0;;;;;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;83715:115;;;83848:7;83843:64;;83879:16;;-1:-1:-1::0;;;83879:16:0::1;;;;;;;;;;;83843:64;84047:20;84011:21;83986:10;-1:-1:-1::0;;;;;83924:154:0::1;;83964:7;83924:154;;;;597:25:1::0;;585:2;570:18;;451:177;83924:154:0::1;;;;;;;;81463:2623;;;;;81348:2738:::0;;:::o;79604:1360::-;63417:13;:11;:13::i;:::-;-1:-1:-1;;;;;79733:24:0;::::1;79729:77;;79781:13;;-1:-1:-1::0;;;79781:13:0::1;;;;;;;;;;;79729:77;79932:18;79953:20:::0;;;:11:::1;:20;::::0;;;;80032:17;;-1:-1:-1;;;;;80032:17:0::1;80028:90;;80087:19;;-1:-1:-1::0;;;80087:19:0::1;;;;;;;;;;;80028:90;80235:19:::0;;-1:-1:-1;;;80235:19:0;::::1;-1:-1:-1::0;;;;;80235:19:0::1;;:24:::0;80231:85:::1;;80283:21;;-1:-1:-1::0;;;80283:21:0::1;;;;;;;;;;;80231:85;80414:31:::0;;-1:-1:-1;;;80414:31:0;::::1;;;80410:89;;;80469:18;;-1:-1:-1::0;;;80469:18:0::1;;;;;;;;;;;80410:89;80511:38:::0;;-1:-1:-1;;;;80511:38:0::1;-1:-1:-1::0;;;80511:38:0::1;::::0;;80545:4:::1;80714:16:::0;::::1;::::0;80511:31:::1;::::0;-1:-1:-1;;;;;80657:15:0;::::1;::::0;66586:5:::1;::::0;66288:4:::1;::::0;80696:34:::1;::::0;80714:16:::1;::::0;::::1;::::0;-1:-1:-1;;;;;;;;80696:15:0;;::::1;;:34;:::i;:::-;-1:-1:-1::0;;;;;80695:80:0::1;;;;;:::i;:::-;80694:107;;;;:::i;:::-;80657:159;::::0;::::1;::::0;;;;;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;80638:178;;;80834:7;80829:64;;80865:16;;-1:-1:-1::0;;;80865:16:0::1;;;;;;;;;;;80829:64;80936:10;-1:-1:-1::0;;;;;80910:46:0::1;;80948:7;80910:46;;;;597:25:1::0;;585:2;570:18;;451:177;80910:46:0::1;;;;;;;;79718:1246;;79604:1360:::0;;:::o;64437:201::-;63417:13;:11;:13::i;:::-;-1:-1:-1;;;;;64526:22:0;::::1;64518:73;;;::::0;-1:-1:-1;;;64518:73:0;;15402:2:1;64518:73:0::1;::::0;::::1;15384:21:1::0;15441:2;15421:18;;;15414:30;15480:34;15460:18;;;15453:62;-1:-1:-1;;;15531:18:1;;;15524:36;15577:19;;64518:73:0::1;15200:402:1::0;64518:73:0::1;64602:28;64621:8;64602:18;:28::i;:::-;64437:201:::0;:::o;72950:1550::-;73092:6;;-1:-1:-1;;;;;73092:6:0;73078:10;:20;73074:79;;73122:19;;-1:-1:-1;;;73122:19:0;;;;;;;;;;;73074:79;73279:17;73299:20;;;:11;:20;;;;;73406:16;;-1:-1:-1;;;;;73406:16:0;73402:89;;73460:19;;-1:-1:-1;;;73460:19:0;;;;;;;;;;;73402:89;73565:18;;-1:-1:-1;;;73565:18:0;;-1:-1:-1;;;;;73565:18:0;:23;73561:74;;73612:11;;-1:-1:-1;;;73612:11:0;;;;;;;;;;;73561:74;73728:30;73738:10;73750:7;73728:9;:30::i;:::-;:35;73724:90;;73787:15;;-1:-1:-1;;;73787:15:0;;;;;;;;;;;73724:90;73911:14;;;;-1:-1:-1;;;73911:14:0;;-1:-1:-1;;;;;73911:14:0;73898:9;:27;73894:81;;73949:14;;-1:-1:-1;;;73949:14:0;;;;;;;;;;;73894:81;74084:15;;;;;;74056:20;74068:7;37372;37399:16;;;:12;:16;;;;;;;37310:113;74056:20;:24;;74079:1;74056:24;:::i;:::-;:43;74052:131;;74137:34;74144:15;74163:8;74137:34;:::i;:::-;74116:55;;-1:-1:-1;;;;;74116:55:0;;;;-1:-1:-1;;;74116:55:0;-1:-1:-1;;;;74116:55:0;;;;;;74052:131;74315:33;74321:10;74333:7;74342:1;74315:33;;;;;;;;;;;;:5;:33::i;:::-;74462:7;74450:10;74439:53;74471:20;74462:7;37372;37399:16;;;:12;:16;;;;;;;37310:113;74471:20;74439:53;;597:25:1;;;585:2;570:18;74439:53:0;;;;;;;73001:1499;72950:1550;:::o;63696:132::-;63604:6;;-1:-1:-1;;;;;63604:6:0;18285:10;63760:23;63752:68;;;;-1:-1:-1;;;63752:68:0;;15994:2:1;63752:68:0;;;15976:21:1;;;16013:18;;;16006:30;16072:34;16052:18;;;16045:62;16124:18;;63752:68:0;15792:356:1;27416:88:0;27483:4;:13;27490:6;27483:4;:13;:::i;:::-;;27416:88;:::o;57367:231::-;57445:7;57466:17;57485:18;57507:27;57518:4;57524:9;57507:10;:27::i;:::-;57465:69;;;;57545:18;57557:5;57545:11;:18::i;64798:191::-;64891:6;;;-1:-1:-1;;;;;64908:17:0;;;-1:-1:-1;;;;;;64908:17:0;;;;;;;64941:40;;64891:6;;;64908:17;64891:6;;64941:40;;64872:16;;64941:40;64861:128;64798:191;:::o;27890:729::-;-1:-1:-1;;;;;28043:16:0;;28035:62;;;;-1:-1:-1;;;28035:62:0;;18944:2:1;28035:62:0;;;18926:21:1;18983:2;18963:18;;;18956:30;19022:34;19002:18;;;18995:62;-1:-1:-1;;;19073:18:1;;;19066:31;19114:19;;28035:62:0;18742:397:1;28035:62:0;18285:10;28110:16;28175:21;28193:2;28175:17;:21::i;:::-;28152:44;;28207:24;28234:25;28252:6;28234:17;:25::i;:::-;28207:52;;28272:66;28293:8;28311:1;28315:2;28319:3;28324:7;28333:4;28272:20;:66::i;:::-;28351:9;:13;;;;;;;;;;;-1:-1:-1;;;;;28351:17:0;;;;;;;;;:27;;28372:6;;28351:9;:27;;28372:6;;28351:27;:::i;:::-;;;;-1:-1:-1;;28394:52:0;;;19318:25:1;;;19374:2;19359:18;;19352:34;;;-1:-1:-1;;;;;28394:52:0;;;;28427:1;;28394:52;;;;;;19291:18:1;28394:52:0;;;;;;;28537:74;28568:8;28586:1;28590:2;28594;28598:6;28606:4;28537:30;:74::i;:::-;28024:595;;;27890:729;;;;:::o;55818:747::-;55899:7;55908:12;55937:9;:16;55957:2;55937:22;55933:625;;56281:4;56266:20;;56260:27;56331:4;56316:20;;56310:27;56389:4;56374:20;;56368:27;55976:9;56360:36;56432:25;56443:4;56360:36;56260:27;56310;56432:10;:25::i;:::-;56425:32;;;;;;;;;55933:625;-1:-1:-1;56506:1:0;;-1:-1:-1;56510:35:0;55933:625;55818:747;;;;;:::o;54211:521::-;54289:20;54280:5;:29;;;;;;;;:::i;:::-;;54276:449;;54211:521;:::o;54276:449::-;54387:29;54378:5;:38;;;;;;;;:::i;:::-;;54374:351;;54433:34;;-1:-1:-1;;;54433:34:0;;19731:2:1;54433:34:0;;;19713:21:1;19770:2;19750:18;;;19743:30;19809:26;19789:18;;;19782:54;19853:18;;54433:34:0;19529:348:1;54374:351:0;54498:35;54489:5;:44;;;;;;;;:::i;:::-;;54485:240;;54550:41;;-1:-1:-1;;;54550:41:0;;20084:2:1;54550:41:0;;;20066:21:1;20123:2;20103:18;;;20096:30;20162:33;20142:18;;;20135:61;20213:18;;54550:41:0;19882:355:1;54485:240:0;54622:30;54613:5;:39;;;;;;;;:::i;:::-;;54609:116;;54669:44;;-1:-1:-1;;;54669:44:0;;20444:2:1;54669:44:0;;;20426:21:1;20483:2;20463:18;;;20456:30;20522:34;20502:18;;;20495:62;-1:-1:-1;;;20573:18:1;;;20566:32;20615:19;;54669:44:0;20242:398:1;36569:198:0;36689:16;;;36703:1;36689:16;;;;;;;;;36635;;36664:22;;36689:16;;;;;;;;;;;;-1:-1:-1;36689:16:0;36664:41;;36727:7;36716:5;36722:1;36716:8;;;;;;;;:::i;:::-;;;;;;;;;;:18;36754:5;36569:198;-1:-1:-1;;36569:198:0:o;37718:931::-;-1:-1:-1;;;;;38040:18:0;;38036:160;;38080:9;38075:110;38099:3;:10;38095:1;:14;38075:110;;;38159:7;38167:1;38159:10;;;;;;;;:::i;:::-;;;;;;;38135:12;:20;38148:3;38152:1;38148:6;;;;;;;;:::i;:::-;;;;;;;38135:20;;;;;;;;;;;;:34;;;;;;;:::i;:::-;;;;-1:-1:-1;38111:3:0;;-1:-1:-1;38111:3:0;;:::i;:::-;;;38075:110;;;;38036:160;-1:-1:-1;;;;;38212:16:0;;38208:434;;38250:9;38245:386;38269:3;:10;38265:1;:14;38245:386;;;38305:10;38318:3;38322:1;38318:6;;;;;;;;:::i;:::-;;;;;;;38305:19;;38343:14;38360:7;38368:1;38360:10;;;;;;;;:::i;:::-;;;;;;;38343:27;;38389:14;38406:12;:16;38419:2;38406:16;;;;;;;;;;;;38389:33;;38459:6;38449;:16;;38441:69;;;;-1:-1:-1;;;38441:69:0;;20847:2:1;38441:69:0;;;20829:21:1;20886:2;20866:18;;;20859:30;20925:34;20905:18;;;20898:62;-1:-1:-1;;;20976:18:1;;;20969:38;21024:19;;38441:69:0;20645:404:1;38441:69:0;38562:16;;;;:12;:16;;;;;;38581:15;;38562:34;;38281:3;;;:::i;:::-;;;38245:386;;38208:434;37718:931;;;;;;:::o;34996:744::-;-1:-1:-1;;;;;35211:13:0;;9703:19;:23;35207:526;;35247:72;;-1:-1:-1;;;35247:72:0;;-1:-1:-1;;;;;35247:38:0;;;;;:72;;35286:8;;35296:4;;35302:2;;35306:6;;35314:4;;35247:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;35247:72:0;;;;;;;;-1:-1:-1;;35247:72:0;;;;;;;;;;;;:::i;:::-;;;35243:479;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;35595:6;35588:14;;-1:-1:-1;;;35588:14:0;;;;;;;;:::i;35243:479::-;;;35644:62;;-1:-1:-1;;;35644:62:0;;22936:2:1;35644:62:0;;;22918:21:1;22975:2;22955:18;;;22948:30;23014:34;22994:18;;;22987:62;-1:-1:-1;;;23065:18:1;;;23058:50;23125:19;;35644:62:0;22734:416:1;35243:479:0;-1:-1:-1;;;;;;35369:55:0;;-1:-1:-1;;;35369:55:0;35365:154;;35449:50;;-1:-1:-1;;;35449:50:0;;23357:2:1;35449:50:0;;;23339:21:1;23396:2;23376:18;;;23369:30;23435:34;23415:18;;;23408:62;-1:-1:-1;;;23486:18:1;;;23479:38;23534:19;;35449:50:0;23155:404:1;58819:1520:0;58950:7;;59884:66;59871:79;;59867:163;;;-1:-1:-1;59983:1:0;;-1:-1:-1;59987:30:0;59967:51;;59867:163;60144:24;;;60127:14;60144:24;;;;;;;;;23791:25:1;;;23864:4;23852:17;;23832:18;;;23825:45;;;;23886:18;;;23879:34;;;23929:18;;;23922:34;;;60144:24:0;;23763:19:1;;60144:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;60144:24:0;;-1:-1:-1;;60144:24:0;;;-1:-1:-1;;;;;;;60183:20:0;;60179:103;;60236:1;60240:29;60220:50;;;;;;;60179:103;60302:6;-1:-1:-1;60310:20:0;;-1:-1:-1;58819:1520:0;;;;;;;;:::o;14:173:1:-;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:70;;177:1;174;167:12;111:70;14:173;;;:::o;192:254::-;260:6;268;321:2;309:9;300:7;296:23;292:32;289:52;;;337:1;334;327:12;289:52;360:29;379:9;360:29;:::i;:::-;350:39;436:2;421:18;;;;408:32;;-1:-1:-1;;;192:254:1:o;633:131::-;-1:-1:-1;;;;;;707:32:1;;697:43;;687:71;;754:1;751;744:12;769:245;827:6;880:2;868:9;859:7;855:23;851:32;848:52;;;896:1;893;886:12;848:52;935:9;922:23;954:30;978:5;954:30;:::i;:::-;1003:5;769:245;-1:-1:-1;;;769:245:1:o;1211:348::-;1263:8;1273:6;1327:3;1320:4;1312:6;1308:17;1304:27;1294:55;;1345:1;1342;1335:12;1294:55;-1:-1:-1;1368:20:1;;-1:-1:-1;;;;;1400:30:1;;1397:50;;;1443:1;1440;1433:12;1397:50;1480:4;1472:6;1468:17;1456:29;;1532:3;1525:4;1516:6;1508;1504:19;1500:30;1497:39;1494:59;;;1549:1;1546;1539:12;1564:411;1635:6;1643;1696:2;1684:9;1675:7;1671:23;1667:32;1664:52;;;1712:1;1709;1702:12;1664:52;1752:9;1739:23;-1:-1:-1;;;;;1777:6:1;1774:30;1771:50;;;1817:1;1814;1807:12;1771:50;1856:59;1907:7;1898:6;1887:9;1883:22;1856:59;:::i;:::-;1934:8;;1830:85;;-1:-1:-1;1564:411:1;-1:-1:-1;;;;1564:411:1:o;1980:180::-;2039:6;2092:2;2080:9;2071:7;2067:23;2063:32;2060:52;;;2108:1;2105;2098:12;2060:52;-1:-1:-1;2131:23:1;;1980:180;-1:-1:-1;1980:180:1:o;2165:423::-;2207:3;2245:5;2239:12;2272:6;2267:3;2260:19;2297:1;2307:162;2321:6;2318:1;2315:13;2307:162;;;2383:4;2439:13;;;2435:22;;2429:29;2411:11;;;2407:20;;2400:59;2336:12;2307:162;;;2311:3;2514:1;2507:4;2498:6;2493:3;2489:16;2485:27;2478:38;2577:4;2570:2;2566:7;2561:2;2553:6;2549:15;2545:29;2540:3;2536:39;2532:50;2525:57;;;2165:423;;;;:::o;2593:220::-;2742:2;2731:9;2724:21;2705:4;2762:45;2803:2;2792:9;2788:18;2780:6;2762:45;:::i;2818:479::-;2885:6;2893;2946:2;2934:9;2925:7;2921:23;2917:32;2914:52;;;2962:1;2959;2952:12;2914:52;3001:9;2988:23;3051:16;3044:5;3040:28;3033:5;3030:39;3020:67;;3083:1;3080;3073:12;3020:67;3106:5;-1:-1:-1;3163:2:1;3148:18;;3135:32;-1:-1:-1;;;;;3198:48:1;;3186:61;;3176:89;;3261:1;3258;3251:12;3176:89;3284:7;3274:17;;;2818:479;;;;;:::o;3302:347::-;3367:6;3375;3428:2;3416:9;3407:7;3403:23;3399:32;3396:52;;;3444:1;3441;3434:12;3396:52;3467:29;3486:9;3467:29;:::i;:::-;3457:39;;3546:2;3535:9;3531:18;3518:32;3593:5;3586:13;3579:21;3572:5;3569:32;3559:60;;3615:1;3612;3605:12;3862:127;3923:10;3918:3;3914:20;3911:1;3904:31;3954:4;3951:1;3944:15;3978:4;3975:1;3968:15;3994:249;4104:2;4085:13;;-1:-1:-1;;4081:27:1;4069:40;;-1:-1:-1;;;;;4124:34:1;;4160:22;;;4121:62;4118:88;;;4186:18;;:::i;:::-;4222:2;4215:22;-1:-1:-1;;3994:249:1:o;4248:183::-;4308:4;-1:-1:-1;;;;;4333:6:1;4330:30;4327:56;;;4363:18;;:::i;:::-;-1:-1:-1;4408:1:1;4404:14;4420:4;4400:25;;4248:183::o;4436:724::-;4490:5;4543:3;4536:4;4528:6;4524:17;4520:27;4510:55;;4561:1;4558;4551:12;4510:55;4597:6;4584:20;4623:4;4646:43;4686:2;4646:43;:::i;:::-;4718:2;4712:9;4730:31;4758:2;4750:6;4730:31;:::i;:::-;4796:18;;;4888:1;4884:10;;;;4872:23;;4868:32;;;4830:15;;;;-1:-1:-1;4912:15:1;;;4909:35;;;4940:1;4937;4930:12;4909:35;4976:2;4968:6;4964:15;4988:142;5004:6;4999:3;4996:15;4988:142;;;5070:17;;5058:30;;5108:12;;;;5021;;4988:142;;;-1:-1:-1;5148:6:1;4436:724;-1:-1:-1;;;;;;4436:724:1:o;5165:555::-;5207:5;5260:3;5253:4;5245:6;5241:17;5237:27;5227:55;;5278:1;5275;5268:12;5227:55;5314:6;5301:20;-1:-1:-1;;;;;5336:2:1;5333:26;5330:52;;;5362:18;;:::i;:::-;5411:2;5405:9;5423:67;5478:2;5459:13;;-1:-1:-1;;5455:27:1;5484:4;5451:38;5405:9;5423:67;:::i;:::-;5514:2;5506:6;5499:18;5560:3;5553:4;5548:2;5540:6;5536:15;5532:26;5529:35;5526:55;;;5577:1;5574;5567:12;5526:55;5641:2;5634:4;5626:6;5622:17;5615:4;5607:6;5603:17;5590:54;5688:1;5664:15;;;5681:4;5660:26;5653:37;;;;5668:6;5165:555;-1:-1:-1;;;5165:555:1:o;5725:943::-;5879:6;5887;5895;5903;5911;5964:3;5952:9;5943:7;5939:23;5935:33;5932:53;;;5981:1;5978;5971:12;5932:53;6004:29;6023:9;6004:29;:::i;:::-;5994:39;;6052:38;6086:2;6075:9;6071:18;6052:38;:::i;:::-;6042:48;;6141:2;6130:9;6126:18;6113:32;-1:-1:-1;;;;;6205:2:1;6197:6;6194:14;6191:34;;;6221:1;6218;6211:12;6191:34;6244:61;6297:7;6288:6;6277:9;6273:22;6244:61;:::i;:::-;6234:71;;6358:2;6347:9;6343:18;6330:32;6314:48;;6387:2;6377:8;6374:16;6371:36;;;6403:1;6400;6393:12;6371:36;6426:63;6481:7;6470:8;6459:9;6455:24;6426:63;:::i;:::-;6416:73;;6542:3;6531:9;6527:19;6514:33;6498:49;;6572:2;6562:8;6559:16;6556:36;;;6588:1;6585;6578:12;6556:36;;6611:51;6654:7;6643:8;6632:9;6628:24;6611:51;:::i;:::-;6601:61;;;5725:943;;;;;;;;:::o;6673:186::-;6732:6;6785:2;6773:9;6764:7;6760:23;6756:32;6753:52;;;6801:1;6798;6791:12;6753:52;6824:29;6843:9;6824:29;:::i;6864:1208::-;6982:6;6990;7043:2;7031:9;7022:7;7018:23;7014:32;7011:52;;;7059:1;7056;7049:12;7011:52;7099:9;7086:23;-1:-1:-1;;;;;7169:2:1;7161:6;7158:14;7155:34;;;7185:1;7182;7175:12;7155:34;7223:6;7212:9;7208:22;7198:32;;7268:7;7261:4;7257:2;7253:13;7249:27;7239:55;;7290:1;7287;7280:12;7239:55;7326:2;7313:16;7348:4;7371:43;7411:2;7371:43;:::i;:::-;7443:2;7437:9;7455:31;7483:2;7475:6;7455:31;:::i;:::-;7521:18;;;7609:1;7605:10;;;;7597:19;;7593:28;;;7555:15;;;;-1:-1:-1;7633:19:1;;;7630:39;;;7665:1;7662;7655:12;7630:39;7689:11;;;;7709:148;7725:6;7720:3;7717:15;7709:148;;;7791:23;7810:3;7791:23;:::i;:::-;7779:36;;7742:12;;;;7835;;;;7709:148;;;7876:6;-1:-1:-1;;7920:18:1;;7907:32;;-1:-1:-1;;7951:16:1;;;7948:36;;;7980:1;7977;7970:12;7948:36;;8003:63;8058:7;8047:8;8036:9;8032:24;8003:63;:::i;:::-;7993:73;;;6864:1208;;;;;:::o;8077:632::-;8248:2;8300:21;;;8370:13;;8273:18;;;8392:22;;;8219:4;;8248:2;8471:15;;;;8445:2;8430:18;;;8219:4;8514:169;8528:6;8525:1;8522:13;8514:169;;;8589:13;;8577:26;;8658:15;;;;8623:12;;;;8550:1;8543:9;8514:169;;;-1:-1:-1;8700:3:1;;8077:632;-1:-1:-1;;;;;;8077:632:1:o;8714:615::-;8811:6;8819;8827;8835;8843;8896:3;8884:9;8875:7;8871:23;8867:33;8864:53;;;8913:1;8910;8903:12;8864:53;8949:9;8936:23;8926:33;;9006:2;8995:9;8991:18;8978:32;8968:42;;9057:2;9046:9;9042:18;9029:32;9019:42;;9112:2;9101:9;9097:18;9084:32;-1:-1:-1;;;;;9131:6:1;9128:30;9125:50;;;9171:1;9168;9161:12;9125:50;9210:59;9261:7;9252:6;9241:9;9237:22;9210:59;:::i;:::-;8714:615;;;;-1:-1:-1;8714:615:1;;-1:-1:-1;9288:8:1;;9184:85;8714:615;-1:-1:-1;;;8714:615:1:o;10262:260::-;10330:6;10338;10391:2;10379:9;10370:7;10366:23;10362:32;10359:52;;;10407:1;10404;10397:12;10359:52;10430:29;10449:9;10430:29;:::i;:::-;10420:39;;10478:38;10512:2;10501:9;10497:18;10478:38;:::i;:::-;10468:48;;10262:260;;;;;:::o;10527:606::-;10631:6;10639;10647;10655;10663;10716:3;10704:9;10695:7;10691:23;10687:33;10684:53;;;10733:1;10730;10723:12;10684:53;10756:29;10775:9;10756:29;:::i;:::-;10746:39;;10804:38;10838:2;10827:9;10823:18;10804:38;:::i;:::-;10794:48;;10889:2;10878:9;10874:18;10861:32;10851:42;;10940:2;10929:9;10925:18;10912:32;10902:42;;10995:3;10984:9;10980:19;10967:33;-1:-1:-1;;;;;11015:6:1;11012:30;11009:50;;;11055:1;11052;11045:12;11009:50;11078:49;11119:7;11110:6;11099:9;11095:22;11078:49;:::i;11549:390::-;11708:2;11697:9;11690:21;11747:6;11742:2;11731:9;11727:18;11720:34;11804:6;11796;11791:2;11780:9;11776:18;11763:48;11860:1;11831:22;;;11855:2;11827:31;;;11820:42;;;;11923:2;11902:15;;;-1:-1:-1;;11898:29:1;11883:45;11879:54;;11549:390;-1:-1:-1;11549:390:1:o;11944:380::-;12023:1;12019:12;;;;12066;;;12087:61;;12141:4;12133:6;12129:17;12119:27;;12087:61;12194:2;12186:6;12183:14;12163:18;12160:38;12157:161;;12240:10;12235:3;12231:20;12228:1;12221:31;12275:4;12272:1;12265:15;12303:4;12300:1;12293:15;12157:161;;11944:380;;;:::o;12329:127::-;12390:10;12385:3;12381:20;12378:1;12371:31;12421:4;12418:1;12411:15;12445:4;12442:1;12435:15;12461:135;12500:3;12521:17;;;12518:43;;12541:18;;:::i;:::-;-1:-1:-1;12588:1:1;12577:13;;12461:135::o;13011:127::-;13072:10;13067:3;13063:20;13060:1;13053:31;13103:4;13100:1;13093:15;13127:4;13124:1;13117:15;13143:274;-1:-1:-1;;;;;13281:10:1;;;13293;;;13277:27;13324:20;;;;13215:34;13363:24;;;13353:58;;13391:18;;:::i;:::-;13353:58;;13143:274;;;;:::o;13422:168::-;13495:9;;;13526;;13543:15;;;13537:22;;13523:37;13513:71;;13564:18;;:::i;13595:217::-;13635:1;13661;13651:132;;13705:10;13700:3;13696:20;13693:1;13686:31;13740:4;13737:1;13730:15;13768:4;13765:1;13758:15;13651:132;-1:-1:-1;13797:9:1;;13595:217::o;14418:125::-;14483:9;;;14504:10;;;14501:36;;;14517:18;;:::i;15067:128::-;15134:9;;;15155:11;;;15152:37;;;15169:18;;:::i;15607:180::-;-1:-1:-1;;;;;15712:10:1;;;15724;;;15708:27;;15747:11;;;15744:37;;;15761:18;;:::i;:::-;15744:37;15607:180;;;;:::o;16279:545::-;16381:2;16376:3;16373:11;16370:448;;;16417:1;16442:5;16438:2;16431:17;16487:4;16483:2;16473:19;16557:2;16545:10;16541:19;16538:1;16534:27;16528:4;16524:38;16593:4;16581:10;16578:20;16575:47;;;-1:-1:-1;16616:4:1;16575:47;16671:2;16666:3;16662:12;16659:1;16655:20;16649:4;16645:31;16635:41;;16726:82;16744:2;16737:5;16734:13;16726:82;;;16789:17;;;16770:1;16759:13;16726:82;;16370:448;16279:545;;;:::o;17000:1352::-;17126:3;17120:10;-1:-1:-1;;;;;17145:6:1;17142:30;17139:56;;;17175:18;;:::i;:::-;17204:97;17294:6;17254:38;17286:4;17280:11;17254:38;:::i;:::-;17248:4;17204:97;:::i;:::-;17356:4;;17420:2;17409:14;;17437:1;17432:663;;;;18139:1;18156:6;18153:89;;;-1:-1:-1;18208:19:1;;;18202:26;18153:89;-1:-1:-1;;16957:1:1;16953:11;;;16949:24;16945:29;16935:40;16981:1;16977:11;;;16932:57;18255:81;;17402:944;;17432:663;16226:1;16219:14;;;16263:4;16250:18;;-1:-1:-1;;17468:20:1;;;17586:236;17600:7;17597:1;17594:14;17586:236;;;17689:19;;;17683:26;17668:42;;17781:27;;;;17749:1;17737:14;;;;17616:19;;17586:236;;;17590:3;17850:6;17841:7;17838:19;17835:201;;;17911:19;;;17905:26;-1:-1:-1;;17994:1:1;17990:14;;;18006:3;17986:24;17982:37;17978:42;17963:58;17948:74;;17835:201;-1:-1:-1;;;;;18082:1:1;18066:14;;;18062:22;18049:36;;-1:-1:-1;17000:1352:1:o;19397:127::-;19458:10;19453:3;19449:20;19446:1;19439:31;19489:4;19486:1;19479:15;19513:4;19510:1;19503:15;21054:561;-1:-1:-1;;;;;21351:15:1;;;21333:34;;21403:15;;21398:2;21383:18;;21376:43;21450:2;21435:18;;21428:34;;;21493:2;21478:18;;21471:34;;;21313:3;21536;21521:19;;21514:32;;;21276:4;;21563:46;;21589:19;;21581:6;21563:46;:::i;:::-;21555:54;21054:561;-1:-1:-1;;;;;;;21054:561:1:o;21620:249::-;21689:6;21742:2;21730:9;21721:7;21717:23;21713:32;21710:52;;;21758:1;21755;21748:12;21710:52;21790:9;21784:16;21809:30;21833:5;21809:30;:::i;21874:179::-;21909:3;21951:1;21933:16;21930:23;21927:120;;;21997:1;21994;21991;21976:23;-1:-1:-1;22034:1:1;22028:8;22023:3;22019:18;21927:120;21874:179;:::o;22058:671::-;22097:3;22139:4;22121:16;22118:26;22115:39;;;22058:671;:::o;22115:39::-;22181:2;22175:9;-1:-1:-1;;22246:16:1;22242:25;;22239:1;22175:9;22218:50;22297:4;22291:11;22321:16;-1:-1:-1;;;;;22427:2:1;22420:4;22412:6;22408:17;22405:25;22400:2;22392:6;22389:14;22386:45;22383:58;;;22434:5;;;;;22058:671;:::o;22383:58::-;22471:6;22465:4;22461:17;22450:28;;22507:3;22501:10;22534:2;22526:6;22523:14;22520:27;;;22540:5;;;;;;22058:671;:::o;22520:27::-;22624:2;22605:16;22599:4;22595:27;22591:36;22584:4;22575:6;22570:3;22566:16;22562:27;22559:69;22556:82;;;22631:5;;;;;;22058:671;:::o;22556:82::-;22647:57;22698:4;22689:6;22681;22677:19;22673:30;22667:4;22647:57;:::i;:::-;-1:-1:-1;22720:3:1;;22058:671;-1:-1:-1;;;;;22058:671:1:o
Swarm Source
ipfs://04833a06cd4aead9511d567f07af67b14d4699308548f3ee0952df511ece4475
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 30 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|---|---|---|---|---|
ETH | Ether (ETH) | 100.00% | $2,544.93 | 0.18 | $458.09 |
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.