ERC-721
Overview
Max Total Supply
444 PVP-GENESIS-PASS
Holders
236
Market
Volume (24H)
N/A
Min Price (24H)
N/A
Max Price (24H)
N/A
Other Info
Token Contract
Balance
0 PVP-GENESIS-PASSLoading...
Loading
Loading...
Loading
Loading...
Loading
# | Exchange | Pair | Price | 24H Volume | % Volume |
---|
Contract Name:
PVPNFT
Compiler Version
v0.8.17+commit.8df45f5f
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: UNLICENSED pragma solidity 0.8.17; import "ERC721Psi/ERC721Psi.sol"; import "openzeppelin-contracts/access/Ownable.sol"; import "./Errors.sol"; contract PVPNFT is ERC721Psi, Ownable { event NewSale(address sale); event TokensRevealed(); address sale; string private baseURI; bool private uriAlreadySet; modifier onlySale() { if (_msgSender() != sale) { revert Blocked(); } _; } modifier onlyOwnerOrSale() { if( (_msgSender() != owner()) && (_msgSender() != sale) ) { revert Blocked(); } _; } constructor(address owner_, address sale_, string memory name_, string memory symbol_, string memory initialURI_) ERC721Psi(name_, symbol_) { transferOwnership(owner_); baseURI = initialURI_; sale = sale_; } function setSale(address sale_) external onlyOwner { if (sale == sale_) { revert AlreadySet(); } sale = sale_; emit NewSale(sale); } function reveal(string calldata uri_) external onlyOwner { if (uriAlreadySet) { revert AlreadySet(); } uriAlreadySet = true; emit TokensRevealed(); baseURI = uri_; } function mint(address receiver_, uint256 amount_) external onlySale { _safeMint(receiver_, amount_); } function _baseURI() internal view override virtual returns (string memory) { return baseURI; } }
// SPDX-License-Identifier: MIT /** ______ _____ _____ ______ ___ __ _ _ _ | ____| __ \ / ____|____ |__ \/_ | || || | | |__ | |__) | | / / ) || | \| |/ | | __| | _ /| | / / / / | |\_ _/ | |____| | \ \| |____ / / / /_ | | | | |______|_| \_\\_____|/_/ |____||_| |_| - github: https://github.com/estarriolvetch/ERC721Psi - npm: https://www.npmjs.com/package/erc721psi */ pragma solidity ^0.8.0; import "@openzeppelin/contracts/token/ERC721/IERC721.sol"; import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol"; import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol"; import "@openzeppelin/contracts/utils/Context.sol"; import "@openzeppelin/contracts/utils/Strings.sol"; import "@openzeppelin/contracts/utils/introspection/ERC165.sol"; import "@openzeppelin/contracts/utils/Address.sol"; import "@openzeppelin/contracts/utils/StorageSlot.sol"; import "solidity-bits/contracts/BitMaps.sol"; contract ERC721Psi is Context, ERC165, IERC721, IERC721Metadata { using Address for address; using Strings for uint256; using BitMaps for BitMaps.BitMap; BitMaps.BitMap private _batchHead; string private _name; string private _symbol; // Mapping from token ID to owner address mapping(uint256 => address) internal _owners; uint256 private _currentIndex; mapping(uint256 => address) private _tokenApprovals; mapping(address => mapping(address => bool)) private _operatorApprovals; /** * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection. */ constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; _currentIndex = _startTokenId(); } /** * @dev Returns the starting token ID. * To change the starting token ID, please override this function. */ function _startTokenId() internal pure returns (uint256) { // It will become modifiable in the future versions return 0; } /** * @dev Returns the next token ID to be minted. */ function _nextTokenId() internal view virtual returns (uint256) { return _currentIndex; } /** * @dev Returns the total amount of tokens minted in the contract. */ function _totalMinted() internal view virtual returns (uint256) { return _currentIndex - _startTokenId(); } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) { return interfaceId == type(IERC721).interfaceId || interfaceId == type(IERC721Metadata).interfaceId || super.supportsInterface(interfaceId); } /** * @dev See {IERC721-balanceOf}. */ function balanceOf(address owner) public view virtual override returns (uint) { require(owner != address(0), "ERC721Psi: balance query for the zero address"); uint count; for( uint i = _startTokenId(); i < _nextTokenId(); ++i ){ if(_exists(i)){ if( owner == ownerOf(i)){ ++count; } } } return count; } /** * @dev See {IERC721-ownerOf}. */ function ownerOf(uint256 tokenId) public view virtual override returns (address) { (address owner, ) = _ownerAndBatchHeadOf(tokenId); return owner; } function _ownerAndBatchHeadOf(uint256 tokenId) internal view returns (address owner, uint256 tokenIdBatchHead){ require(_exists(tokenId), "ERC721Psi: owner query for nonexistent token"); tokenIdBatchHead = _getBatchHead(tokenId); owner = _owners[tokenIdBatchHead]; } /** * @dev See {IERC721Metadata-name}. */ function name() public view virtual override returns (string memory) { return _name; } /** * @dev See {IERC721Metadata-symbol}. */ function symbol() public view virtual override returns (string memory) { return _symbol; } /** * @dev See {IERC721Metadata-tokenURI}. */ function tokenURI(uint256 tokenId) public view virtual override returns (string memory) { require(_exists(tokenId), "ERC721Psi: URI query for nonexistent token"); string memory baseURI = _baseURI(); return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : ""; } /** * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each * token will be the concatenation of the `baseURI` and the `tokenId`. Empty * by default, can be overriden in child contracts. */ function _baseURI() internal view virtual returns (string memory) { return ""; } /** * @dev See {IERC721-approve}. */ function approve(address to, uint256 tokenId) public virtual override { address owner = ownerOf(tokenId); require(to != owner, "ERC721Psi: approval to current owner"); require( _msgSender() == owner || isApprovedForAll(owner, _msgSender()), "ERC721Psi: approve caller is not owner nor approved for all" ); _approve(to, tokenId); } /** * @dev See {IERC721-getApproved}. */ function getApproved(uint256 tokenId) public view virtual override returns (address) { require( _exists(tokenId), "ERC721Psi: approved query for nonexistent token" ); return _tokenApprovals[tokenId]; } /** * @dev See {IERC721-setApprovalForAll}. */ function setApprovalForAll(address operator, bool approved) public virtual override { require(operator != _msgSender(), "ERC721Psi: approve to caller"); _operatorApprovals[_msgSender()][operator] = approved; emit ApprovalForAll(_msgSender(), operator, approved); } /** * @dev See {IERC721-isApprovedForAll}. */ function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) { return _operatorApprovals[owner][operator]; } /** * @dev See {IERC721-transferFrom}. */ function transferFrom( address from, address to, uint256 tokenId ) public virtual override { //solhint-disable-next-line max-line-length require( _isApprovedOrOwner(_msgSender(), tokenId), "ERC721Psi: transfer caller is not owner nor approved" ); _transfer(from, to, tokenId); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom( address from, address to, uint256 tokenId ) public virtual override { safeTransferFrom(from, to, tokenId, ""); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom( address from, address to, uint256 tokenId, bytes memory _data ) public virtual override { require( _isApprovedOrOwner(_msgSender(), tokenId), "ERC721Psi: transfer caller is not owner nor approved" ); _safeTransfer(from, to, tokenId, _data); } /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * `_data` is additional data, it has no specified format and it is sent in call to `to`. * * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g. * implement alternative mechanisms to perform token transfer, such as signature-based. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function _safeTransfer( address from, address to, uint256 tokenId, bytes memory _data ) internal virtual { _transfer(from, to, tokenId); require( _checkOnERC721Received(from, to, tokenId, 1,_data), "ERC721Psi: transfer to non ERC721Receiver implementer" ); } /** * @dev Returns whether `tokenId` exists. * * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}. * * Tokens start existing when they are minted (`_mint`). */ function _exists(uint256 tokenId) internal view virtual returns (bool) { return tokenId < _nextTokenId() && _startTokenId() <= tokenId; } /** * @dev Returns whether `spender` is allowed to manage `tokenId`. * * Requirements: * * - `tokenId` must exist. */ function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) { require( _exists(tokenId), "ERC721Psi: operator query for nonexistent token" ); address owner = ownerOf(tokenId); return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender)); } /** * @dev Safely mints `quantity` tokens and transfers them to `to`. * * Requirements: * * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called for each safe transfer. * - `quantity` must be greater than 0. * * Emits a {Transfer} event. */ function _safeMint(address to, uint256 quantity) internal virtual { _safeMint(to, quantity, ""); } function _safeMint( address to, uint256 quantity, bytes memory _data ) internal virtual { uint256 nextTokenId = _nextTokenId(); _mint(to, quantity); require( _checkOnERC721Received(address(0), to, nextTokenId, quantity, _data), "ERC721Psi: transfer to non ERC721Receiver implementer" ); } function _mint( address to, uint256 quantity ) internal virtual { uint256 nextTokenId = _nextTokenId(); require(quantity > 0, "ERC721Psi: quantity must be greater 0"); require(to != address(0), "ERC721Psi: mint to the zero address"); _beforeTokenTransfers(address(0), to, nextTokenId, quantity); _currentIndex += quantity; _owners[nextTokenId] = to; _batchHead.set(nextTokenId); _afterTokenTransfers(address(0), to, nextTokenId, quantity); // Emit events for(uint256 tokenId=nextTokenId; tokenId < nextTokenId + quantity; tokenId++){ emit Transfer(address(0), to, tokenId); } } /** * @dev Transfers `tokenId` from `from` to `to`. * As opposed to {transferFrom}, this imposes no restrictions on msg.sender. * * Requirements: * * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * * Emits a {Transfer} event. */ function _transfer( address from, address to, uint256 tokenId ) internal virtual { (address owner, uint256 tokenIdBatchHead) = _ownerAndBatchHeadOf(tokenId); require( owner == from, "ERC721Psi: transfer of token that is not own" ); require(to != address(0), "ERC721Psi: transfer to the zero address"); _beforeTokenTransfers(from, to, tokenId, 1); // Clear approvals from the previous owner _approve(address(0), tokenId); uint256 subsequentTokenId = tokenId + 1; if(!_batchHead.get(subsequentTokenId) && subsequentTokenId < _nextTokenId() ) { _owners[subsequentTokenId] = from; _batchHead.set(subsequentTokenId); } _owners[tokenId] = to; if(tokenId != tokenIdBatchHead) { _batchHead.set(tokenId); } emit Transfer(from, to, tokenId); _afterTokenTransfers(from, to, tokenId, 1); } /** * @dev Approve `to` to operate on `tokenId` * * Emits a {Approval} event. */ function _approve(address to, uint256 tokenId) internal virtual { _tokenApprovals[tokenId] = to; emit Approval(ownerOf(tokenId), to, tokenId); } /** * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address. * The call is not executed if the target address is not a contract. * * @param from address representing the previous owner of the given token ID * @param to target address that will receive the tokens * @param startTokenId uint256 the first ID of the tokens to be transferred * @param quantity uint256 amount of the tokens to be transfered. * @param _data bytes optional data to send along with the call * @return r bool whether the call correctly returned the expected magic value */ function _checkOnERC721Received( address from, address to, uint256 startTokenId, uint256 quantity, bytes memory _data ) private returns (bool r) { if (to.isContract()) { r = true; for(uint256 tokenId = startTokenId; tokenId < startTokenId + quantity; tokenId++){ try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) { r = r && retval == IERC721Receiver.onERC721Received.selector; } catch (bytes memory reason) { if (reason.length == 0) { revert("ERC721Psi: transfer to non ERC721Receiver implementer"); } else { assembly { revert(add(32, reason), mload(reason)) } } } } return r; } else { return true; } } function _getBatchHead(uint256 tokenId) internal view returns (uint256 tokenIdBatchHead) { tokenIdBatchHead = _batchHead.scanForward(tokenId); } function totalSupply() public virtual view returns (uint256) { return _totalMinted(); } /** * @dev Returns an array of token IDs owned by `owner`. * * This function scans the ownership mapping and is O(`totalSupply`) in complexity. * It is meant to be called off-chain. * * This function is compatiable with ERC721AQueryable. */ function tokensOfOwner(address owner) external view virtual returns (uint256[] memory) { unchecked { uint256 tokenIdsIdx; uint256 tokenIdsLength = balanceOf(owner); uint256[] memory tokenIds = new uint256[](tokenIdsLength); for (uint256 i = _startTokenId(); tokenIdsIdx != tokenIdsLength; ++i) { if (_exists(i)) { if (ownerOf(i) == owner) { tokenIds[tokenIdsIdx++] = i; } } } return tokenIds; } } /** * @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting. * * startTokenId - the first token id to be transferred * quantity - the amount to be transferred * * Calling conditions: * * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be * transferred to `to`. * - When `from` is zero, `tokenId` will be minted for `to`. */ function _beforeTokenTransfers( address from, address to, uint256 startTokenId, uint256 quantity ) internal virtual {} /** * @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes * minting. * * startTokenId - the first token id to be transferred * quantity - the amount to be transferred * * Calling conditions: * * - when `from` and `to` are both non-zero. * - `from` and `to` are never both zero. */ function _afterTokenTransfers( address from, address to, uint256 startTokenId, uint256 quantity ) internal virtual {} }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol) pragma solidity ^0.8.0; import "../utils/Context.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); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/IERC721.sol) pragma solidity ^0.8.0; import "../../utils/introspection/IERC165.sol"; /** * @dev Required interface of an ERC721 compliant contract. */ interface IERC721 is IERC165 { /** * @dev Emitted when `tokenId` token is transferred from `from` to `to`. */ event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token. */ event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets. */ event ApprovalForAll(address indexed owner, address indexed operator, bool approved); /** * @dev Returns the number of tokens in ``owner``'s account. */ function balanceOf(address owner) external view returns (uint256 balance); /** * @dev Returns the owner of the `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function ownerOf(uint256 tokenId) external view returns (address owner); /** * @dev Safely transfers `tokenId` token from `from` to `to`. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external; /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom(address from, address to, uint256 tokenId) external; /** * @dev Transfers `tokenId` token from `from` to `to`. * * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721 * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must * understand this adds an external call which potentially creates a reentrancy vulnerability. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * * Emits a {Transfer} event. */ function transferFrom(address from, address to, uint256 tokenId) external; /** * @dev Gives permission to `to` to transfer `tokenId` token to another account. * The approval is cleared when the token is transferred. * * Only a single account can be approved at a time, so approving the zero address clears previous approvals. * * Requirements: * * - The caller must own the token or be an approved operator. * - `tokenId` must exist. * * Emits an {Approval} event. */ function approve(address to, uint256 tokenId) external; /** * @dev Approve or remove `operator` as an operator for the caller. * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. * * Requirements: * * - The `operator` cannot be the caller. * * Emits an {ApprovalForAll} event. */ function setApprovalForAll(address operator, bool _approved) external; /** * @dev Returns the account approved for `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function getApproved(uint256 tokenId) external view returns (address operator); /** * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`. * * See {setApprovalForAll} */ function isApprovedForAll(address owner, address operator) external view returns (bool); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol) pragma solidity ^0.8.0; /** * @title ERC721 token receiver interface * @dev Interface for any contract that wants to support safeTransfers * from ERC721 asset contracts. */ interface IERC721Receiver { /** * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom} * by `operator` from `from`, this function is called. * * It must return its Solidity selector to confirm the token transfer. * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted. * * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`. */ function onERC721Received( address operator, address from, uint256 tokenId, bytes calldata data ) external returns (bytes4); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol) pragma solidity ^0.8.0; import "../IERC721.sol"; /** * @title ERC-721 Non-Fungible Token Standard, optional metadata extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721Metadata is IERC721 { /** * @dev Returns the token collection name. */ function name() external view returns (string memory); /** * @dev Returns the token collection symbol. */ function symbol() external view returns (string memory); /** * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token. */ function tokenURI(uint256 tokenId) external view returns (string memory); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol) pragma solidity ^0.8.1; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== * * [IMPORTANT] * ==== * You shouldn't rely on `isContract` to protect against flash loan attacks! * * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract * constructor. * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize/address.code.length, which returns 0 // for contracts in construction, since the code is only stored at the end // of the constructor execution. return account.code.length > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.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); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/Context.sol) pragma solidity ^0.8.0; /** * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (utils/StorageSlot.sol) pragma solidity ^0.8.0; /** * @dev Library for reading and writing primitive types to specific storage slots. * * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts. * This library helps with reading and writing to such slots without the need for inline assembly. * * The functions in this library return Slot structs that contain a `value` member that can be used to read or write. * * Example usage to set ERC1967 implementation slot: * ``` * contract ERC1967 { * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc; * * function _getImplementation() internal view returns (address) { * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value; * } * * function _setImplementation(address newImplementation) internal { * require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract"); * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation; * } * } * ``` * * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._ */ library StorageSlot { struct AddressSlot { address value; } struct BooleanSlot { bool value; } struct Bytes32Slot { bytes32 value; } struct Uint256Slot { uint256 value; } /** * @dev Returns an `AddressSlot` with member `value` located at `slot`. */ function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `BooleanSlot` with member `value` located at `slot`. */ function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `Bytes32Slot` with member `value` located at `slot`. */ function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `Uint256Slot` with member `value` located at `slot`. */ function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol) pragma solidity ^0.8.0; import "./math/Math.sol"; /** * @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); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol) pragma solidity ^0.8.0; import "./IERC165.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; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC165 standard, as defined in the * https://eips.ethereum.org/EIPS/eip-165[EIP]. * * Implementers can declare support of contract interfaces, which can then be * queried by others ({ERC165Checker}). * * For an implementation, see {ERC165}. */ interface IERC165 { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol) pragma solidity ^0.8.0; /** * @dev Standard math utilities missing in the Solidity language. */ library Math { enum Rounding { Down, // Toward negative infinity Up, // Toward infinity Zero // Toward zero } /** * @dev Returns the largest of two numbers. */ function max(uint256 a, uint256 b) internal pure returns (uint256) { return a > b ? a : b; } /** * @dev Returns the smallest of two numbers. */ function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } /** * @dev Returns the average of two numbers. The result is rounded towards * zero. */ function average(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b) / 2 can overflow. return (a & b) + (a ^ b) / 2; } /** * @dev Returns the ceiling of the division of two numbers. * * This differs from standard division with `/` in that it rounds up instead * of rounding down. */ function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b - 1) / b can overflow on addition, so we distribute. return a == 0 ? 0 : (a - 1) / b + 1; } /** * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0 * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) * with further edits by Uniswap Labs also under MIT license. */ function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) { unchecked { // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256 // variables such that product = prod1 * 2^256 + prod0. uint256 prod0; // Least significant 256 bits of the product uint256 prod1; // Most significant 256 bits of the product assembly { let mm := mulmod(x, y, not(0)) prod0 := mul(x, y) prod1 := sub(sub(mm, prod0), lt(mm, prod0)) } // Handle non-overflow cases, 256 by 256 division. if (prod1 == 0) { return prod0 / denominator; } // Make sure the result is less than 2^256. Also prevents denominator == 0. require(denominator > prod1, "Math: mulDiv overflow"); /////////////////////////////////////////////// // 512 by 256 division. /////////////////////////////////////////////// // Make division exact by subtracting the remainder from [prod1 prod0]. uint256 remainder; assembly { // Compute remainder using mulmod. remainder := mulmod(x, y, denominator) // Subtract 256 bit number from 512 bit number. prod1 := sub(prod1, gt(remainder, prod0)) prod0 := sub(prod0, remainder) } // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1. // See https://cs.stackexchange.com/q/138556/92363. // Does not overflow because the denominator cannot be zero at this stage in the function. uint256 twos = denominator & (~denominator + 1); assembly { // Divide denominator by twos. denominator := div(denominator, twos) // Divide [prod1 prod0] by twos. prod0 := div(prod0, twos) // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one. twos := add(div(sub(0, twos), twos), 1) } // Shift in bits from prod1 into prod0. prod0 |= prod1 * twos; // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for // four bits. That is, denominator * inv = 1 mod 2^4. uint256 inverse = (3 * denominator) ^ 2; // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works // in modular arithmetic, doubling the correct bits in each step. inverse *= 2 - denominator * inverse; // inverse mod 2^8 inverse *= 2 - denominator * inverse; // inverse mod 2^16 inverse *= 2 - denominator * inverse; // inverse mod 2^32 inverse *= 2 - denominator * inverse; // inverse mod 2^64 inverse *= 2 - denominator * inverse; // inverse mod 2^128 inverse *= 2 - denominator * inverse; // inverse mod 2^256 // Because the division is now exact we can divide by multiplying with the modular inverse of denominator. // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1 // is no longer required. result = prod0 * inverse; return result; } } /** * @notice Calculates x * y / denominator with full precision, following the selected rounding direction. */ function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) { uint256 result = mulDiv(x, y, denominator); if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) { result += 1; } return result; } /** * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down. * * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11). */ function sqrt(uint256 a) internal pure returns (uint256) { if (a == 0) { return 0; } // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target. // // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`. // // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)` // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))` // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)` // // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit. uint256 result = 1 << (log2(a) >> 1); // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128, // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision // into the expected uint128 result. unchecked { result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; return min(result, a / result); } } /** * @notice Calculates sqrt(a), following the selected rounding direction. */ function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = sqrt(a); return result + (rounding == Rounding.Up && result * result < a ? 1 : 0); } } /** * @dev Return the log in base 2, rounded down, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 128; } if (value >> 64 > 0) { value >>= 64; result += 64; } if (value >> 32 > 0) { value >>= 32; result += 32; } if (value >> 16 > 0) { value >>= 16; result += 16; } if (value >> 8 > 0) { value >>= 8; result += 8; } if (value >> 4 > 0) { value >>= 4; result += 4; } if (value >> 2 > 0) { value >>= 2; result += 2; } if (value >> 1 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 2, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log2(value); return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0); } } /** * @dev Return the log in base 10, rounded down, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >= 10 ** 64) { value /= 10 ** 64; result += 64; } if (value >= 10 ** 32) { value /= 10 ** 32; result += 32; } if (value >= 10 ** 16) { value /= 10 ** 16; result += 16; } if (value >= 10 ** 8) { value /= 10 ** 8; result += 8; } if (value >= 10 ** 4) { value /= 10 ** 4; result += 4; } if (value >= 10 ** 2) { value /= 10 ** 2; result += 2; } if (value >= 10 ** 1) { result += 1; } } return result; } /** * @dev Return the log in base 10, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log10(value); return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0); } } /** * @dev Return the log in base 256, rounded down, of a positive value. * Returns 0 if given 0. * * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string. */ function log256(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 16; } if (value >> 64 > 0) { value >>= 64; result += 8; } if (value >> 32 > 0) { value >>= 32; result += 4; } if (value >> 16 > 0) { value >>= 16; result += 2; } if (value >> 8 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 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 << 3) < value ? 1 : 0); } } }
// SPDX-License-Identifier: MIT /** _____ ___ ___ __ ____ _ __ / ___/____ / (_)___/ (_) /___ __ / __ )(_) /______ \__ \/ __ \/ / / __ / / __/ / / / / __ / / __/ ___/ ___/ / /_/ / / / /_/ / / /_/ /_/ / / /_/ / / /_(__ ) /____/\____/_/_/\__,_/_/\__/\__, / /_____/_/\__/____/ /____/ - npm: https://www.npmjs.com/package/solidity-bits - github: https://github.com/estarriolvetch/solidity-bits */ pragma solidity ^0.8.0; import "./BitScan.sol"; import "./Popcount.sol"; /** * @dev This Library is a modified version of Openzeppelin's BitMaps library with extra features. * * 1. Functions of finding the index of the closest set bit from a given index are added. * The indexing of each bucket is modifed to count from the MSB to the LSB instead of from the LSB to the MSB. * The modification of indexing makes finding the closest previous set bit more efficient in gas usage. * 2. Setting and unsetting the bitmap consecutively. * 3. Accounting number of set bits within a given range. * */ /** * @dev Library for managing uint256 to bool mapping in a compact and efficient way, providing the keys are sequential. * Largelly inspired by Uniswap's https://github.com/Uniswap/merkle-distributor/blob/master/contracts/MerkleDistributor.sol[merkle-distributor]. */ library BitMaps { using BitScan for uint256; uint256 private constant MASK_INDEX_ZERO = (1 << 255); uint256 private constant MASK_FULL = type(uint256).max; struct BitMap { mapping(uint256 => uint256) _data; } /** * @dev Returns whether the bit at `index` is set. */ function get(BitMap storage bitmap, uint256 index) internal view returns (bool) { uint256 bucket = index >> 8; uint256 mask = MASK_INDEX_ZERO >> (index & 0xff); return bitmap._data[bucket] & mask != 0; } /** * @dev Sets the bit at `index` to the boolean `value`. */ function setTo( BitMap storage bitmap, uint256 index, bool value ) internal { if (value) { set(bitmap, index); } else { unset(bitmap, index); } } /** * @dev Sets the bit at `index`. */ function set(BitMap storage bitmap, uint256 index) internal { uint256 bucket = index >> 8; uint256 mask = MASK_INDEX_ZERO >> (index & 0xff); bitmap._data[bucket] |= mask; } /** * @dev Unsets the bit at `index`. */ function unset(BitMap storage bitmap, uint256 index) internal { uint256 bucket = index >> 8; uint256 mask = MASK_INDEX_ZERO >> (index & 0xff); bitmap._data[bucket] &= ~mask; } /** * @dev Consecutively sets `amount` of bits starting from the bit at `startIndex`. */ function setBatch(BitMap storage bitmap, uint256 startIndex, uint256 amount) internal { uint256 bucket = startIndex >> 8; uint256 bucketStartIndex = (startIndex & 0xff); unchecked { if(bucketStartIndex + amount < 256) { bitmap._data[bucket] |= MASK_FULL << (256 - amount) >> bucketStartIndex; } else { bitmap._data[bucket] |= MASK_FULL >> bucketStartIndex; amount -= (256 - bucketStartIndex); bucket++; while(amount > 256) { bitmap._data[bucket] = MASK_FULL; amount -= 256; bucket++; } bitmap._data[bucket] |= MASK_FULL << (256 - amount); } } } /** * @dev Consecutively unsets `amount` of bits starting from the bit at `startIndex`. */ function unsetBatch(BitMap storage bitmap, uint256 startIndex, uint256 amount) internal { uint256 bucket = startIndex >> 8; uint256 bucketStartIndex = (startIndex & 0xff); unchecked { if(bucketStartIndex + amount < 256) { bitmap._data[bucket] &= ~(MASK_FULL << (256 - amount) >> bucketStartIndex); } else { bitmap._data[bucket] &= ~(MASK_FULL >> bucketStartIndex); amount -= (256 - bucketStartIndex); bucket++; while(amount > 256) { bitmap._data[bucket] = 0; amount -= 256; bucket++; } bitmap._data[bucket] &= ~(MASK_FULL << (256 - amount)); } } } /** * @dev Returns number of set bits within a range. */ function popcountA(BitMap storage bitmap, uint256 startIndex, uint256 amount) internal view returns(uint256 count) { uint256 bucket = startIndex >> 8; uint256 bucketStartIndex = (startIndex & 0xff); unchecked { if(bucketStartIndex + amount < 256) { count += Popcount.popcount256A( bitmap._data[bucket] & (MASK_FULL << (256 - amount) >> bucketStartIndex) ); } else { count += Popcount.popcount256A( bitmap._data[bucket] & (MASK_FULL >> bucketStartIndex) ); amount -= (256 - bucketStartIndex); bucket++; while(amount > 256) { count += Popcount.popcount256A(bitmap._data[bucket]); amount -= 256; bucket++; } count += Popcount.popcount256A( bitmap._data[bucket] & (MASK_FULL << (256 - amount)) ); } } } /** * @dev Returns number of set bits within a range. */ function popcountB(BitMap storage bitmap, uint256 startIndex, uint256 amount) internal view returns(uint256 count) { uint256 bucket = startIndex >> 8; uint256 bucketStartIndex = (startIndex & 0xff); unchecked { if(bucketStartIndex + amount < 256) { count += Popcount.popcount256B( bitmap._data[bucket] & (MASK_FULL << (256 - amount) >> bucketStartIndex) ); } else { count += Popcount.popcount256B( bitmap._data[bucket] & (MASK_FULL >> bucketStartIndex) ); amount -= (256 - bucketStartIndex); bucket++; while(amount > 256) { count += Popcount.popcount256B(bitmap._data[bucket]); amount -= 256; bucket++; } count += Popcount.popcount256B( bitmap._data[bucket] & (MASK_FULL << (256 - amount)) ); } } } /** * @dev Find the closest index of the set bit before `index`. */ function scanForward(BitMap storage bitmap, uint256 index) internal view returns (uint256 setBitIndex) { uint256 bucket = index >> 8; // index within the bucket uint256 bucketIndex = (index & 0xff); // load a bitboard from the bitmap. uint256 bb = bitmap._data[bucket]; // offset the bitboard to scan from `bucketIndex`. bb = bb >> (0xff ^ bucketIndex); // bb >> (255 - bucketIndex) if(bb > 0) { unchecked { setBitIndex = (bucket << 8) | (bucketIndex - bb.bitScanForward256()); } } else { while(true) { require(bucket > 0, "BitMaps: The set bit before the index doesn't exist."); unchecked { bucket--; } // No offset. Always scan from the least significiant bit now. bb = bitmap._data[bucket]; if(bb > 0) { unchecked { setBitIndex = (bucket << 8) | (255 - bb.bitScanForward256()); break; } } } } } function getBucket(BitMap storage bitmap, uint256 bucket) internal view returns (uint256) { return bitmap._data[bucket]; } }
// SPDX-License-Identifier: MIT /** _____ ___ ___ __ ____ _ __ / ___/____ / (_)___/ (_) /___ __ / __ )(_) /______ \__ \/ __ \/ / / __ / / __/ / / / / __ / / __/ ___/ ___/ / /_/ / / / /_/ / / /_/ /_/ / / /_/ / / /_(__ ) /____/\____/_/_/\__,_/_/\__/\__, / /_____/_/\__/____/ /____/ - npm: https://www.npmjs.com/package/solidity-bits - github: https://github.com/estarriolvetch/solidity-bits */ pragma solidity ^0.8.0; library BitScan { uint256 constant private DEBRUIJN_256 = 0x818283848586878898a8b8c8d8e8f929395969799a9b9d9e9faaeb6bedeeff; bytes constant private LOOKUP_TABLE_256 = hex"0001020903110a19042112290b311a3905412245134d2a550c5d32651b6d3a7506264262237d468514804e8d2b95569d0d495ea533a966b11c886eb93bc176c9071727374353637324837e9b47af86c7155181ad4fd18ed32c9096db57d59ee30e2e4a6a5f92a6be3498aae067ddb2eb1d5989b56fd7baf33ca0c2ee77e5caf7ff0810182028303840444c545c646c7425617c847f8c949c48a4a8b087b8c0c816365272829aaec650acd0d28fdad4e22d6991bd97dfdcea58b4d6f29fede4f6fe0f1f2f3f4b5b6b607b8b93a3a7b7bf357199c5abcfd9e168bcdee9b3f1ecf5fd1e3e5a7a8aa2b670c4ced8bbe8f0f4fc3d79a1c3cde7effb78cce6facbf9f8"; /** @dev Isolate the least significant set bit. */ function isolateLS1B256(uint256 bb) pure internal returns (uint256) { require(bb > 0); unchecked { return bb & (0 - bb); } } /** @dev Isolate the most significant set bit. */ function isolateMS1B256(uint256 bb) pure internal returns (uint256) { require(bb > 0); unchecked { bb |= bb >> 128; bb |= bb >> 64; bb |= bb >> 32; bb |= bb >> 16; bb |= bb >> 8; bb |= bb >> 4; bb |= bb >> 2; bb |= bb >> 1; return (bb >> 1) + 1; } } /** @dev Find the index of the lest significant set bit. (trailing zero count) */ function bitScanForward256(uint256 bb) pure internal returns (uint8) { unchecked { return uint8(LOOKUP_TABLE_256[(isolateLS1B256(bb) * DEBRUIJN_256) >> 248]); } } /** @dev Find the index of the most significant set bit. */ function bitScanReverse256(uint256 bb) pure internal returns (uint8) { unchecked { return 255 - uint8(LOOKUP_TABLE_256[((isolateMS1B256(bb) * DEBRUIJN_256) >> 248)]); } } function log2(uint256 bb) pure internal returns (uint8) { unchecked { return uint8(LOOKUP_TABLE_256[(isolateMS1B256(bb) * DEBRUIJN_256) >> 248]); } } }
// SPDX-License-Identifier: MIT /** _____ ___ ___ __ ____ _ __ / ___/____ / (_)___/ (_) /___ __ / __ )(_) /______ \__ \/ __ \/ / / __ / / __/ / / / / __ / / __/ ___/ ___/ / /_/ / / / /_/ / / /_/ /_/ / / /_/ / / /_(__ ) /____/\____/_/_/\__,_/_/\__/\__, / /_____/_/\__/____/ /____/ - npm: https://www.npmjs.com/package/solidity-bits - github: https://github.com/estarriolvetch/solidity-bits */ pragma solidity ^0.8.0; library Popcount { uint256 private constant m1 = 0x5555555555555555555555555555555555555555555555555555555555555555; uint256 private constant m2 = 0x3333333333333333333333333333333333333333333333333333333333333333; uint256 private constant m4 = 0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f; uint256 private constant h01 = 0x0101010101010101010101010101010101010101010101010101010101010101; function popcount256A(uint256 x) internal pure returns (uint256 count) { unchecked{ for (count=0; x!=0; count++) x &= x - 1; } } function popcount256B(uint256 x) internal pure returns (uint256) { if (x == type(uint256).max) { return 256; } unchecked { x -= (x >> 1) & m1; //put count of each 2 bits into those 2 bits x = (x & m2) + ((x >> 2) & m2); //put count of each 4 bits into those 4 bits x = (x + (x >> 4)) & m4; //put count of each 8 bits into those 8 bits x = (x * h01) >> 248; //returns left 8 bits of x + (x<<8) + (x<<16) + (x<<24) + ... } return x; } }
// SPDX-License-Identifier: UNLICENSED pragma solidity 0.8.17; /** @dev Action restricted. Given account is not allowed to run it */ error Restricted(); /** @dev Trying to set Zero Address to an attribute that cannot be 0 */ error ZeroAddress(); /** @dev Attribute already set and does not allow resetting */ error AlreadySet(); /** @dev A cap has been exceeded - temporarily locked */ error CapExceeded(); /** @dev A deadline has been wrongly set */ error WrongDeadline(); /** @dev A kill switch is in play. Action restricted and temporarily frozen */ error KillSwitch(); /** @dev A value cannot be zero */ error ZeroValue(); /** @dev Value exceeded maximum allowed */ error TooBig(); /** @dev Appointed item does not exist */ error NotExists(); /** @dev Appointed item already exist */ error AlreadyExists(); /** @dev Timed action has timed out */ error Timeout(); /** @dev Insufficient funds to perform action */ error InsufficientFunds(); /** @dev Wrong currency used */ error WrongCurrency(); /** @dev Blocked action. For timing or other reasons */ error Blocked(); /** @dev Suspended access */ error Suspended(); /** @dev Nothing to claim */ error NothingToClaim(); /** @dev Missing vesting tokens */ error MissingVestingTokens();
{ "remappings": [ "@openzeppelin/=lib/openzeppelin-contracts/", "ERC721Psi/=lib/ERC721Psi/contracts/", "ds-test/=lib/forge-std/lib/ds-test/src/", "erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/", "forge-std/=lib/forge-std/src/", "openzeppelin-contracts/=lib/openzeppelin-contracts/contracts/", "solidity-bits/=lib/solidity-bits/" ], "optimizer": { "enabled": true, "runs": 20000 }, "metadata": { "bytecodeHash": "ipfs" }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "abi" ] } }, "evmVersion": "london", "viaIR": true, "libraries": {} }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address","name":"owner_","type":"address"},{"internalType":"address","name":"sale_","type":"address"},{"internalType":"string","name":"name_","type":"string"},{"internalType":"string","name":"symbol_","type":"string"},{"internalType":"string","name":"initialURI_","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AlreadySet","type":"error"},{"inputs":[],"name":"Blocked","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"sale","type":"address"}],"name":"NewSale","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":[],"name":"TokensRevealed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"receiver_","type":"address"},{"internalType":"uint256","name":"amount_","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"uri_","type":"string"}],"name":"reveal","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sale_","type":"address"}],"name":"setSale","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"tokensOfOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]
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)
00000000000000000000000076fc5bde70ba5d418f4eae9769c254dcc3b5973d000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000001200000000000000000000000000000000000000000000000000000000000000012225076502047656e65736973205061737322000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000105056502d47454e455349532d5041535300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004068747470733a2f2f617277656176652e6e65742f643954303679485875335357483533714e5a6a3672514670375438544954344b57433856365249792d70412f
-----Decoded View---------------
Arg [0] : owner_ (address): 0x76fc5bDE70BA5d418f4Eae9769C254dcc3B5973d
Arg [1] : sale_ (address): 0x0000000000000000000000000000000000000000
Arg [2] : name_ (string): "PvP Genesis Pass"
Arg [3] : symbol_ (string): PVP-GENESIS-PASS
Arg [4] : initialURI_ (string): https://arweave.net/d9T06yHXu3SWH53qNZj6rQFp7T8TIT4KWC8V6RIy-pA/
-----Encoded View---------------
12 Constructor Arguments found :
Arg [0] : 00000000000000000000000076fc5bde70ba5d418f4eae9769c254dcc3b5973d
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [2] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [3] : 00000000000000000000000000000000000000000000000000000000000000e0
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000120
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000012
Arg [6] : 225076502047656e657369732050617373220000000000000000000000000000
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000010
Arg [8] : 5056502d47454e455349532d5041535300000000000000000000000000000000
Arg [9] : 0000000000000000000000000000000000000000000000000000000000000040
Arg [10] : 68747470733a2f2f617277656176652e6e65742f643954303679485875335357
Arg [11] : 483533714e5a6a3672514670375438544954344b57433856365249792d70412f
Deployed Bytecode Sourcemap
174:1307:16:-:0;;;;;;;;;-1:-1:-1;174:1307:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;;;;;;:::o;:::-;;;;;;-1:-1:-1;;174:1307:16;;;;;;;;;;;;:::i;:::-;;2753:25:0;2738:40;;:104;;;;;174:1307:16;2738:156:0;;;;174:1307:16;;;;;;;;;;2738:156:0;952:25:9;937:40;;;2738:156:0;;;:104;2809:33;2794:48;;;-1:-1:-1;2738:104:0;;174:1307:16;;;;;;;;-1:-1:-1;;174:1307:16;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;:::o;:::-;;;;;;;;;;;:::i;:::-;;:::o;:::-;;;;;;;-1:-1:-1;;174:1307:16;;;;;;;;;4150:5:0;174:1307:16;;;;;;:::i;:::-;;;;;;;;;4150:5:0;;;;174:1307:16;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;-1:-1:-1;;;174:1307:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;174:1307:16;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;:::o;:::-;;;;;;-1:-1:-1;;174:1307:16;;;;;;;:::i;:::-;;;3644:29:0;;;:::i;:::-;174:1307:16;;;;;;;;;;5239:11:0;174:1307:16;;5494:7:0;719:10:6;5302:168:0;719:10:6;;5323:21:0;:62;;;;;174:1307:16;5302:168:0;;:::i;:::-;5494:7;:::i;:::-;174:1307:16;5323:62:0;6486:35;719:10:6;;6486:35:0;719:10:6;6486:25:0;719:10:6;6486:25:0;174:1307:16;;;;6486:18:0;174:1307:16;;;;;;;6486:25:0;174:1307:16;;;;;;;;;;;;6486:35:0;174:1307:16;;;;;6486:35:0;5323:62;;;174:1307:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;174:1307:16;;;;;;;;;;;;;;;-1:-1:-1;;174:1307:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;6942:7:0;174:1307:16;;;:::i;:::-;719:10:6;6771:140:0;6792:41;719:10:6;;6792:41:0;:::i;:::-;6771:140;:::i;:::-;6942:7;:::i;174:1307:16:-;;;;;;-1:-1:-1;;174:1307:16;;;;;;;:::i;:::-;1063:62:1;;:::i;:::-;945:4:16;174:1307;;;;;;;;;945:13;941:43;;174:1307;1020:13;174:1307;;;;;;945:4;174:1307;;;;;;1020:13;174:1307;941:43;174:1307;;;969:12;;;;174:1307;;;;;;-1:-1:-1;;174:1307:16;;;;;;;:::i;:::-;;;;;;410:4;174:1307;;719:10:6;394:20:16;390:47;;174:1307;;;;;:::i;:::-;-1:-1:-1;174:1307:16;;;;;;10832:12:0;;;174:1307:16;;;;10904:16:0;10896:64;10904:16;;;10896:64;:::i;:::-;11049:25;;;;;:::i;:::-;174:1307:16;;;11049:25:0;11084;:20;;;174:1307:16;;11084:7:0;174:1307:16;;;;;;;11084:20:0;174:1307:16;;;;;;;;;;;11084:25:0;11134:11;;174:1307:16;2388:1:12;174:1307:16;;;;;;1478:8:12;174:1307:16;;;;2434:12:12;;174:1307:16;;;2457:28:12;174:1307:16;;2292:200:12;11134:11:0;11261:27;11324:9;11300:22;;;;:::i;:::-;11290:32;;;;;11353:33;11324:9;11353:33;;;;;;;11324:9;:::i;:::-;11261:27;;11290:32;;10514:68;11290:32;;10493:168;11290:32;10514:68;:::i;:::-;10493:168;:::i;:::-;174:1307:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;390:47;174:1307;;;425:9;;;;174:1307;;;;;7156:39:0;174:1307:16;;;:::i;:::-;;;;;;;;:::i;:::-;;;;7156:39:0;:::i;174:1307:16:-;;;;;;;-1:-1:-1;;174:1307:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1063:62:1;;:::i;:::-;1117:13:16;174:1307;;;;;1113:43;;174:1307;1181:4;;174:1307;;;;;1117:13;174:1307;-1:-1:-1;1200:16:16;;;;;174:1307;;;1226:14;174:1307;;:::i;:::-;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1226:14;174:1307;;;;;;;;-1:-1:-1;174:1307:16;;;;;;1226:14;174:1307;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1226:14;174:1307;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;174:1307:16;;;;;;;;;;;;-1:-1:-1;;174:1307:16;;;;;;3644:29:0;174:1307:16;;3644:29:0;:::i;:::-;174:1307:16;;;;;;;;;;;;;;;-1:-1:-1;;174:1307:16;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;;;;;-1:-1:-1;;174:1307:16;;;;;1063:62:1;;:::i;:::-;174:1307:16;;2525:6:1;174:1307:16;;;;2525:6:1;174:1307:16;;2573:40:1;;;;174:1307:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;174:1307:16;;;;;;;:::i;:::-;-1:-1:-1;15414:16:0;;;;:::i;:::-;174:1307:16;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;15520:27:0;15549:29;;;;;;174:1307:16;;;;;;;:::i;15580:3:0:-;15607:10;;174:1307:16;15607:10:0;;:::i;:::-;15603:157;;15580:3;174:1307:16;15520:27:0;;15603:157;3644:29;;;:::i;:::-;174:1307:16;;;;;;;15645:19:0;15603:157;15641:101;15701:13;;;;174:1307:16;;;;;;;;;15641:101:0;174:1307:16;;;;;;15603:157:0;;174:1307:16;;;:::i;:::-;;;;;;;;;-1:-1:-1;;174:1307:16;;;;;;;1273:6:1;174:1307:16;;;;;;;;;;;;;;;-1:-1:-1;;174:1307:16;;;;;;;;;4314:7:0;174:1307:16;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;4314:7:0;174:1307:16;;;;;;;;;-1:-1:-1;;;174:1307:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;174:1307:16;;;;;;;:::i;:::-;;;;;;;;;;;;;719:10:6;;6065:24:0;;174:1307:16;;719:10:6;6133:42:0;:53;719:10:6;;-1:-1:-1;174:1307:16;6133:18:0;174:1307:16;;;-1:-1:-1;174:1307:16;;;;;;;;;;;;;6133:42:0;174:1307:16;;;;;;;;;;;;;;6133:53:0;174:1307:16;;;;;;;719:10:6;;6201:48:0;;174:1307:16;;6201:48:0;174:1307:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;:::o;:::-;;;:::i;:::-;;;;;;;;;-1:-1:-1;;174:1307:16;;;;;;;:::i;:::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;-1:-1:-1;174:1307:16;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;-1:-1:-1;;174:1307:16;;;;;;;4500:16:0;;;:::i;:::-;174:1307:16;;;;;:::i;:::-;;;4625:25:0;:86;;4660:45;174:1307:16;4686:18:0;174:1307:16;4686:18:0;174:1307:16;4686:18:0;;:::i;:::-;174:1307:16;;4660:45:0;;;174:1307:16;4660:45:0;;174:1307:16;;:::i;:::-;;;:::i;:::-;4660:45:0;;;;;;;;:::i;4625:86::-;174:1307:16;;;;;:::i;:::-;4625:86:0;;174:1307:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;174:1307:16;;;;;;;6486:35:0;174:1307:16;;:::i;:::-;;;;:::i;:::-;;;-1:-1:-1;174:1307:16;6486:18:0;174:1307:16;;;-1:-1:-1;174:1307:16;;;;;;;;;;;;;6486:35:0;174:1307:16;;;;;;;;;;;;;;;;-1:-1:-1;;174:1307:16;;;;;;;:::i;:::-;1063:62:1;;:::i;:::-;174:1307:16;;;;2169:22:1;;;174:1307:16;;2525:6:1;174:1307:16;;;;;;2525:6:1;174:1307:16;;2573:40:1;-1:-1:-1;2573:40:1;;174:1307:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;:::i;:::-;;;:::o;2960:472:0:-;174:1307:16;;;;3106:19:0;;;174:1307:16;;;3211:24:0;;174:1307:16;2257:13:0;174:1307:16;3206:198:0;3237:18;;;;;;3413:12;;;;2960:472;:::o;3257:3::-;3279:10;;;:::i;:::-;3276:118;;3257:3;;;;:::i;:::-;3211:24;;3276:118;3644:29;;;;:::i;:::-;174:1307:16;;3312:19:0;;3276:118;3308:72;3354:7;;3257:3;3354:7;;:::i;:::-;3308:72;;;3276:118;;174:1307:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;3708:294:0;3836:16;;;:::i;:::-;174:1307:16;;;14804:10:0;7063:1:12;;174:1307:16;;;;;;7133:12:12;;174:1307:16;;;;;;;;;7316:18:12;174:1307:16;7316:18:12;174:1307:16;7386:6:12;;;7383:736;7386:6;;;7482:22;7467:37;7482:22;;:::i;:::-;174:1307:16;;;;7467:37:12;174:1307:16;;;;7450:55:12;7383:736;3970:25:0;;3911:41;174:1307:16;;11084:7:0;174:1307:16;;;;;;;3970:25:0;174:1307:16;;;;;3970:25:0;3708:294;:::o;7383:736:12:-;7554:555;;174:1307:16;7554:555:12;;7584:75;7592:10;;;7584:75;:::i;:::-;174:1307:16;7837:20:12;;14804:10:0;174:1307:16;14804:10:0;174:1307:16;;;14804:10:0;174:1307:16;;;7837:20:12;174:1307:16;7895:6:12;7892:202;;7554:555;174:1307:16;7554:555:12;;;7892:202;7992:29;7999:22;7975:47;7999:22;;:::i;:::-;174:1307:16;;;;;;;7975:47:12;174:1307:16;;7975:47:12;7383:736;;174:1307:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;174:1307:16;1465:7;174:1307;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:::o;:::-;1465:7;-1:-1:-1;174:1307:16;;;-1:-1:-1;;174:1307:16;;;;;;;-1:-1:-1;174:1307:16;;-1:-1:-1;;174:1307:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;174:1307:16;;:::o;:::-;;;:::i;:::-;;;;;;;;;;;;;;;;:::i;:::-;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;5570:298:0;5730:16;;;:::i;:::-;174:1307:16;;;-1:-1:-1;174:1307:16;5837:15:0;174:1307:16;;;;-1:-1:-1;174:1307:16;;;5570:298:0;:::o;174:1307:16:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;7268:357:0;;8676:150;7268:357;;8697:50;7268:357;7429:140;7450:41;719:10:6;;7450:41:0;:::i;7429:140::-;8658:7;;;;;:::i;:::-;8697:50;:::i;174:1307:16:-;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9079:149:0;2257:13;174:1307:16;-1:-1:-1;9167:54:0;;;9079:149;:::o;9167:54::-;;9195:26;9079:149;:::o;9386:434::-;9552:16;;;:::i;:::-;174:1307:16;;;3644:29:0;;;:::i;:::-;174:1307:16;;;;;;;;;9701:16:0;;:63;;;;;9386:434;9701:111;;;;;;;9693:120;;9386:434;:::o;9701:111::-;174:1307:16;6486:25:0;;;;:35;:25;174:1307:16;;;;6486:18:0;174:1307:16;;;;;;;6486:35:0;174:1307:16;;9386:434:0;:::o;9701:63::-;9733:20;;;;;;;:::i;:::-;174:1307:16;9733:31:0;9701:63;;;;;;174:1307:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12311:1:0;174:1307:16;;;;;;;:::o;:::-;;;:::i;:::-;;;;;;;;;;:::o;11729:1022:0:-;;11892:29;;;:::i;:::-;174:1307:16;;;;;;;;;;;;11953:13:0;174:1307:16;;12538:21:0;174:1307:16;;;12054:16:0;12046:68;12054:16;;;12046:68;:::i;:::-;12251:7;;;:::i;:::-;12301:11;;;:::i;:::-;12326:34;12327:33;;174:1307:16;1478:8:12;1695:231;174:1307:16;1811:1:12;174:1307:16;12068:1:0;174:1307:16;12068:1:0;174:1307:16;;1857:12:12;174:1307:16;;12068:1:0;174:1307:16;;1887:27:12;:32;;1695:231;;12327:33:0;12326:34;;174:1307:16;12326:34:0;:86;;;11729:1022;12323:205;;11729:1022;12538:16;;;;174:1307:16;;11084:7:0;174:1307:16;;;;;;;12538:21:0;12572:27;;12569:80;;11729:1022;12664:27;12068:1;12664:27;;11729:1022::o;12569:80::-;12630:7;;174:1307:16;2388:1:12;174:1307:16;12068:1:0;174:1307:16;12068:1:0;174:1307:16;;1478:8:12;174:1307:16;;12068:1:0;174:1307:16;2434:12:12;;174:1307:16;;;2457:28:12;174:1307:16;;2292:200:12;12630:7:0;12569:80;;12323:205;12437:33;12499:17;12437:26;;;174:1307:16;;11084:7:0;174:1307:16;;;;;;;12437:33:0;174:1307:16;2388:1:12;174:1307:16;12068:1:0;174:1307:16;12068:1:0;174:1307:16;;1478:8:12;174:1307:16;;12068:1:0;174:1307:16;2434:12:12;;174:1307:16;;;2457:28:12;174:1307:16;;2292:200:12;12499:17:0;12323:205;;;;12326:86;174:1307:16;2257:13:0;174:1307:16;12378:34:0;;12326:86;;174:1307:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;12862:164:0;174:1307:16;;;12936:15:0;174:1307:16;;;;;;;;;;;;;3644:29:0;;;:::i;:::-;174:1307:16;;12980:39:0;;;;12862:164::o;:::-;174:1307:16;-1:-1:-1;174:1307:16;12936:15:0;174:1307:16;;12936:29:0;174:1307:16;;-1:-1:-1;174:1307:16;;;;;;;;;;;;12936:29:0;3644;;;:::i;:::-;-1:-1:-1;174:1307:16;;;;;;12980:39:0;-1:-1:-1;;12980:39:0;12862:164::o;174:1307:16:-;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;-1:-1:-1;174:1307:16;;;;:::o;:::-;;;:::o;13667:1013:0:-;;;;1465:19:5;;:23;13870:15:0;;13901:8;;;13905:4;13901:8;;;13927:30;;13923:677;13905:4;;;13923:677;14613:8;;;;;;;:::o;13994:9::-;13969:23;;;;;;;;:::i;:::-;13959:33;;;;;174:1307:16;;;;;;14026:72:0;;;;;;;;719:10:6;;;;;;14026:72:0;;;;;;;:::i;:::-;;174:1307:16;;;;;;;;;;14026:72:0;;;;;;;13994:9;-1:-1:-1;;14022:564:0;;14225:361;;;;;:::i;:::-;174:1307:16;;;14279:18:0;;;14325:63;174:1307:16;;;14325:63:0;;;;;;;;174:1307:16;;;;;;;;;;;;;;;;;;;;;;;14275:293:0;14443:103;;;;;14022:564;14149:56;;;;;;;;;;13994:9;14149:56;;;;;;;14022:564;14145:60;;14022:564;13994:9;:::i;:::-;13927:30;;;;;;;;14149:56;174:1307:16;;14154:51:0;;-1:-1:-1;14149:56:0;;;;14026:72;;;;;;;-1:-1:-1;14026:72:0;;;;;;;:::i;:::-;;;;;:::i;:::-;;;;;;;;;;;13959:33;;;;;;;13866:808;14652:11;;;;14659:4;14652:11;:::o;13667:1013::-;;;;1465:19:5;;:23;13870:15:0;;13901:8;;;8739:1;13901:8;;13927:30;;;13923:677;8739:1;;;14613:8;;;;;;;:::o;13994:9::-;13969:23;;;;;;;:::i;:::-;13959:33;;;;;174:1307:16;;;;;;14026:72:0;;;;;;;;719:10:6;;;;;;;14026:72:0;;;;;;;:::i;:::-;;-1:-1:-1;;;;174:1307:16;;;;;;14026:72:0;;;;;;;13994:9;-1:-1:-1;;14022:564:0;;14225:361;;;;;:::i;14022:564::-;14149:56;;;;;;;;;;13994:9;14149:56;;;;;;;14145:60;;14022:564;13994:9;:::i;:::-;13927:30;;;;;;;;;14026:72;;;;;;;-1:-1:-1;14026:72:0;;;;;;:::i;:::-;;;;;;174:1307:16;;;;;;;;;;;;;:::o;:::-;;;:::i;:::-;;;;;;;;;;;;;;1359:130:1;174:1307:16;1273:6:1;174:1307:16;;719:10:6;1422:23:1;174:1307:16;;1359:130:1:o;174:1307:16:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;:::o;415:696:8:-;537:17;-1:-1:-1;9983:8:11;;9974:17;;;;9970:103;;415:696:8;10099:8:11;;10090:17;;;;10086:103;;415:696:8;10215:8:11;;10206:17;;;;10202:103;;415:696:8;10331:7:11;;10322:16;;;;10318:100;;415:696:8;10444:7:11;;10435:16;;;;10431:100;;415:696:8;10548:16:11;10557:7;10548:16;;;10544:100;;415:696:8;10670:7:11;10661:16;;;;10657:66;;415:696:8;557:1;174:1307:16;;699:76:8;595:18;174:1307:16;;;595:18:8;:::i;:::-;627:11;699:76;;;788:280;557:1;;;788:280;1081:13;;;;415:696;:::o;788:280::-;174:1307:16;;;;893:93:8;;;;;;;;174:1307:16;1003:11:8;;1036:10;1032:21;;788:280;;;;;1032:21;1048:5;;10657:66:11;174:1307:16;10707:1:11;174:1307:16;10657:66:11;;;10544:100;174:1307:16;;10557:7:11;10628:1;174:1307:16;;;;10544:100:11;;;10431;10515:1;174:1307:16;;;;;;10431:100:11;;;;10318;10402:1;174:1307:16;;;;;;10318:100:11;;;;10202:103;10288:2;174:1307:16;;;;;;10202:103:11;;;;10086;10172:2;174:1307:16;;;;;;10086:103:11;;;;9970;10056:2;;-1:-1:-1;174:1307:16;;;-1:-1:-1;9970:103:11;;;174:1307:16;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;583:64:13;;;;174:1307:16;;583:64:13;;;;;;;;:::o;:::-;;;:::i;:::-;;;;:::o;2032:197::-;174:1307:16;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1374:6:13;;174:1307:16;;2148:60:13;;174:1307:16;583:64:13;174:1307:16;2142:67:13;174:1307:16;-1:-1:-1;174:1307:16;1422:13:13;583:64;174:1307:16;;2148:60:13;;:::i;:::-;583:64;;;;;2148:60;174:1307:16;;;;;;;;;;;;:::o;:::-;-1:-1:-1;174:1307:16;1226:14;174:1307;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;-1:-1:-1;174:1307:16;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;
Swarm Source
ipfs://77ad2cd13536305e4fb7e8a646d487bf0e676efc2e73d63010ff37dffae569e7
Loading...
Loading
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.