Contract 0xc1adec85105aa525ad1ddf3cfa7be507aed313bb 8
Contract Overview
Balance:
0.175 ETH
ETH Value:
$619.81 (@ $3,541.76/ETH)
My Name Tag:
Not Available
TokenTracker:
[ Download CSV Export ]
Latest 5 internal transactions
[ Download CSV Export ]
Contract Name:
ArbiDegenApe
Compiler Version
v0.8.4+commit.c7e474f2
Contract Source Code (Solidity)
/** *Submitted for verification at Arbiscan.io on 2021-09-19 */ /** *Submitted for verification at arbiscan.io on 2021-09-07 */ // Sources flattened with hardhat v2.6.2 https://hardhat.org // File @openzeppelin/contracts/utils/[email protected] // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; /** * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } } // File @openzeppelin/contracts/access/[email protected] pragma solidity ^0.8.0; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor() { _setOwner(_msgSender()); } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { 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 { _setOwner(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"); _setOwner(newOwner); } function _setOwner(address newOwner) private { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } } // File @openzeppelin/contracts/utils/introspection/[email protected] pragma solidity ^0.8.0; /** * @dev Interface of the ERC165 standard, as defined in the * https://eips.ethereum.org/EIPS/eip-165[EIP]. * * Implementers can declare support of contract interfaces, which can then be * queried by others ({ERC165Checker}). * * For an implementation, see {ERC165}. */ interface IERC165 { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); } // File @openzeppelin/contracts/token/ERC721/[email protected] pragma solidity ^0.8.0; /** * @dev Required interface of an ERC721 compliant contract. */ interface IERC721 is IERC165 { /** * @dev Emitted when `tokenId` token is transferred from `from` to `to`. */ event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token. */ event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets. */ event ApprovalForAll(address indexed owner, address indexed operator, bool approved); /** * @dev Returns the number of tokens in ``owner``'s account. */ function balanceOf(address owner) external view returns (uint256 balance); /** * @dev Returns the owner of the `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function ownerOf(uint256 tokenId) external view returns (address owner); /** * @dev Safely transfers `tokenId` token from `from` to `to`, 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 be 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: Usage of this method is discouraged, use {safeTransferFrom} whenever possible. * * 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 Returns the account approved for `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function getApproved(uint256 tokenId) external view returns (address operator); /** * @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 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); /** * @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; } // File @openzeppelin/contracts/token/ERC721/[email protected] 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 `IERC721.onERC721Received.selector`. */ function onERC721Received( address operator, address from, uint256 tokenId, bytes calldata data ) external returns (bytes4); } // File @openzeppelin/contracts/token/ERC721/extensions/[email protected] pragma solidity ^0.8.0; /** * @title ERC-721 Non-Fungible Token Standard, optional metadata extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721Metadata is IERC721 { /** * @dev Returns the token collection name. */ function name() external view returns (string memory); /** * @dev Returns the token collection symbol. */ function symbol() external view returns (string memory); /** * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token. */ function tokenURI(uint256 tokenId) external view returns (string memory); } // File @openzeppelin/contracts/utils/[email protected] pragma solidity ^0.8.0; /** * @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 * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; assembly { size := extcodesize(account) } return size > 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 functionCall(target, data, "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"); require(isContract(target), "Address: call to non-contract"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResult(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) { require(isContract(target), "Address: static call to non-contract"); (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResult(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) { require(isContract(target), "Address: delegate call to non-contract"); (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason 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 { // 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 assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } // File @openzeppelin/contracts/utils/[email protected] pragma solidity ^0.8.0; /** * @dev String operations. */ library Strings { bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef"; /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function toString(uint256 value) internal pure returns (string memory) { // Inspired by OraclizeAPI's implementation - MIT licence // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol if (value == 0) { return "0"; } uint256 temp = value; uint256 digits; while (temp != 0) { digits++; temp /= 10; } bytes memory buffer = new bytes(digits); while (value != 0) { digits -= 1; buffer[digits] = bytes1(uint8(48 + uint256(value % 10))); value /= 10; } return string(buffer); } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { if (value == 0) { return "0x00"; } uint256 temp = value; uint256 length = 0; while (temp != 0) { length++; temp >>= 8; } return toHexString(value, length); } /** * @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] = _HEX_SYMBOLS[value & 0xf]; value >>= 4; } require(value == 0, "Strings: hex length insufficient"); return string(buffer); } } // File @openzeppelin/contracts/utils/introspection/[email protected] pragma solidity ^0.8.0; /** * @dev Implementation of the {IERC165} interface. * * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check * for the additional interface id that will be supported. For example: * * ```solidity * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId); * } * ``` * * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation. */ abstract contract ERC165 is IERC165 { /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IERC165).interfaceId; } } // File @openzeppelin/contracts/token/ERC721/[email protected] pragma solidity ^0.8.0; /** * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including * the Metadata extension, but not including the Enumerable extension, which is available separately as * {ERC721Enumerable}. */ contract ERC721 is Context, ERC165, IERC721, IERC721Metadata { using Address for address; using Strings for uint256; // Token name string private _name; // Token symbol string private _symbol; // Mapping from token ID to owner address mapping(uint256 => address) private _owners; // Mapping owner address to token count mapping(address => uint256) private _balances; // Mapping from token ID to approved address mapping(uint256 => address) private _tokenApprovals; // Mapping from owner to operator approvals mapping(address => mapping(address => bool)) private _operatorApprovals; /** * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection. */ constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) { return interfaceId == type(IERC721).interfaceId || interfaceId == type(IERC721Metadata).interfaceId || super.supportsInterface(interfaceId); } /** * @dev See {IERC721-balanceOf}. */ function balanceOf(address owner) public view virtual override returns (uint256) { require(owner != address(0), "ERC721: balance query for the zero address"); return _balances[owner]; } /** * @dev See {IERC721-ownerOf}. */ function ownerOf(uint256 tokenId) public view virtual override returns (address) { address owner = _owners[tokenId]; require(owner != address(0), "ERC721: owner query for nonexistent token"); return owner; } /** * @dev See {IERC721Metadata-name}. */ function name() public view virtual override returns (string memory) { return _name; } /** * @dev See {IERC721Metadata-symbol}. */ function symbol() public view virtual override returns (string memory) { return _symbol; } /** * @dev See {IERC721Metadata-tokenURI}. */ function tokenURI(uint256 tokenId) public view virtual override returns (string memory) { require(_exists(tokenId), "ERC721Metadata: 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 = ERC721.ownerOf(tokenId); require(to != owner, "ERC721: approval to current owner"); require( _msgSender() == owner || isApprovedForAll(owner, _msgSender()), "ERC721: 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), "ERC721: approved query for nonexistent token"); return _tokenApprovals[tokenId]; } /** * @dev See {IERC721-setApprovalForAll}. */ function setApprovalForAll(address operator, bool approved) public virtual override { require(operator != _msgSender(), "ERC721: 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), "ERC721: 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), "ERC721: 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, _data), "ERC721: 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`), * and stop existing when they are burned (`_burn`). */ function _exists(uint256 tokenId) internal view virtual returns (bool) { return _owners[tokenId] != address(0); } /** * @dev Returns whether `spender` is allowed to manage `tokenId`. * * Requirements: * * - `tokenId` must exist. */ function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) { require(_exists(tokenId), "ERC721: operator query for nonexistent token"); address owner = ERC721.ownerOf(tokenId); return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender)); } /** * @dev Safely mints `tokenId` and transfers it to `to`. * * Requirements: * * - `tokenId` must not exist. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function _safeMint(address to, uint256 tokenId) internal virtual { _safeMint(to, tokenId, ""); } /** * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is * forwarded in {IERC721Receiver-onERC721Received} to contract recipients. */ function _safeMint( address to, uint256 tokenId, bytes memory _data ) internal virtual { _mint(to, tokenId); require( _checkOnERC721Received(address(0), to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer" ); } /** * @dev Mints `tokenId` and transfers it to `to`. * * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible * * Requirements: * * - `tokenId` must not exist. * - `to` cannot be the zero address. * * Emits a {Transfer} event. */ function _mint(address to, uint256 tokenId) internal virtual { require(to != address(0), "ERC721: mint to the zero address"); require(!_exists(tokenId), "ERC721: token already minted"); _beforeTokenTransfer(address(0), to, tokenId); _balances[to] += 1; _owners[tokenId] = to; emit Transfer(address(0), to, tokenId); } /** * @dev Destroys `tokenId`. * The approval is cleared when the token is burned. * * Requirements: * * - `tokenId` must exist. * * Emits a {Transfer} event. */ function _burn(uint256 tokenId) internal virtual { address owner = ERC721.ownerOf(tokenId); _beforeTokenTransfer(owner, address(0), tokenId); // Clear approvals _approve(address(0), tokenId); _balances[owner] -= 1; delete _owners[tokenId]; emit Transfer(owner, address(0), 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 { require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own"); require(to != address(0), "ERC721: transfer to the zero address"); _beforeTokenTransfer(from, to, tokenId); // Clear approvals from the previous owner _approve(address(0), tokenId); _balances[from] -= 1; _balances[to] += 1; _owners[tokenId] = to; emit Transfer(from, to, tokenId); } /** * @dev Approve `to` to operate on `tokenId` * * Emits a {Approval} event. */ function _approve(address to, uint256 tokenId) internal virtual { _tokenApprovals[tokenId] = to; emit Approval(ERC721.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 tokenId uint256 ID of the token to be transferred * @param _data bytes optional data to send along with the call * @return bool whether the call correctly returned the expected magic value */ function _checkOnERC721Received( address from, address to, uint256 tokenId, bytes memory _data ) private returns (bool) { if (to.isContract()) { try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) { return retval == IERC721Receiver.onERC721Received.selector; } catch (bytes memory reason) { if (reason.length == 0) { revert("ERC721: transfer to non ERC721Receiver implementer"); } else { assembly { revert(add(32, reason), mload(reason)) } } } } else { return true; } } /** * @dev Hook that is called before any token transfer. This includes minting * and burning. * * 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`. * - When `to` is zero, ``from``'s `tokenId` will be burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer( address from, address to, uint256 tokenId ) internal virtual {} } // File @openzeppelin/contracts/token/ERC721/extensions/[email protected] pragma solidity ^0.8.0; /** * @title ERC721 Burnable Token * @dev ERC721 Token that can be irreversibly burned (destroyed). */ abstract contract ERC721Burnable is Context, ERC721 { /** * @dev Burns `tokenId`. See {ERC721-_burn}. * * Requirements: * * - The caller must own `tokenId` or be an approved operator. */ function burn(uint256 tokenId) public virtual { //solhint-disable-next-line max-line-length require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721Burnable: caller is not owner nor approved"); _burn(tokenId); } } // File @openzeppelin/contracts/token/ERC721/extensions/[email protected] pragma solidity ^0.8.0; /** * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721Enumerable is IERC721 { /** * @dev Returns the total amount of tokens stored by the contract. */ function totalSupply() external view returns (uint256); /** * @dev Returns a token ID owned by `owner` at a given `index` of its token list. * Use along with {balanceOf} to enumerate all of ``owner``'s tokens. */ function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId); /** * @dev Returns a token ID at a given `index` of all the tokens stored by the contract. * Use along with {totalSupply} to enumerate all tokens. */ function tokenByIndex(uint256 index) external view returns (uint256); } // File @openzeppelin/contracts/token/ERC721/extensions/[email protected] pragma solidity ^0.8.0; /** * @dev This implements an optional extension of {ERC721} defined in the EIP that adds * enumerability of all the token ids in the contract as well as all token ids owned by each * account. */ abstract contract ERC721Enumerable is ERC721, IERC721Enumerable { // Mapping from owner to list of owned token IDs mapping(address => mapping(uint256 => uint256)) private _ownedTokens; // Mapping from token ID to index of the owner tokens list mapping(uint256 => uint256) private _ownedTokensIndex; // Array with all token ids, used for enumeration uint256[] private _allTokens; // Mapping from token id to position in the allTokens array mapping(uint256 => uint256) private _allTokensIndex; /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) { return interfaceId == type(IERC721Enumerable).interfaceId || super.supportsInterface(interfaceId); } /** * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}. */ function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) { require(index < ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds"); return _ownedTokens[owner][index]; } /** * @dev See {IERC721Enumerable-totalSupply}. */ function totalSupply() public view virtual override returns (uint256) { return _allTokens.length; } /** * @dev See {IERC721Enumerable-tokenByIndex}. */ function tokenByIndex(uint256 index) public view virtual override returns (uint256) { require(index < ERC721Enumerable.totalSupply(), "ERC721Enumerable: global index out of bounds"); return _allTokens[index]; } /** * @dev Hook that is called before any token transfer. This includes minting * and burning. * * 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`. * - When `to` is zero, ``from``'s `tokenId` will be burned. * - `from` cannot be the zero address. * - `to` cannot be the zero address. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer( address from, address to, uint256 tokenId ) internal virtual override { super._beforeTokenTransfer(from, to, tokenId); if (from == address(0)) { _addTokenToAllTokensEnumeration(tokenId); } else if (from != to) { _removeTokenFromOwnerEnumeration(from, tokenId); } if (to == address(0)) { _removeTokenFromAllTokensEnumeration(tokenId); } else if (to != from) { _addTokenToOwnerEnumeration(to, tokenId); } } /** * @dev Private function to add a token to this extension's ownership-tracking data structures. * @param to address representing the new owner of the given token ID * @param tokenId uint256 ID of the token to be added to the tokens list of the given address */ function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private { uint256 length = ERC721.balanceOf(to); _ownedTokens[to][length] = tokenId; _ownedTokensIndex[tokenId] = length; } /** * @dev Private function to add a token to this extension's token tracking data structures. * @param tokenId uint256 ID of the token to be added to the tokens list */ function _addTokenToAllTokensEnumeration(uint256 tokenId) private { _allTokensIndex[tokenId] = _allTokens.length; _allTokens.push(tokenId); } /** * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for * gas optimizations e.g. when performing a transfer operation (avoiding double writes). * This has O(1) time complexity, but alters the order of the _ownedTokens array. * @param from address representing the previous owner of the given token ID * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address */ function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private { // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and // then delete the last slot (swap and pop). uint256 lastTokenIndex = ERC721.balanceOf(from) - 1; uint256 tokenIndex = _ownedTokensIndex[tokenId]; // When the token to delete is the last token, the swap operation is unnecessary if (tokenIndex != lastTokenIndex) { uint256 lastTokenId = _ownedTokens[from][lastTokenIndex]; _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index } // This also deletes the contents at the last position of the array delete _ownedTokensIndex[tokenId]; delete _ownedTokens[from][lastTokenIndex]; } /** * @dev Private function to remove a token from this extension's token tracking data structures. * This has O(1) time complexity, but alters the order of the _allTokens array. * @param tokenId uint256 ID of the token to be removed from the tokens list */ function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private { // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and // then delete the last slot (swap and pop). uint256 lastTokenIndex = _allTokens.length - 1; uint256 tokenIndex = _allTokensIndex[tokenId]; // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding // an 'if' statement (like in _removeTokenFromOwnerEnumeration) uint256 lastTokenId = _allTokens[lastTokenIndex]; _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index // This also deletes the contents at the last position of the array delete _allTokensIndex[tokenId]; _allTokens.pop(); } } // File @openzeppelin/contracts/utils/math/[email protected] pragma solidity ^0.8.0; // CAUTION // This version of SafeMath should only be used with Solidity 0.8 or later, // because it relies on the compiler's built in overflow checks. /** * @dev Wrappers over Solidity's arithmetic operations. * * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler * now has built in overflow checking. */ library SafeMath { /** * @dev Returns the addition of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { uint256 c = a + b; if (c < a) return (false, 0); return (true, c); } } /** * @dev Returns the substraction of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b > a) return (false, 0); return (true, a - b); } } /** * @dev Returns the multiplication of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) return (true, 0); uint256 c = a * b; if (c / a != b) return (false, 0); return (true, c); } } /** * @dev Returns the division of two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a / b); } } /** * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a % b); } } /** * @dev Returns the addition of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `+` operator. * * Requirements: * * - Addition cannot overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { return a + b; } /** * @dev Returns the subtraction of two unsigned integers, reverting on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { return a - b; } /** * @dev Returns the multiplication of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `*` operator. * * Requirements: * * - Multiplication cannot overflow. */ function mul(uint256 a, uint256 b) internal pure returns (uint256) { return a * b; } /** * @dev Returns the integer division of two unsigned integers, reverting on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { return a / b; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b) internal pure returns (uint256) { return a % b; } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {trySub}. * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { unchecked { require(b <= a, errorMessage); return a - b; } } /** * @dev Returns the integer division of two unsigned integers, reverting with custom message on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { unchecked { require(b > 0, errorMessage); return a / b; } } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting with custom message when dividing by zero. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryMod}. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { unchecked { require(b > 0, errorMessage); return a % b; } } } // File @openzeppelin/contracts/security/[email protected] pragma solidity ^0.8.0; /** * @dev Contract module that helps prevent reentrant calls to a function. * * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier * available, which can be applied to functions to make sure there are no nested * (reentrant) calls to them. * * Note that because there is a single `nonReentrant` guard, functions marked as * `nonReentrant` may not call one another. This can be worked around by making * those functions `private`, and then adding `external` `nonReentrant` entry * points to them. * * TIP: If you would like to learn more about reentrancy and alternative ways * to protect against it, check out our blog post * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul]. */ abstract contract ReentrancyGuard { // Booleans are more expensive than uint256 or any type that takes up a full // word because each write operation emits an extra SLOAD to first read the // slot's contents, replace the bits taken up by the boolean, and then write // back. This is the compiler's defense against contract upgrades and // pointer aliasing, and it cannot be disabled. // The values being non-zero value makes deployment a bit more expensive, // but in exchange the refund on every call to nonReentrant will be lower in // amount. Since refunds are capped to a percentage of the total // transaction's gas, it is best to keep them low in cases like this one, to // increase the likelihood of the full refund coming into effect. uint256 private constant _NOT_ENTERED = 1; uint256 private constant _ENTERED = 2; uint256 private _status; constructor() { _status = _NOT_ENTERED; } /** * @dev Prevents a contract from calling itself, directly or indirectly. * Calling a `nonReentrant` function from another `nonReentrant` * function is not supported. It is possible to prevent this from happening * by making the `nonReentrant` function external, and make it call a * `private` function that does the actual work. */ modifier nonReentrant() { // On the first call to nonReentrant, _notEntered will be true require(_status != _ENTERED, "ReentrancyGuard: reentrant call"); // Any calls to nonReentrant after this point will fail _status = _ENTERED; _; // By storing the original value once again, a refund is triggered (see // https://eips.ethereum.org/EIPS/eip-2200) _status = _NOT_ENTERED; } } // File @openzeppelin/contracts/utils/[email protected] pragma solidity ^0.8.0; /** * @title Counters * @author Matt Condon (@shrugs) * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number * of elements in a mapping, issuing ERC721 ids, or counting request ids. * * Include with `using Counters for Counters.Counter;` */ library Counters { struct Counter { // This variable should never be directly accessed by users of the library: interactions must be restricted to // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add // this feature: see https://github.com/ethereum/solidity/issues/4637 uint256 _value; // default: 0 } function current(Counter storage counter) internal view returns (uint256) { return counter._value; } function increment(Counter storage counter) internal { unchecked { counter._value += 1; } } function decrement(Counter storage counter) internal { uint256 value = counter._value; require(value > 0, "Counter: decrement overflow"); unchecked { counter._value = value - 1; } } function reset(Counter storage counter) internal { counter._value = 0; } } // File contracts/ArbiDegenApe.sol pragma solidity >=0.7.0; contract ArbiDegenApe is Ownable, ERC721Enumerable, ERC721Burnable, ReentrancyGuard { event List(uint256 indexed tokenId, uint256 value); event Delist(uint256 indexed tokenId); using Counters for Counters.Counter; using SafeMath for uint256; Counters.Counter private _tokenIdTracker; uint256 public constant MAX_APES = 10000; uint256 public constant MINT_FEE = 0.025 ether; bool public isMarketPlaceOn = true; mapping (uint256 => uint256) public listings; // id to price //Base token URI string public base = "https://ipfs.io/ipfs/Qmaqrk31Mbi4JwZPXb7bnc9HQiMqH2NGTMUagfTsMu2nzd/"; constructor() ERC721("Arbi Degen Ape Academy", "ADAA") { reserveTokens(50); } //Overriding ERC721.sol method for use w/ tokenURI method function _baseURI() internal view override returns(string memory) { return base; } function setBaseTokenURI(string memory _baseTokenURI) public onlyOwner { base = _baseTokenURI; } function mint(uint256 _numApes) public virtual payable { uint256 nextId = _tokenIdTracker.current(); require(nextId + _numApes <= MAX_APES, "Mint amount exceeds supply"); require((msg.value >= MINT_FEE * _numApes && nextId + _numApes <= 2000) || (msg.value >= MINT_FEE * _numApes * 2), "Price not met"); for(uint i = 0; i < _numApes; i++) { _safeMint(msg.sender, _tokenIdTracker.current()); _tokenIdTracker.increment(); } } function reserveTokens(uint256 _reserveAmount) public onlyOwner { for (uint i = 0; i < _reserveAmount; i++) { _safeMint(owner(), _tokenIdTracker.current()); _tokenIdTracker.increment(); } } function withdraw() public onlyOwner { (bool success, ) = owner().call{value: address(this).balance}(""); require(success, "Transfer failed."); } function _beforeTokenTransfer( address from, address to, uint256 tokenId ) internal virtual override(ERC721, ERC721Enumerable) { super._beforeTokenTransfer(from, to, tokenId); } function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC721Enumerable) returns (bool) { return super.supportsInterface(interfaceId); } //Modifier to enable/disable marketplace functions modifier marketPlaceFunc { require(isMarketPlaceOn, "Marketplace is disabled"); _; } function toggleMarketPlace() external onlyOwner { isMarketPlaceOn = !isMarketPlaceOn; } //Credit to Ether Phrocks for marketplace functions https://etherscan.io/address/0x23fc142a6ba57a37855d9d52702fda2ec4b4fd53 function listApe(uint256 tokenId, uint256 price) public marketPlaceFunc { require(msg.sender == ownerOf(tokenId), "Must own Ape to sell"); require(price > 0); listings[tokenId] = price; emit List(tokenId, price); } function delistApe(uint256 tokenId) public { require(msg.sender == ownerOf(tokenId), "Must own Ape to delist"); listings[tokenId] = 0; emit Delist(tokenId); } function buyApe(uint256 tokenId) public payable nonReentrant marketPlaceFunc { require(listings[tokenId] > 0, "Ape must be for sale to buy"); require(msg.value >= listings[tokenId], "Must pay enough for Ape"); address oldOwner = ownerOf(tokenId); _transfer(oldOwner, msg.sender, tokenId); listings[tokenId] = 0; (bool success, ) = oldOwner.call{value: msg.value}(""); require(success); } //Delisting on transfer function transferFrom(address from, address to, uint256 tokenId) public override { if(listings[tokenId] != 0) { delistApe(tokenId); } super.transferFrom(from, to, tokenId); } function safeTransferFrom(address from,address to,uint256 tokenId) public override { if(listings[tokenId] != 0) { delistApe(tokenId); } super.safeTransferFrom(from, to, tokenId); } function safeTransferFrom(address from,address to,uint256 tokenId, bytes memory _data) public override { if(listings[tokenId] != 0) { delistApe(tokenId); } super.safeTransferFrom(from, to, tokenId, _data); } }
[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Delist","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"List","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"MAX_APES","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MINT_FEE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"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":[],"name":"base","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"buyApe","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"delistApe","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isMarketPlaceOn","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"price","type":"uint256"}],"name":"listApe","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"listings","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_numApes","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","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":"uint256","name":"_reserveAmount","type":"uint256"}],"name":"reserveTokens","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":"string","name":"_baseTokenURI","type":"string"}],"name":"setBaseTokenURI","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":[],"name":"toggleMarketPlace","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Deployed ByteCode Sourcemap
55176:4495:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57395:179;;;;;;;;;;-1:-1:-1;57395:179:0;;;;;:::i;:::-;;:::i;:::-;;;6269:14:1;;6262:22;6244:41;;6232:2;6217:18;57395:179:0;;;;;;;;24065:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;25624:221::-;;;;;;;;;;-1:-1:-1;25624:221:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;5567:32:1;;;5549:51;;5537:2;5522:18;25624:221:0;5504:102:1;25147:411:0;;;;;;;;;;-1:-1:-1;25147:411:0;;;;;:::i;:::-;;:::i;:::-;;38519:113;;;;;;;;;;-1:-1:-1;38607:10:0;:17;38519:113;;;17452:25:1;;;17440:2;17425:18;38519:113:0;17407:76:1;57753:101:0;;;;;;;;;;;;;:::i;58952:219::-;;;;;;;;;;-1:-1:-1;58952:219:0;;;;;:::i;:::-;;:::i;38187:256::-;;;;;;;;;;-1:-1:-1;38187:256:0;;;;;:::i;:::-;;:::i;56097:110::-;;;;;;;;;;-1:-1:-1;56097:110:0;;;;;:::i;:::-;;:::i;56988:168::-;;;;;;;;;;;;;:::i;59179:225::-;;;;;;;;;;-1:-1:-1;59179:225:0;;;;;:::i;:::-;;:::i;35702:245::-;;;;;;;;;;-1:-1:-1;35702:245:0;;;;;:::i;:::-;;:::i;38709:233::-;;;;;;;;;;-1:-1:-1;38709:233:0;;;;;:::i;:::-;;:::i;55731:91::-;;;;;;;;;;;;;:::i;57991:257::-;;;;;;;;;;-1:-1:-1;57991:257:0;;;;;:::i;:::-;;:::i;23759:239::-;;;;;;;;;;-1:-1:-1;23759:239:0;;;;;:::i;:::-;;:::i;55598:34::-;;;;;;;;;;-1:-1:-1;55598:34:0;;;;;;;;23489:208;;;;;;;;;;-1:-1:-1;23489:208:0;;;;;:::i;:::-;;:::i;2661:94::-;;;;;;;;;;;;;:::i;58256:192::-;;;;;;;;;;-1:-1:-1;58256:192:0;;;;;:::i;:::-;;:::i;2010:87::-;;;;;;;;;;-1:-1:-1;2056:7:0;2083:6;-1:-1:-1;;;;;2083:6:0;2010:87;;24234:104;;;;;;;;;;;;;:::i;56215:511::-;;;;;;:::i;:::-;;:::i;25917:295::-;;;;;;;;;;-1:-1:-1;25917:295:0;;;;;:::i;:::-;;:::i;58456:459::-;;;;;;:::i;:::-;;:::i;59412:252::-;;;;;;;;;;-1:-1:-1;59412:252:0;;;;;:::i;:::-;;:::i;55496:40::-;;;;;;;;;;;;55531:5;55496:40;;24409:334;;;;;;;;;;-1:-1:-1;24409:334:0;;;;;:::i;:::-;;:::i;56734:246::-;;;;;;;;;;-1:-1:-1;56734:246:0;;;;;:::i;:::-;;:::i;55543:46::-;;;;;;;;;;;;55578:11;55543:46;;55641:44;;;;;;;;;;-1:-1:-1;55641:44:0;;;;;:::i;:::-;;;;;;;;;;;;;;26283:164;;;;;;;;;;-1:-1:-1;26283:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;26404:25:0;;;26380:4;26404:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;26283:164;2910:192;;;;;;;;;;-1:-1:-1;2910:192:0;;;;;:::i;:::-;;:::i;57395:179::-;57506:4;57530:36;57554:11;57530:23;:36::i;:::-;57523:43;57395:179;-1:-1:-1;;57395:179:0:o;24065:100::-;24119:13;24152:5;24145:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24065:100;:::o;25624:221::-;25700:7;29107:16;;;:7;:16;;;;;;-1:-1:-1;;;;;29107:16:0;25720:73;;;;-1:-1:-1;;;25720:73:0;;11797:2:1;25720:73:0;;;11779:21:1;11836:2;11816:18;;;11809:30;11875:34;11855:18;;;11848:62;-1:-1:-1;;;11926:18:1;;;11919:42;11978:19;;25720:73:0;;;;;;;;;-1:-1:-1;25813:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;25813:24:0;;25624:221::o;25147:411::-;25228:13;25244:23;25259:7;25244:14;:23::i;:::-;25228:39;;25292:5;-1:-1:-1;;;;;25286:11:0;:2;-1:-1:-1;;;;;25286:11:0;;;25278:57;;;;-1:-1:-1;;;25278:57:0;;14446:2:1;25278:57:0;;;14428:21:1;14485:2;14465:18;;;14458:30;14524:34;14504:18;;;14497:62;-1:-1:-1;;;14575:18:1;;;14568:31;14616:19;;25278:57:0;14418:223:1;25278:57:0;876:10;-1:-1:-1;;;;;25370:21:0;;;;:62;;-1:-1:-1;25395:37:0;25412:5;876:10;26283:164;:::i;25395:37::-;25348:168;;;;-1:-1:-1;;;25348:168:0;;10190:2:1;25348:168:0;;;10172:21:1;10229:2;10209:18;;;10202:30;10268:34;10248:18;;;10241:62;10339:26;10319:18;;;10312:54;10383:19;;25348:168:0;10162:246:1;25348:168:0;25529:21;25538:2;25542:7;25529:8;:21::i;:::-;25147:411;;;:::o;57753:101::-;2056:7;2083:6;-1:-1:-1;;;;;2083:6:0;876:10;2230:23;2222:68;;;;-1:-1:-1;;;2222:68:0;;;;;;;:::i;:::-;57831:15:::1;::::0;;-1:-1:-1;;57812:34:0;::::1;57831:15;::::0;;::::1;57830:16;57812:34;::::0;;57753:101::o;58952:219::-;59047:17;;;;:8;:17;;;;;;:22;59044:72;;59086:18;59096:7;59086:9;:18::i;:::-;59126:37;59145:4;59151:2;59155:7;59126:18;:37::i;38187:256::-;38284:7;38320:23;38337:5;38320:16;:23::i;:::-;38312:5;:31;38304:87;;;;-1:-1:-1;;;38304:87:0;;6722:2:1;38304:87:0;;;6704:21:1;6761:2;6741:18;;;6734:30;6800:34;6780:18;;;6773:62;-1:-1:-1;;;6851:18:1;;;6844:41;6902:19;;38304:87:0;6694:233:1;38304:87:0;-1:-1:-1;;;;;;38409:19:0;;;;;;;;:12;:19;;;;;;;;:26;;;;;;;;;38187:256::o;56097:110::-;2056:7;2083:6;-1:-1:-1;;;;;2083:6:0;876:10;2230:23;2222:68;;;;-1:-1:-1;;;2222:68:0;;;;;;;:::i;:::-;56179:20;;::::1;::::0;:4:::1;::::0;:20:::1;::::0;::::1;::::0;::::1;:::i;:::-;;56097:110:::0;:::o;56988:168::-;2056:7;2083:6;-1:-1:-1;;;;;2083:6:0;876:10;2230:23;2222:68;;;;-1:-1:-1;;;2222:68:0;;;;;;;:::i;:::-;57037:12:::1;2083:6:::0;;57055:46:::1;::::0;-1:-1:-1;;;;;2083:6:0;;;;57075:21:::1;::::0;57037:12;57055:46;57037:12;57055:46;57075:21;2083:6;57055:46:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57036:65;;;57120:7;57112:36;;;::::0;-1:-1:-1;;;57112:36:0;;15200:2:1;57112:36:0::1;::::0;::::1;15182:21:1::0;15239:2;15219:18;;;15212:30;-1:-1:-1;;;15258:18:1;;;15251:46;15314:18;;57112:36:0::1;15172:166:1::0;57112:36:0::1;2301:1;56988:168::o:0;59179:225::-;59276:17;;;;:8;:17;;;;;;:22;59273:72;;59315:18;59325:7;59315:9;:18::i;:::-;59355:41;59378:4;59384:2;59388:7;59355:22;:41::i;35702:245::-;35820:41;876:10;35839:12;35853:7;35820:18;:41::i;:::-;35812:102;;;;-1:-1:-1;;;35812:102:0;;17091:2:1;35812:102:0;;;17073:21:1;17130:2;17110:18;;;17103:30;17169:34;17149:18;;;17142:62;-1:-1:-1;;;17220:18:1;;;17213:46;17276:19;;35812:102:0;17063:238:1;35812:102:0;35925:14;35931:7;35925:5;:14::i;38709:233::-;38784:7;38820:30;38607:10;:17;;38519:113;38820:30;38812:5;:38;38804:95;;;;-1:-1:-1;;;38804:95:0;;15963:2:1;38804:95:0;;;15945:21:1;16002:2;15982:18;;;15975:30;16041:34;16021:18;;;16014:62;-1:-1:-1;;;16092:18:1;;;16085:42;16144:19;;38804:95:0;15935:234:1;38804:95:0;38917:10;38928:5;38917:17;;;;;;-1:-1:-1;;;38917:17:0;;;;;;;;;;;;;;;;;38910:24;;38709:233;;;:::o;55731:91::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;57991:257::-;57682:15;;;;57674:51;;;;-1:-1:-1;;;57674:51:0;;14848:2:1;57674:51:0;;;14830:21:1;14887:2;14867:18;;;14860:30;-1:-1:-1;;;14906:18:1;;;14899:53;14969:18;;57674:51:0;14820:173:1;57674:51:0;58096:16:::1;58104:7;58096;:16::i;:::-;-1:-1:-1::0;;;;;58082:30:0::1;:10;-1:-1:-1::0;;;;;58082:30:0::1;;58074:63;;;::::0;-1:-1:-1;;;58074:63:0;;9841:2:1;58074:63:0::1;::::0;::::1;9823:21:1::0;9880:2;9860:18;;;9853:30;-1:-1:-1;;;9899:18:1;;;9892:50;9959:18;;58074:63:0::1;9813:170:1::0;58074:63:0::1;58164:1;58156:5;:9;58148:18;;;::::0;::::1;;58179:17;::::0;;;:8:::1;:17;::::0;;;;;;:25;;;58220:20;58188:7;;58220:20:::1;::::0;::::1;::::0;58199:5;17452:25:1;;17440:2;17425:18;;17407:76;58220:20:0::1;;;;;;;;57991:257:::0;;:::o;23759:239::-;23831:7;23867:16;;;:7;:16;;;;;;-1:-1:-1;;;;;23867:16:0;23902:19;23894:73;;;;-1:-1:-1;;;23894:73:0;;11026:2:1;23894:73:0;;;11008:21:1;11065:2;11045:18;;;11038:30;11104:34;11084:18;;;11077:62;-1:-1:-1;;;11155:18:1;;;11148:39;11204:19;;23894:73:0;10998:231:1;23489:208:0;23561:7;-1:-1:-1;;;;;23589:19:0;;23581:74;;;;-1:-1:-1;;;23581:74:0;;10615:2:1;23581:74:0;;;10597:21:1;10654:2;10634:18;;;10627:30;10693:34;10673:18;;;10666:62;-1:-1:-1;;;10744:18:1;;;10737:40;10794:19;;23581:74:0;10587:232:1;23581:74:0;-1:-1:-1;;;;;;23673:16:0;;;;;:9;:16;;;;;;;23489:208::o;2661:94::-;2056:7;2083:6;-1:-1:-1;;;;;2083:6:0;876:10;2230:23;2222:68;;;;-1:-1:-1;;;2222:68:0;;;;;;;:::i;:::-;2726:21:::1;2744:1;2726:9;:21::i;:::-;2661:94::o:0;58256:192::-;58332:16;58340:7;58332;:16::i;:::-;-1:-1:-1;;;;;58318:30:0;:10;-1:-1:-1;;;;;58318:30:0;;58310:65;;;;-1:-1:-1;;;58310:65:0;;13739:2:1;58310:65:0;;;13721:21:1;13778:2;13758:18;;;13751:30;-1:-1:-1;;;13797:18:1;;;13790:52;13859:18;;58310:65:0;13711:172:1;58310:65:0;58408:1;58388:17;;;:8;:17;;;;;;:21;;;58425:15;58397:7;;58425:15;;;58256:192;:::o;24234:104::-;24290:13;24323:7;24316:14;;;;;:::i;56215:511::-;56281:14;56298:25;:15;54597:14;;54505:114;56298:25;56281:42;-1:-1:-1;55531:5:0;56342:17;56351:8;56281:42;56342:17;:::i;:::-;:29;;56334:68;;;;-1:-1:-1;;;56334:68:0;;16376:2:1;56334:68:0;;;16358:21:1;16415:2;16395:18;;;16388:30;16454:28;16434:18;;;16427:56;16500:18;;56334:68:0;16348:176:1;56334:68:0;56435:19;56446:8;55578:11;56435:19;:::i;:::-;56422:9;:32;;:61;;;;-1:-1:-1;56479:4:0;56458:17;56467:8;56458:6;:17;:::i;:::-;:25;;56422:61;56421:105;;;-1:-1:-1;56502:19:0;56513:8;55578:11;56502:19;:::i;:::-;:23;;56524:1;56502:23;:::i;:::-;56489:9;:36;;56421:105;56413:131;;;;-1:-1:-1;;;56413:131:0;;12571:2:1;56413:131:0;;;12553:21:1;12610:2;12590:18;;;12583:30;-1:-1:-1;;;12629:18:1;;;12622:43;12682:18;;56413:131:0;12543:163:1;56413:131:0;56561:6;56557:152;56577:8;56573:1;:12;56557:152;;;56607:48;56617:10;56629:25;:15;54597:14;;54505:114;56629:25;56607:9;:48::i;:::-;56670:27;:15;54716:19;;54734:1;54716:19;;;54627:127;56670:27;56587:3;;;;:::i;:::-;;;;56557:152;;25917:295;-1:-1:-1;;;;;26020:24:0;;876:10;26020:24;;26012:62;;;;-1:-1:-1;;;26012:62:0;;8722:2:1;26012:62:0;;;8704:21:1;8761:2;8741:18;;;8734:30;8800:27;8780:18;;;8773:55;8845:18;;26012:62:0;8694:175:1;26012:62:0;876:10;26087:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;26087:42:0;;;;;;;;;;;;:53;;-1:-1:-1;;26087:53:0;;;;;;;;;;26156:48;;6244:41:1;;;26087:42:0;;876:10;26156:48;;6217:18:1;26156:48:0;;;;;;;25917:295;;:::o;58456:459::-;52739:1;53335:7;;:19;;53327:63;;;;-1:-1:-1;;;53327:63:0;;16731:2:1;53327:63:0;;;16713:21:1;16770:2;16750:18;;;16743:30;16809:33;16789:18;;;16782:61;16860:18;;53327:63:0;16703:181:1;53327:63:0;52739:1;53468:7;:18;57682:15:::1;::::0;::::1;;57674:51;;;::::0;-1:-1:-1;;;57674:51:0;;14848:2:1;57674:51:0::1;::::0;::::1;14830:21:1::0;14887:2;14867:18;;;14860:30;-1:-1:-1;;;14906:18:1;;;14899:53;14969:18;;57674:51:0::1;14820:173:1::0;57674:51:0::1;58572:1:::2;58552:17:::0;;;:8:::2;:17;::::0;;;;;58544:61:::2;;;::::0;-1:-1:-1;;;58544:61:0;;14090:2:1;58544:61:0::2;::::0;::::2;14072:21:1::0;14129:2;14109:18;;;14102:30;14168:29;14148:18;;;14141:57;14215:18;;58544:61:0::2;14062:177:1::0;58544:61:0::2;58637:17;::::0;;;:8:::2;:17;::::0;;;;;58624:9:::2;:30;;58616:66;;;::::0;-1:-1:-1;;;58616:66:0;;9489:2:1;58616:66:0::2;::::0;::::2;9471:21:1::0;9528:2;9508:18;;;9501:30;9567:25;9547:18;;;9540:53;9610:18;;58616:66:0::2;9461:173:1::0;58616:66:0::2;58695:16;58714;58722:7;58714;:16::i;:::-;58695:35;;58741:40;58751:8;58761:10;58773:7;58741:9;:40::i;:::-;58812:1;58792:17:::0;;;:8:::2;:17;::::0;;;;;:21;;;58845:35;-1:-1:-1;;;;;58845:13:0;::::2;::::0;58866:9:::2;::::0;58812:1;58845:35;58812:1;58845:35;58866:9;58845:13;:35:::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58826:54;;;58899:7;58891:16;;;::::0;::::2;;-1:-1:-1::0;;52695:1:0;53647:7;:22;-1:-1:-1;58456:459:0:o;59412:252::-;59529:17;;;;:8;:17;;;;;;:22;59526:72;;59568:18;59578:7;59568:9;:18::i;:::-;59608:48;59631:4;59637:2;59641:7;59650:5;59608:22;:48::i;:::-;59412:252;;;;:::o;24409:334::-;29083:4;29107:16;;;:7;:16;;;;;;24482:13;;-1:-1:-1;;;;;29107:16:0;24508:76;;;;-1:-1:-1;;;24508:76:0;;13323:2:1;24508:76:0;;;13305:21:1;13362:2;13342:18;;;13335:30;13401:34;13381:18;;;13374:62;-1:-1:-1;;;13452:18:1;;;13445:45;13507:19;;24508:76:0;13295:237:1;24508:76:0;24597:21;24621:10;:8;:10::i;:::-;24597:34;;24673:1;24655:7;24649:21;:25;:86;;;;;;;;;;;;;;;;;24701:7;24710:18;:7;:16;:18::i;:::-;24684:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;24649:86;24642:93;24409:334;-1:-1:-1;;;24409:334:0:o;56734:246::-;2056:7;2083:6;-1:-1:-1;;;;;2083:6:0;876:10;2230:23;2222:68;;;;-1:-1:-1;;;2222:68:0;;;;;;;:::i;:::-;56822:6:::1;56817:156;56838:14;56834:1;:18;56817:156;;;56874:45;56884:7;2056::::0;2083:6;-1:-1:-1;;;;;2083:6:0;;2010:87;56884:7:::1;56893:15;54597:14:::0;56607:9;:48::i;56874:45::-:1;56934:27;:15;54716:19:::0;;54734:1;54716:19;;;54627:127;56934:27:::1;56854:3:::0;::::1;::::0;::::1;:::i;:::-;;;;56817:156;;2910:192:::0;2056:7;2083:6;-1:-1:-1;;;;;2083:6:0;876:10;2230:23;2222:68;;;;-1:-1:-1;;;2222:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;2999:22:0;::::1;2991:73;;;::::0;-1:-1:-1;;;2991:73:0;;7553:2:1;2991:73:0::1;::::0;::::1;7535:21:1::0;7592:2;7572:18;;;7565:30;7631:34;7611:18;;;7604:62;-1:-1:-1;;;7682:18:1;;;7675:36;7728:19;;2991:73:0::1;7525:228:1::0;2991:73:0::1;3075:19;3085:8;3075:9;:19::i;54505:114::-:0;54597:14;;54505:114::o;54627:127::-;54716:19;;54734:1;54716:19;;;54627:127::o;11417:387::-;11740:20;11788:8;;;11417:387::o;39555:589::-;-1:-1:-1;;;;;39761:18:0;;39757:187;;39796:40;39828:7;40971:10;:17;;40944:24;;;;:15;:24;;;;;:44;;;40999:24;;;;;;;;;;;;40867:164;39796:40;39757:187;;;39866:2;-1:-1:-1;;;;;39858:10:0;:4;-1:-1:-1;;;;;39858:10:0;;39854:90;;39885:47;39918:4;39924:7;39885:32;:47::i;:::-;-1:-1:-1;;;;;39958:16:0;;39954:183;;39991:45;40028:7;39991:36;:45::i;39954:183::-;40064:4;-1:-1:-1;;;;;40058:10:0;:2;-1:-1:-1;;;;;40058:10:0;;40054:83;;40085:40;40113:2;40117:7;40085:27;:40::i;37879:224::-;37981:4;-1:-1:-1;;;;;;38005:50:0;;-1:-1:-1;;;38005:50:0;;:90;;;38059:36;38083:11;38059:23;:36::i;33000:174::-;33075:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;33075:29:0;-1:-1:-1;;;;;33075:29:0;;;;;;;;:24;;33129:23;33075:24;33129:14;:23::i;:::-;-1:-1:-1;;;;;33120:46:0;;;;;;;;;;;33000:174;;:::o;26514:339::-;26709:41;876:10;26728:12;796:98;26709:41;26701:103;;;;-1:-1:-1;;;26701:103:0;;;;;;;:::i;:::-;26817:28;26827:4;26833:2;26837:7;26817:9;:28::i;26924:185::-;27062:39;27079:4;27085:2;27089:7;27062:39;;;;;;;;;;;;:16;:39::i;29312:348::-;29405:4;29107:16;;;:7;:16;;;;;;-1:-1:-1;;;;;29107:16:0;29422:73;;;;-1:-1:-1;;;29422:73:0;;9076:2:1;29422:73:0;;;9058:21:1;9115:2;9095:18;;;9088:30;9154:34;9134:18;;;9127:62;-1:-1:-1;;;9205:18:1;;;9198:42;9257:19;;29422:73:0;9048:234:1;29422:73:0;29506:13;29522:23;29537:7;29522:14;:23::i;:::-;29506:39;;29575:5;-1:-1:-1;;;;;29564:16:0;:7;-1:-1:-1;;;;;29564:16:0;;:51;;;;29608:7;-1:-1:-1;;;;;29584:31:0;:20;29596:7;29584:11;:20::i;:::-;-1:-1:-1;;;;;29584:31:0;;29564:51;:87;;;-1:-1:-1;;;;;;26404:25:0;;;26380:4;26404:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;29619:32;29556:96;29312:348;-1:-1:-1;;;;29312:348:0:o;31607:360::-;31667:13;31683:23;31698:7;31683:14;:23::i;:::-;31667:39;;31719:48;31740:5;31755:1;31759:7;31719:20;:48::i;:::-;31808:29;31825:1;31829:7;31808:8;:29::i;:::-;-1:-1:-1;;;;;31850:16:0;;;;;;:9;:16;;;;;:21;;31870:1;;31850:16;:21;;31870:1;;31850:21;:::i;:::-;;;;-1:-1:-1;;31889:16:0;;;;:7;:16;;;;;;31882:23;;-1:-1:-1;;;;;;31882:23:0;;;31923:36;31897:7;;31889:16;-1:-1:-1;;;;;31923:36:0;;;;;31889:16;;31923:36;31607:360;;:::o;3110:173::-;3166:16;3185:6;;-1:-1:-1;;;;;3202:17:0;;;-1:-1:-1;;;;;;3202:17:0;;;;;;3235:40;;3185:6;;;;;;;3235:40;;3166:16;3235:40;3110:173;;:::o;30002:110::-;30078:26;30088:2;30092:7;30078:26;;;;;;;;;;;;:9;:26::i;32304:578::-;32463:4;-1:-1:-1;;;;;32436:31:0;:23;32451:7;32436:14;:23::i;:::-;-1:-1:-1;;;;;32436:31:0;;32428:85;;;;-1:-1:-1;;;32428:85:0;;12913:2:1;32428:85:0;;;12895:21:1;12952:2;12932:18;;;12925:30;12991:34;12971:18;;;12964:62;-1:-1:-1;;;13042:18:1;;;13035:39;13091:19;;32428:85:0;12885:231:1;32428:85:0;-1:-1:-1;;;;;32532:16:0;;32524:65;;;;-1:-1:-1;;;32524:65:0;;8317:2:1;32524:65:0;;;8299:21:1;8356:2;8336:18;;;8329:30;8395:34;8375:18;;;8368:62;-1:-1:-1;;;8446:18:1;;;8439:34;8490:19;;32524:65:0;8289:226:1;32524:65:0;32602:39;32623:4;32629:2;32633:7;32602:20;:39::i;:::-;32706:29;32723:1;32727:7;32706:8;:29::i;:::-;-1:-1:-1;;;;;32748:15:0;;;;;;:9;:15;;;;;:20;;32767:1;;32748:15;:20;;32767:1;;32748:20;:::i;:::-;;;;-1:-1:-1;;;;;;;32779:13:0;;;;;;:9;:13;;;;;:18;;32796:1;;32779:13;:18;;32796:1;;32779:18;:::i;:::-;;;;-1:-1:-1;;32808:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;32808:21:0;-1:-1:-1;;;;;32808:21:0;;;;;;;;;32847:27;;32808:16;;32847:27;;;;;;;32304:578;;;:::o;27180:328::-;27355:41;876:10;27388:7;27355:18;:41::i;:::-;27347:103;;;;-1:-1:-1;;;27347:103:0;;;;;;;:::i;:::-;27461:39;27475:4;27481:2;27485:7;27494:5;27461:13;:39::i;55993:96::-;56044:13;56077:4;56070:11;;;;;:::i;19063:723::-;19119:13;19340:10;19336:53;;-1:-1:-1;;19367:10:0;;;;;;;;;;;;-1:-1:-1;;;19367:10:0;;;;;19063:723::o;19336:53::-;19414:5;19399:12;19455:78;19462:9;;19455:78;;19488:8;;;;:::i;:::-;;-1:-1:-1;19511:10:0;;-1:-1:-1;19519:2:0;19511:10;;:::i;:::-;;;19455:78;;;19543:19;19575:6;19565:17;;;;;;-1:-1:-1;;;19565:17:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;19565:17:0;;19543:39;;19593:154;19600:10;;19593:154;;19627:11;19637:1;19627:11;;:::i;:::-;;-1:-1:-1;19696:10:0;19704:2;19696:5;:10;:::i;:::-;19683:24;;:2;:24;:::i;:::-;19670:39;;19653:6;19660;19653:14;;;;;;-1:-1:-1;;;19653:14:0;;;;;;;;;;;;:56;-1:-1:-1;;;;;19653:56:0;;;;;;;;-1:-1:-1;19724:11:0;19733:2;19724:11;;:::i;:::-;;;19593:154;;41658:988;41924:22;41974:1;41949:22;41966:4;41949:16;:22::i;:::-;:26;;;;:::i;:::-;41986:18;42007:26;;;:17;:26;;;;;;41924:51;;-1:-1:-1;42140:28:0;;;42136:328;;-1:-1:-1;;;;;42207:18:0;;42185:19;42207:18;;;:12;:18;;;;;;;;:34;;;;;;;;;42258:30;;;;;;:44;;;42375:30;;:17;:30;;;;;:43;;;42136:328;-1:-1:-1;42560:26:0;;;;:17;:26;;;;;;;;42553:33;;;-1:-1:-1;;;;;42604:18:0;;;;;:12;:18;;;;;:34;;;;;;;42597:41;41658:988::o;42941:1079::-;43219:10;:17;43194:22;;43219:21;;43239:1;;43219:21;:::i;:::-;43251:18;43272:24;;;:15;:24;;;;;;43645:10;:26;;43194:46;;-1:-1:-1;43272:24:0;;43194:46;;43645:26;;;;-1:-1:-1;;;43645:26:0;;;;;;;;;;;;;;;;;43623:48;;43709:11;43684:10;43695;43684:22;;;;;;-1:-1:-1;;;43684:22:0;;;;;;;;;;;;;;;;;;;;:36;;;;43789:28;;;:15;:28;;;;;;;:41;;;43961:24;;;;;43954:31;43996:10;:16;;;;;-1:-1:-1;;;43996:16:0;;;;;;;;;;;;;;;;;;;;;;;;;;42941:1079;;;;:::o;40445:221::-;40530:14;40547:20;40564:2;40547:16;:20::i;:::-;-1:-1:-1;;;;;40578:16:0;;;;;;;:12;:16;;;;;;;;:24;;;;;;;;:34;;;40623:26;;;:17;:26;;;;;;:35;;;;-1:-1:-1;40445:221:0:o;23120:305::-;23222:4;-1:-1:-1;;;;;;23259:40:0;;-1:-1:-1;;;23259:40:0;;:105;;-1:-1:-1;;;;;;;23316:48:0;;-1:-1:-1;;;23316:48:0;23259:105;:158;;;-1:-1:-1;;;;;;;;;;21731:40:0;;;23381:36;21622:157;57164:223;57334:45;57361:4;57367:2;57371:7;57334:26;:45::i;30339:321::-;30469:18;30475:2;30479:7;30469:5;:18::i;:::-;30520:54;30551:1;30555:2;30559:7;30568:5;30520:22;:54::i;:::-;30498:154;;;;-1:-1:-1;;;30498:154:0;;;;;;;:::i;28390:315::-;28547:28;28557:4;28563:2;28567:7;28547:9;:28::i;:::-;28594:48;28617:4;28623:2;28627:7;28636:5;28594:22;:48::i;:::-;28586:111;;;;-1:-1:-1;;;28586:111:0;;;;;;;:::i;30996:382::-;-1:-1:-1;;;;;31076:16:0;;31068:61;;;;-1:-1:-1;;;31068:61:0;;11436:2:1;31068:61:0;;;11418:21:1;;;11455:18;;;11448:30;11514:34;11494:18;;;11487:62;11566:18;;31068:61:0;11408:182:1;31068:61:0;29083:4;29107:16;;;:7;:16;;;;;;-1:-1:-1;;;;;29107:16:0;:30;31140:58;;;;-1:-1:-1;;;31140:58:0;;7960:2:1;31140:58:0;;;7942:21:1;7999:2;7979:18;;;7972:30;8038;8018:18;;;8011:58;8086:18;;31140:58:0;7932:178:1;31140:58:0;31211:45;31240:1;31244:2;31248:7;31211:20;:45::i;:::-;-1:-1:-1;;;;;31269:13:0;;;;;;:9;:13;;;;;:18;;31286:1;;31269:13;:18;;31286:1;;31269:18;:::i;:::-;;;;-1:-1:-1;;31298:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;31298:21:0;-1:-1:-1;;;;;31298:21:0;;;;;;;;31337:33;;31298:16;;;31337:33;;31298:16;;31337:33;30996:382;;:::o;33739:799::-;33894:4;-1:-1:-1;;;;;33915:13:0;;11740:20;11788:8;33911:620;;33951:72;;-1:-1:-1;;;33951:72:0;;-1:-1:-1;;;;;33951:36:0;;;;;:72;;876:10;;34002:4;;34008:7;;34017:5;;33951:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;33951:72:0;;;;;;;;-1:-1:-1;;33951:72:0;;;;;;;;;;;;:::i;:::-;;;33947:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;34193:13:0;;34189:272;;34236:60;;-1:-1:-1;;;34236:60:0;;;;;;;:::i;34189:272::-;34411:6;34405:13;34396:6;34392:2;34388:15;34381:38;33947:529;-1:-1:-1;;;;;;34074:51:0;-1:-1:-1;;;34074:51:0;;-1:-1:-1;34067:58:0;;33911:620;-1:-1:-1;34515:4:0;33739:799;;;;;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:631:1;78:5;108:18;149:2;141:6;138:14;135:2;;;155:18;;:::i;:::-;230:2;224:9;198:2;284:15;;-1:-1:-1;;280:24:1;;;306:2;276:33;272:42;260:55;;;330:18;;;350:22;;;327:46;324:2;;;376:18;;:::i;:::-;416:10;412:2;405:22;445:6;436:15;;475:6;467;460:22;515:3;506:6;501:3;497:16;494:25;491:2;;;532:1;529;522:12;491:2;582:6;577:3;570:4;562:6;558:17;545:44;637:1;630:4;621:6;613;609:19;605:30;598:41;;;;88:557;;;;;:::o;650:173::-;718:20;;-1:-1:-1;;;;;767:31:1;;757:42;;747:2;;813:1;810;803:12;747:2;699:124;;;:::o;828:196::-;887:6;940:2;928:9;919:7;915:23;911:32;908:2;;;961:6;953;946:22;908:2;989:29;1008:9;989:29;:::i;1029:270::-;1097:6;1105;1158:2;1146:9;1137:7;1133:23;1129:32;1126:2;;;1179:6;1171;1164:22;1126:2;1207:29;1226:9;1207:29;:::i;:::-;1197:39;;1255:38;1289:2;1278:9;1274:18;1255:38;:::i;:::-;1245:48;;1116:183;;;;;:::o;1304:338::-;1381:6;1389;1397;1450:2;1438:9;1429:7;1425:23;1421:32;1418:2;;;1471:6;1463;1456:22;1418:2;1499:29;1518:9;1499:29;:::i;:::-;1489:39;;1547:38;1581:2;1570:9;1566:18;1547:38;:::i;:::-;1537:48;;1632:2;1621:9;1617:18;1604:32;1594:42;;1408:234;;;;;:::o;1647:696::-;1742:6;1750;1758;1766;1819:3;1807:9;1798:7;1794:23;1790:33;1787:2;;;1841:6;1833;1826:22;1787:2;1869:29;1888:9;1869:29;:::i;:::-;1859:39;;1917:38;1951:2;1940:9;1936:18;1917:38;:::i;:::-;1907:48;;2002:2;1991:9;1987:18;1974:32;1964:42;;2057:2;2046:9;2042:18;2029:32;2084:18;2076:6;2073:30;2070:2;;;2121:6;2113;2106:22;2070:2;2149:22;;2202:4;2194:13;;2190:27;-1:-1:-1;2180:2:1;;2236:6;2228;2221:22;2180:2;2264:73;2329:7;2324:2;2311:16;2306:2;2302;2298:11;2264:73;:::i;:::-;2254:83;;;1777:566;;;;;;;:::o;2348:367::-;2413:6;2421;2474:2;2462:9;2453:7;2449:23;2445:32;2442:2;;;2495:6;2487;2480:22;2442:2;2523:29;2542:9;2523:29;:::i;:::-;2513:39;;2602:2;2591:9;2587:18;2574:32;2649:5;2642:13;2635:21;2628:5;2625:32;2615:2;;2676:6;2668;2661:22;2615:2;2704:5;2694:15;;;2432:283;;;;;:::o;2720:264::-;2788:6;2796;2849:2;2837:9;2828:7;2824:23;2820:32;2817:2;;;2870:6;2862;2855:22;2817:2;2898:29;2917:9;2898:29;:::i;:::-;2888:39;2974:2;2959:18;;;;2946:32;;-1:-1:-1;;;2807:177:1:o;2989:255::-;3047:6;3100:2;3088:9;3079:7;3075:23;3071:32;3068:2;;;3121:6;3113;3106:22;3068:2;3165:9;3152:23;3184:30;3208:5;3184:30;:::i;3249:259::-;3318:6;3371:2;3359:9;3350:7;3346:23;3342:32;3339:2;;;3392:6;3384;3377:22;3339:2;3429:9;3423:16;3448:30;3472:5;3448:30;:::i;3513:480::-;3582:6;3635:2;3623:9;3614:7;3610:23;3606:32;3603:2;;;3656:6;3648;3641:22;3603:2;3701:9;3688:23;3734:18;3726:6;3723:30;3720:2;;;3771:6;3763;3756:22;3720:2;3799:22;;3852:4;3844:13;;3840:27;-1:-1:-1;3830:2:1;;3886:6;3878;3871:22;3830:2;3914:73;3979:7;3974:2;3961:16;3956:2;3952;3948:11;3914:73;:::i;3998:190::-;4057:6;4110:2;4098:9;4089:7;4085:23;4081:32;4078:2;;;4131:6;4123;4116:22;4078:2;-1:-1:-1;4159:23:1;;4068:120;-1:-1:-1;4068:120:1:o;4193:258::-;4261:6;4269;4322:2;4310:9;4301:7;4297:23;4293:32;4290:2;;;4343:6;4335;4328:22;4290:2;-1:-1:-1;;4371:23:1;;;4441:2;4426:18;;;4413:32;;-1:-1:-1;4280:171:1:o;4456:257::-;4497:3;4535:5;4529:12;4562:6;4557:3;4550:19;4578:63;4634:6;4627:4;4622:3;4618:14;4611:4;4604:5;4600:16;4578:63;:::i;:::-;4695:2;4674:15;-1:-1:-1;;4670:29:1;4661:39;;;;4702:4;4657:50;;4505:208;-1:-1:-1;;4505:208:1:o;4718:470::-;4897:3;4935:6;4929:13;4951:53;4997:6;4992:3;4985:4;4977:6;4973:17;4951:53;:::i;:::-;5067:13;;5026:16;;;;5089:57;5067:13;5026:16;5123:4;5111:17;;5089:57;:::i;:::-;5162:20;;4905:283;-1:-1:-1;;;;4905:283:1:o;5611:488::-;-1:-1:-1;;;;;5880:15:1;;;5862:34;;5932:15;;5927:2;5912:18;;5905:43;5979:2;5964:18;;5957:34;;;6027:3;6022:2;6007:18;;6000:31;;;5805:4;;6048:45;;6073:19;;6065:6;6048:45;:::i;:::-;6040:53;5814:285;-1:-1:-1;;;;;;5814:285:1:o;6296:219::-;6445:2;6434:9;6427:21;6408:4;6465:44;6505:2;6494:9;6490:18;6482:6;6465:44;:::i;6932:414::-;7134:2;7116:21;;;7173:2;7153:18;;;7146:30;7212:34;7207:2;7192:18;;7185:62;-1:-1:-1;;;7278:2:1;7263:18;;7256:48;7336:3;7321:19;;7106:240::o;12008:356::-;12210:2;12192:21;;;12229:18;;;12222:30;12288:34;12283:2;12268:18;;12261:62;12355:2;12340:18;;12182:182::o;15343:413::-;15545:2;15527:21;;;15584:2;15564:18;;;15557:30;15623:34;15618:2;15603:18;;15596:62;-1:-1:-1;;;15689:2:1;15674:18;;15667:47;15746:3;15731:19;;15517:239::o;17488:128::-;17528:3;17559:1;17555:6;17552:1;17549:13;17546:2;;;17565:18;;:::i;:::-;-1:-1:-1;17601:9:1;;17536:80::o;17621:120::-;17661:1;17687;17677:2;;17692:18;;:::i;:::-;-1:-1:-1;17726:9:1;;17667:74::o;17746:168::-;17786:7;17852:1;17848;17844:6;17840:14;17837:1;17834:21;17829:1;17822:9;17815:17;17811:45;17808:2;;;17859:18;;:::i;:::-;-1:-1:-1;17899:9:1;;17798:116::o;17919:125::-;17959:4;17987:1;17984;17981:8;17978:2;;;17992:18;;:::i;:::-;-1:-1:-1;18029:9:1;;17968:76::o;18049:258::-;18121:1;18131:113;18145:6;18142:1;18139:13;18131:113;;;18221:11;;;18215:18;18202:11;;;18195:39;18167:2;18160:10;18131:113;;;18262:6;18259:1;18256:13;18253:2;;;-1:-1:-1;;18297:1:1;18279:16;;18272:27;18102:205::o;18312:380::-;18391:1;18387:12;;;;18434;;;18455:2;;18509:4;18501:6;18497:17;18487:27;;18455:2;18562;18554:6;18551:14;18531:18;18528:38;18525:2;;;18608:10;18603:3;18599:20;18596:1;18589:31;18643:4;18640:1;18633:15;18671:4;18668:1;18661:15;18525:2;;18367:325;;;:::o;18697:135::-;18736:3;-1:-1:-1;;18757:17:1;;18754:2;;;18777:18;;:::i;:::-;-1:-1:-1;18824:1:1;18813:13;;18744:88::o;18837:112::-;18869:1;18895;18885:2;;18900:18;;:::i;:::-;-1:-1:-1;18934:9:1;;18875:74::o;18954:127::-;19015:10;19010:3;19006:20;19003:1;18996:31;19046:4;19043:1;19036:15;19070:4;19067:1;19060:15;19086:127;19147:10;19142:3;19138:20;19135:1;19128:31;19178:4;19175:1;19168:15;19202:4;19199:1;19192:15;19218:127;19279:10;19274:3;19270:20;19267:1;19260:31;19310:4;19307:1;19300:15;19334:4;19331:1;19324:15;19350:131;-1:-1:-1;;;;;;19424:32:1;;19414:43;;19404:2;;19471:1;19468;19461:12
Metadata Hash
4c76611aef1062a8e07b12df130aa65cff38657e6ace9639e00a50c41e716da4
Age | Block | Fee Address | BC Fee Address | Voting Power | Jailed | Incoming |
---|
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.