Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
Multichain Info
Latest 25 from a total of 411 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Set Sale Status | 13818654 | 1036 days ago | IN | 0 ETH | 0.00423233 | ||||
Buy | 13743186 | 1048 days ago | IN | 0.08 ETH | 0.01920878 | ||||
Buy | 13734129 | 1050 days ago | IN | 0.48 ETH | 0.09364283 | ||||
Buy | 13733688 | 1050 days ago | IN | 0.16 ETH | 0.02697847 | ||||
Buy | 13732616 | 1050 days ago | IN | 0.08 ETH | 0.01585665 | ||||
Buy | 13731961 | 1050 days ago | IN | 0.08 ETH | 0.0163017 | ||||
Buy | 13731943 | 1050 days ago | IN | 0.08 ETH | 0.01698297 | ||||
Buy | 13731115 | 1050 days ago | IN | 0.08 ETH | 0.01669747 | ||||
Buy | 13730192 | 1050 days ago | IN | 0.08 ETH | 0.01752653 | ||||
Buy | 13726498 | 1051 days ago | IN | 0.08 ETH | 0.01578855 | ||||
Buy | 13725085 | 1051 days ago | IN | 0.08 ETH | 0.01736365 | ||||
Buy | 13724852 | 1051 days ago | IN | 0.08 ETH | 0.01967432 | ||||
Buy | 13717757 | 1052 days ago | IN | 0.08 ETH | 0.02504736 | ||||
Buy | 13713585 | 1053 days ago | IN | 0.08 ETH | 0.01962696 | ||||
Buy | 13711581 | 1053 days ago | IN | 0.16 ETH | 0.04669743 | ||||
Buy | 13710936 | 1053 days ago | IN | 0.08 ETH | 0.01864237 | ||||
Buy | 13710089 | 1053 days ago | IN | 0.08 ETH | 0.02488263 | ||||
Buy | 13709603 | 1053 days ago | IN | 0.08 ETH | 0.02367307 | ||||
Buy | 13709197 | 1054 days ago | IN | 0.16 ETH | 0.03972375 | ||||
Buy | 13709181 | 1054 days ago | IN | 0.16 ETH | 0.04340237 | ||||
Buy | 13708231 | 1054 days ago | IN | 0.16 ETH | 0.03319159 | ||||
Buy | 13705694 | 1054 days ago | IN | 0.08 ETH | 0.02293005 | ||||
Buy | 13702118 | 1055 days ago | IN | 0.24 ETH | 0.05676377 | ||||
Buy | 13691779 | 1056 days ago | IN | 0.16 ETH | 0.04086647 | ||||
Buy | 13690945 | 1056 days ago | IN | 0.08 ETH | 0.02171696 |
Latest 25 internal transactions (View All)
Advanced mode:
Parent Transaction Hash | Block | From | To | |||
---|---|---|---|---|---|---|
13743186 | 1048 days ago | 0.08 ETH | ||||
13734129 | 1050 days ago | 0.48 ETH | ||||
13733688 | 1050 days ago | 0.16 ETH | ||||
13732616 | 1050 days ago | 0.08 ETH | ||||
13731961 | 1050 days ago | 0.08 ETH | ||||
13731943 | 1050 days ago | 0.08 ETH | ||||
13731115 | 1050 days ago | 0.08 ETH | ||||
13730192 | 1050 days ago | 0.08 ETH | ||||
13726498 | 1051 days ago | 0.08 ETH | ||||
13725085 | 1051 days ago | 0.08 ETH | ||||
13724852 | 1051 days ago | 0.08 ETH | ||||
13717757 | 1052 days ago | 0.08 ETH | ||||
13713585 | 1053 days ago | 0.08 ETH | ||||
13711581 | 1053 days ago | 0.16 ETH | ||||
13710936 | 1053 days ago | 0.08 ETH | ||||
13710089 | 1053 days ago | 0.08 ETH | ||||
13709603 | 1053 days ago | 0.08 ETH | ||||
13709197 | 1054 days ago | 0.16 ETH | ||||
13709181 | 1054 days ago | 0.16 ETH | ||||
13708231 | 1054 days ago | 0.16 ETH | ||||
13705694 | 1054 days ago | 0.08 ETH | ||||
13702118 | 1055 days ago | 0.24 ETH | ||||
13691779 | 1056 days ago | 0.16 ETH | ||||
13690945 | 1056 days ago | 0.08 ETH | ||||
13689175 | 1057 days ago | 0.08 ETH |
Loading...
Loading
Contract Name:
CowMarket
Compiler Version
v0.8.10+commit.fc410830
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2021-11-19 */ // Dependency file: @openzeppelin/contracts/utils/Address.sol // SPDX-License-Identifier: MIT // 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); } function _verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) private 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); } } } } // Dependency file: @openzeppelin/contracts/utils/math/SafeMath.sol // 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; } } } // Dependency file: @openzeppelin/contracts/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); } // Dependency file: @openzeppelin/contracts/token/ERC721/IERC721.sol // pragma solidity ^0.8.0; // import "@openzeppelin/contracts/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`, 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; } // Dependency file: @openzeppelin/contracts/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 `IERC721.onERC721Received.selector`. */ function onERC721Received( address operator, address from, uint256 tokenId, bytes calldata data ) external returns (bytes4); } // Dependency file: @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol // pragma solidity ^0.8.0; // import "@openzeppelin/contracts/token/ERC721/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); } // Dependency file: @openzeppelin/contracts/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; } } // Dependency file: @openzeppelin/contracts/utils/Strings.sol // 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); } } // Dependency file: @openzeppelin/contracts/utils/introspection/ERC165.sol // pragma solidity ^0.8.0; // import "@openzeppelin/contracts/utils/introspection/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; } } // Dependency file: @openzeppelin/contracts/token/ERC721/ERC721.sol // 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/Address.sol"; // import "@openzeppelin/contracts/utils/Context.sol"; // import "@openzeppelin/contracts/utils/Strings.sol"; // import "@openzeppelin/contracts/utils/introspection/ERC165.sol"; /** * @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(to).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 {} } // Dependency file: @openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol // pragma solidity ^0.8.0; // import "@openzeppelin/contracts/token/ERC721/IERC721.sol"; /** * @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); } // Dependency file: @openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol // pragma solidity ^0.8.0; // import "@openzeppelin/contracts/token/ERC721/ERC721.sol"; // import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol"; /** * @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(); } } // Dependency file: contracts/interfaces/ICollectible.sol // pragma solidity >=0.8.0 <1.0.0; interface ICollectible is IERC721Enumerable { function mint(address to, uint256 amount) external; function createdAt(uint256 _tokenId) external view returns (uint256 timestamp); function createdAtBlock(uint256 _tokenId) external view returns (uint256 blockNumber); } // Dependency file: contracts/interfaces/ICowRegistry.sol // pragma solidity >=0.8.0 <1.0.0; interface ICowsRegistry { enum Gender { MALE, FEMALE } struct Cow { Gender gender; uint power; uint rarity; } function store(uint256 _cowId, Cow memory _data) external; function update(uint256 _cowId, Cow memory _data) external; function data(uint256 _cowId) external view returns (Cow memory _data); } // Dependency file: @openzeppelin/contracts/access/Ownable.sol // pragma solidity ^0.8.0; // import "@openzeppelin/contracts/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() { _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); } } // Dependency file: contracts/access/Whitelist.sol // pragma solidity >=0.8.0 <1.0.0; // import "@openzeppelin/contracts/access/Ownable.sol"; abstract contract Whitelist is Ownable { event MemberAdded(address member); event MemberRemoved(address member); mapping(address => bool) private members; /** * @dev A method to verify whether an address is a member of the whitelist * @param _member The address to verify. * @return Whether the address is a member of the whitelist. */ function isMember(address _member) public view returns (bool) { return members[_member]; } /** * @dev A method to add a member to the whitelist * @param _member The member to add as a member. */ function addMember(address _member) external onlyOwner { require(!isMember(_member), "Whitelist: Address is member already"); members[_member] = true; emit MemberAdded(_member); } /** * @dev A method to add a member to the whitelist * @param _members The members to add as a member. */ function addMembers(address[] calldata _members) external onlyOwner { _addMembers(_members); } /** * @dev A method to remove a member from the whitelist * @param _member The member to remove as a member. */ function removeMember(address _member) external onlyOwner { require(isMember(_member), "Whitelist: Not member of whitelist"); delete members[_member]; emit MemberRemoved(_member); } /** * @dev A method to remove a members from the whitelist * @param _members The members to remove as a member. */ function removeMembers(address[] calldata _members) external onlyOwner { _removeMembers(_members); } function _addMembers(address[] memory _members) internal { uint256 l = _members.length; uint256 i; for (i; i < l; i++) { require( !isMember(_members[i]), "Whitelist: Address is member already" ); members[_members[i]] = true; emit MemberAdded(_members[i]); } } function _removeMembers(address[] memory _members) internal { uint256 l = _members.length; uint256 i; for (i; i < l; i++) { require( isMember(_members[i]), "Whitelist: Address is no member" ); delete members[_members[i]]; emit MemberRemoved(_members[i]); } } } // Root file: contracts/CowMarket.sol pragma solidity >=0.8.0 <1.0.0; // import "contracts/interfaces/ICollectible.sol"; // import "contracts/interfaces/ICowRegistry.sol"; // import "contracts/access/Whitelist.sol"; contract CowMarket is Whitelist { using SafeMath for uint256; enum SaleStatus { DISABLED, WHITELIST, GENERAL } uint256 public tokenPrice = 80000000000000000; // 0.08 ETH uint256 public maxTokenPurchase = 5; uint256 public constant maxTokens = 3333; address public fund; SaleStatus public saleStatus; ICollectible public cows; event TokenPriceChanged(uint256 price); event MaxPurchaseChanged(uint256 value); event FundSet(address bankAccount); event RolledOver(SaleStatus status); constructor(ICollectible _cows, address _fund) { require( address(_cows) != address(0) && _fund != address(0), "Unacceptable address set" ); cows = _cows; fund = _fund; } receive() external payable { uint256 deposit = msg.value; uint256 amount = deposit.div(tokenPrice); require( SaleStatus.DISABLED != saleStatus, "Collection: sale is not active" ); if (SaleStatus.WHITELIST == saleStatus) { require(isMember(_msgSender()), "Whitelist: not in the list"); } require( amount <= maxTokenPurchase, "Collection: exceeds max number of Tokens in one transaction" ); require( cows.totalSupply().add(amount) <= maxTokens, "Collection: purchase would exceed max supply of Tokens" ); require(tokenPrice.mul(amount) == deposit, "Collection: ether value sent is not correct" ); if (fund != address(this)) { Address.sendValue(payable(fund), deposit); } cows.mint(msg.sender, amount); } function buy(uint _amount) external payable { require(SaleStatus.DISABLED != saleStatus, "Collection: sale is not active"); if (SaleStatus.WHITELIST == saleStatus) { require(isMember(_msgSender()), "Whitelist: not in the list"); } require( _amount <= maxTokenPurchase, "Collection: exceeds max number of Tokens in one transaction" ); require( cows.totalSupply().add(_amount) <= maxTokens, "Collection: purchase would exceed max supply of Tokens" ); uint256 deposit = msg.value; require(tokenPrice.mul(_amount) == deposit, "Collection: ether value sent is not correct" ); if (fund != address(this)) { Address.sendValue(payable(fund), deposit); } cows.mint(msg.sender, _amount); } // @dev Changes sale status. // Permission: only owner function setSaleStatus(SaleStatus _status) public onlyOwner { saleStatus = _status; emit RolledOver(_status); } // @dev Setup new token sale price. // Permission: only owner function setPrice(uint256 _price) external onlyOwner { require(_price != 0, "Zero price"); tokenPrice = _price; emit TokenPriceChanged(_price); } // @dev Setup max tokens purchase per transaction. // Permission: only owner function setMaxPurchase(uint256 _value) external onlyOwner { require(_value != 0, "Very low value"); maxTokenPurchase = _value; emit MaxPurchaseChanged(_value); } // @dev Setup new bank account. // Permission: only owner function setFund(address _account) external onlyOwner { require(_account != address(0), "Zero address set"); fund = _account; emit FundSet(_account); } // @dev Withdraw ethereum from contract balance. // Permission: only owner function withdraw() public onlyOwner { uint balance = address(this).balance; Address.sendValue(payable(_msgSender()), balance); } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"contract ICollectible","name":"_cows","type":"address"},{"internalType":"address","name":"_fund","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"bankAccount","type":"address"}],"name":"FundSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"MaxPurchaseChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"member","type":"address"}],"name":"MemberAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"member","type":"address"}],"name":"MemberRemoved","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":false,"internalType":"enum CowMarket.SaleStatus","name":"status","type":"uint8"}],"name":"RolledOver","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"price","type":"uint256"}],"name":"TokenPriceChanged","type":"event"},{"inputs":[{"internalType":"address","name":"_member","type":"address"}],"name":"addMember","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_members","type":"address[]"}],"name":"addMembers","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"buy","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"cows","outputs":[{"internalType":"contract ICollectible","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"fund","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_member","type":"address"}],"name":"isMember","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxTokenPurchase","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxTokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_member","type":"address"}],"name":"removeMember","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_members","type":"address[]"}],"name":"removeMembers","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"saleStatus","outputs":[{"internalType":"enum CowMarket.SaleStatus","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"setFund","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_value","type":"uint256"}],"name":"setMaxPurchase","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_price","type":"uint256"}],"name":"setPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"enum CowMarket.SaleStatus","name":"_status","type":"uint8"}],"name":"setSaleStatus","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"tokenPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]
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)
0000000000000000000000005f597f29a9222db8a0a2378f3dc32c1ca258bb640000000000000000000000009f2d1cb4da50f843fed381691b6d48351e6f9356
-----Decoded View---------------
Arg [0] : _cows (address): 0x5f597f29A9222db8a0A2378f3dC32c1Ca258BB64
Arg [1] : _fund (address): 0x9F2d1cB4da50F843fed381691B6d48351e6f9356
-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000005f597f29a9222db8a0a2378f3dc32c1ca258bb64
Arg [1] : 0000000000000000000000009f2d1cb4da50f843fed381691b6d48351e6f9356
Deployed Bytecode Sourcemap
54751:4005:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55705:10;;55656:9;;55638:15;;55693:23;;55656:9;;55693:11;:23::i;:::-;55774:10;;55676:40;;-1:-1:-1;55774:10:0;;;;;55751:33;;;;;;;;:::i;:::-;55729:113;;;;-1:-1:-1;;;55729:113:0;;405:2:1;55729:113:0;;;387:21:1;444:2;424:18;;;417:30;483:32;463:18;;;456:60;533:18;;55729:113:0;;;;;;;;;55891:10;;;;;;;55867:34;;;;;;;;:::i;:::-;:20;:34;55863:128;;;55926:22;23148:10;55935:12;52489:16;;52465:4;52489:16;;;:7;:16;;;;;;;;;52409:104;55926:22;55918:61;;;;-1:-1:-1;;;55918:61:0;;764:2:1;55918:61:0;;;746:21:1;803:2;783:18;;;776:30;842:28;822:18;;;815:56;888:18;;55918:61:0;562:350:1;55918:61:0;56036:16;;56026:6;:26;;56004:135;;;;-1:-1:-1;;;56004:135:0;;1119:2:1;56004:135:0;;;1101:21:1;1158:2;1138:18;;;1131:30;1197:34;1177:18;;;1170:62;1268:29;1248:18;;;1241:57;1315:19;;56004:135:0;917:423:1;56004:135:0;55055:4;56172:30;56195:6;56172:4;;;;;;;;;;;:16;;;:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:22;;:30::i;:::-;:43;;56150:147;;;;-1:-1:-1;;;56150:147:0;;1736:2:1;56150:147:0;;;1718:21:1;1775:2;1755:18;;;1748:30;1814:34;1794:18;;;1787:62;1885:24;1865:18;;;1858:52;1927:19;;56150:147:0;1534:418:1;56150:147:0;56316:10;;56342:7;;56316:22;;56331:6;56316:14;:22::i;:::-;:33;56308:112;;;;-1:-1:-1;;;56308:112:0;;2159:2:1;56308:112:0;;;2141:21:1;2198:2;2178:18;;;2171:30;2237:34;2217:18;;;2210:62;2308:13;2288:18;;;2281:41;2339:19;;56308:112:0;1957:407:1;56308:112:0;56437:4;;:21;:4;56453;56437:21;56433:95;;56501:4;;56475:41;;56501:4;;56508:7;56475:17;:41::i;:::-;56540:4;;:29;;;;;56550:10;56540:29;;;2543:74:1;2633:18;;;2626:34;;;56540:4:0;;;;;:9;;2516:18:1;;56540:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55627:950;;54751:4005;;;;;54977:35;;;;;;;;;;;;;;;;;;;2817:25:1;;;2805:2;2790:18;54977:35:0;;;;;;;;53249:215;;;;;;;;;;-1:-1:-1;53249:215:0;;;;;:::i;:::-;;:::i;:::-;;58323:185;;;;;;;;;;-1:-1:-1;58323:185:0;;;;;:::i;:::-;;:::i;55131:24::-;;;;;;;;;;-1:-1:-1;55131:24:0;;;;;;;;;;;3364:42:1;3352:55;;;3334:74;;3322:2;3307:18;55131:24:0;3167:247:1;58601:152:0;;;;;;;;;;;;;:::i;53610:114::-;;;;;;;;;;-1:-1:-1;53610:114:0;;;;;:::i;:::-;;:::i;57561:134::-;;;;;;;;;;-1:-1:-1;57561:134:0;;;;;:::i;:::-;;:::i;52998:108::-;;;;;;;;;;-1:-1:-1;52998:108:0;;;;;:::i;:::-;;:::i;58051:196::-;;;;;;;;;;-1:-1:-1;58051:196:0;;;;;:::i;:::-;;:::i;51236:94::-;;;;;;;;;;;;;:::i;54913:45::-;;;;;;;;;;;;;;;;50585:87;;;;;;;;;;-1:-1:-1;50631:7:0;50658:6;;;50585:87;;57777:179;;;;;;;;;;-1:-1:-1;57777:179:0;;;;;:::i;:::-;;:::i;52409:104::-;;;;;;;;;;-1:-1:-1;52409:104:0;;;;;:::i;:::-;;;4896:14:1;;4889:22;4871:41;;4859:2;4844:18;52409:104:0;4731:187:1;55068:19:0;;;;;;;;;;-1:-1:-1;55068:19:0;;;;;;;;52648:213;;;;;;;;;;-1:-1:-1;52648:213:0;;;;;:::i;:::-;;:::i;56585:903::-;;;;;;:::i;:::-;;:::i;55019:40::-;;;;;;;;;;;;55055:4;55019:40;;51485:192;;;;;;;;;;-1:-1:-1;51485:192:0;;;;;:::i;:::-;;:::i;55094:28::-;;;;;;;;;;-1:-1:-1;55094:28:0;;;;;;;;;;;;;;;;;;:::i;11868:98::-;11926:7;11953:5;11957:1;11953;:5;:::i;:::-;11946:12;11868:98;-1:-1:-1;;;11868:98:0:o;10731:::-;10789:7;10816:5;10820:1;10816;:5;:::i;11469:98::-;11527:7;11554:5;11558:1;11554;:5;:::i;2133:317::-;2248:6;2223:21;:31;;2215:73;;;;-1:-1:-1;;;2215:73:0;;6364:2:1;2215:73:0;;;6346:21:1;6403:2;6383:18;;;6376:30;6442:31;6422:18;;;6415:59;6491:18;;2215:73:0;6162:353:1;2215:73:0;2302:12;2320:9;:14;;2342:6;2320:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2301:52;;;2372:7;2364:78;;;;-1:-1:-1;;;2364:78:0;;6932:2:1;2364:78:0;;;6914:21:1;6971:2;6951:18;;;6944:30;7010:34;6990:18;;;6983:62;7081:28;7061:18;;;7054:56;7127:19;;2364:78:0;6730:422:1;2364:78:0;2204:246;2133:317;;:::o;53249:215::-;50631:7;50658:6;50805:23;50658:6;23148:10;50805:23;50797:68;;;;-1:-1:-1;;;50797:68:0;;7359:2:1;50797:68:0;;;7341:21:1;;;7378:18;;;7371:30;7437:34;7417:18;;;7410:62;7489:18;;50797:68:0;7157:356:1;50797:68:0;52489:16;;;52465:4;52489:16;;;:7;:16;;;;;;;;53318:64:::1;;;::::0;-1:-1:-1;;;53318:64:0;;7720:2:1;53318:64:0::1;::::0;::::1;7702:21:1::0;7759:2;7739:18;;;7732:30;7798:34;7778:18;;;7771:62;7869:4;7849:18;;;7842:32;7891:19;;53318:64:0::1;7518:398:1::0;53318:64:0::1;53402:16;::::0;::::1;;::::0;;;:7:::1;:16;::::0;;;;;;;;53395:23;;;::::1;::::0;;53434:22;;3334:74:1;;;53434:22:0::1;::::0;3307:18:1;53434:22:0::1;;;;;;;;53249:215:::0;:::o;58323:185::-;50631:7;50658:6;50805:23;50658:6;23148:10;50805:23;50797:68;;;;-1:-1:-1;;;50797:68:0;;7359:2:1;50797:68:0;;;7341:21:1;;;7378:18;;;7371:30;7437:34;7417:18;;;7410:62;7489:18;;50797:68:0;7157:356:1;50797:68:0;58396:22:::1;::::0;::::1;58388:51;;;::::0;-1:-1:-1;;;58388:51:0;;8123:2:1;58388:51:0::1;::::0;::::1;8105:21:1::0;8162:2;8142:18;;;8135:30;8201:18;8181;;;8174:46;8237:18;;58388:51:0::1;7921:340:1::0;58388:51:0::1;58452:4;:15:::0;;;::::1;;::::0;::::1;::::0;;::::1;::::0;;;58483:17:::1;::::0;3334:74:1;;;58483:17:0::1;::::0;3322:2:1;3307:18;58483:17:0::1;3167:247:1::0;58601:152:0;50631:7;50658:6;50805:23;50658:6;23148:10;50805:23;50797:68;;;;-1:-1:-1;;;50797:68:0;;7359:2:1;50797:68:0;;;7341:21:1;;;7378:18;;;7371:30;7437:34;7417:18;;;7410:62;7489:18;;50797:68:0;7157:356:1;50797:68:0;58664:21:::1;58696:49;23148:10:::0;58737:7:::1;58696:17;:49::i;:::-;58638:115;58601:152::o:0;53610:114::-;50631:7;50658:6;50805:23;50658:6;23148:10;50805:23;50797:68;;;;-1:-1:-1;;;50797:68:0;;7359:2:1;50797:68:0;;;7341:21:1;;;7378:18;;;7371:30;7437:34;7417:18;;;7410:62;7489:18;;50797:68:0;7157:356:1;50797:68:0;53692:24:::1;53707:8;;53692:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;53692:14:0::1;::::0;-1:-1:-1;;;53692:24:0:i:1;:::-;53610:114:::0;;:::o;57561:134::-;50631:7;50658:6;50805:23;50658:6;23148:10;50805:23;50797:68;;;;-1:-1:-1;;;50797:68:0;;7359:2:1;50797:68:0;;;7341:21:1;;;7378:18;;;7371:30;7437:34;7417:18;;;7410:62;7489:18;;50797:68:0;7157:356:1;50797:68:0;57632:10:::1;:20:::0;;57645:7;;57632:10;:20;::::1;::::0;57645:7;57632:20:::1;::::0;::::1;;;;;;:::i;:::-;;;;;;57668:19;57679:7;57668:19;;;;;;:::i;52998:108::-:0;50631:7;50658:6;50805:23;50658:6;23148:10;50805:23;50797:68;;;;-1:-1:-1;;;50797:68:0;;7359:2:1;50797:68:0;;;7341:21:1;;;7378:18;;;7371:30;7437:34;7417:18;;;7410:62;7489:18;;50797:68:0;7157:356:1;50797:68:0;53077:21:::1;53089:8;;53077:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;53077:11:0::1;::::0;-1:-1:-1;;;53077:21:0:i:1;58051:196::-:0;50631:7;50658:6;50805:23;50658:6;23148:10;50805:23;50797:68;;;;-1:-1:-1;;;50797:68:0;;7359:2:1;50797:68:0;;;7341:21:1;;;7378:18;;;7371:30;7437:34;7417:18;;;7410:62;7489:18;;50797:68:0;7157:356:1;50797:68:0;58129:11;58121:38:::1;;;::::0;-1:-1:-1;;;58121:38:0;;8468:2:1;58121:38:0::1;::::0;::::1;8450:21:1::0;8507:2;8487:18;;;8480:30;8546:16;8526:18;;;8519:44;8580:18;;58121:38:0::1;8266:338:1::0;58121:38:0::1;58172:16;:25:::0;;;58213:26:::1;::::0;2817:25:1;;;58213:26:0::1;::::0;2805:2:1;2790:18;58213:26:0::1;2671:177:1::0;51236:94:0;50631:7;50658:6;50805:23;50658:6;23148:10;50805:23;50797:68;;;;-1:-1:-1;;;50797:68:0;;7359:2:1;50797:68:0;;;7341:21:1;;;7378:18;;;7371:30;7437:34;7417:18;;;7410:62;7489:18;;50797:68:0;7157:356:1;50797:68:0;51301:21:::1;51319:1;51301:9;:21::i;:::-;51236:94::o:0;57777:179::-;50631:7;50658:6;50805:23;50658:6;23148:10;50805:23;50797:68;;;;-1:-1:-1;;;50797:68:0;;7359:2:1;50797:68:0;;;7341:21:1;;;7378:18;;;7371:30;7437:34;7417:18;;;7410:62;7489:18;;50797:68:0;7157:356:1;50797:68:0;57849:11;57841:34:::1;;;::::0;-1:-1:-1;;;57841:34:0;;8811:2:1;57841:34:0::1;::::0;::::1;8793:21:1::0;8850:2;8830:18;;;8823:30;8889:12;8869:18;;;8862:40;8919:18;;57841:34:0::1;8609:334:1::0;57841:34:0::1;57888:10;:19:::0;;;57923:25:::1;::::0;2817::1;;;57923::0::1;::::0;2805:2:1;2790:18;57923:25:0::1;2671:177:1::0;52648:213:0;50631:7;50658:6;50805:23;50658:6;23148:10;50805:23;50797:68;;;;-1:-1:-1;;;50797:68:0;;7359:2:1;50797:68:0;;;7341:21:1;;;7378:18;;;7371:30;7437:34;7417:18;;;7410:62;7489:18;;50797:68:0;7157:356:1;50797:68:0;52489:16;;;52465:4;52489:16;;;:7;:16;;;;;;;;52722:18:::1;52714:67;;;::::0;-1:-1:-1;;;52714:67:0;;9150:2:1;52714:67:0::1;::::0;::::1;9132:21:1::0;9189:2;9169:18;;;9162:30;9228:34;9208:18;;;9201:62;9299:6;9279:18;;;9272:34;9323:19;;52714:67:0::1;8948:400:1::0;52714:67:0::1;52794:16;::::0;::::1;;::::0;;;52813:4:::1;52794:16;::::0;;;;;;;;:23;;;::::1;::::0;;::::1;::::0;;;52833:20;;3334:74:1;;;52833:20:0::1;::::0;3307:18:1;52833:20:0::1;3167:247:1::0;56585:903:0;56671:10;;;;;;;56648:33;;;;;;;;:::i;:::-;56640:76;;;;-1:-1:-1;;;56640:76:0;;405:2:1;56640:76:0;;;387:21:1;444:2;424:18;;;417:30;483:32;463:18;;;456:60;533:18;;56640:76:0;203:354:1;56640:76:0;56757:10;;;;;;;56733:34;;;;;;;;:::i;:::-;:20;:34;56729:128;;;56792:22;23148:10;56801:12;23068:98;56792:22;56784:61;;;;-1:-1:-1;;;56784:61:0;;764:2:1;56784:61:0;;;746:21:1;803:2;783:18;;;776:30;842:28;822:18;;;815:56;888:18;;56784:61:0;562:350:1;56784:61:0;56902:16;;56891:7;:27;;56869:136;;;;-1:-1:-1;;;56869:136:0;;1119:2:1;56869:136:0;;;1101:21:1;1158:2;1138:18;;;1131:30;1197:34;1177:18;;;1170:62;1268:29;1248:18;;;1241:57;1315:19;;56869:136:0;917:423:1;56869:136:0;55055:4;57038:31;57061:7;57038:4;;;;;;;;;;;:16;;;:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:31;:44;;57016:148;;;;-1:-1:-1;;;57016:148:0;;1736:2:1;57016:148:0;;;1718:21:1;1775:2;1755:18;;;1748:30;1814:34;1794:18;;;1787:62;1885:24;1865:18;;;1858:52;1927:19;;57016:148:0;1534:418:1;57016:148:0;57225:10;;57195:9;;;;57225:23;;57240:7;57225:14;:23::i;:::-;:34;57217:113;;;;-1:-1:-1;;;57217:113:0;;2159:2:1;57217:113:0;;;2141:21:1;2198:2;2178:18;;;2171:30;2237:34;2217:18;;;2210:62;2308:13;2288:18;;;2281:41;2339:19;;57217:113:0;1957:407:1;57217:113:0;57347:4;;:21;:4;57363;57347:21;57343:95;;57411:4;;57385:41;;57411:4;;57418:7;57385:17;:41::i;:::-;57450:4;;:30;;;;;57460:10;57450:30;;;2543:74:1;2633:18;;;2626:34;;;57450:4:0;;;;;:9;;2516:18:1;;57450:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56629:859;56585:903;:::o;51485:192::-;50631:7;50658:6;50805:23;50658:6;23148:10;50805:23;50797:68;;;;-1:-1:-1;;;50797:68:0;;7359:2:1;50797:68:0;;;7341:21:1;;;7378:18;;;7371:30;7437:34;7417:18;;;7410:62;7489:18;;50797:68:0;7157:356:1;50797:68:0;51574:22:::1;::::0;::::1;51566:73;;;::::0;-1:-1:-1;;;51566:73:0;;9555:2:1;51566:73:0::1;::::0;::::1;9537:21:1::0;9594:2;9574:18;;;9567:30;9633:34;9613:18;;;9606:62;9704:8;9684:18;;;9677:36;9730:19;;51566:73:0::1;9353:402:1::0;51566:73:0::1;51650:19;51660:8;51650:9;:19::i;54128:387::-:0;54211:15;;54199:9;54257:251;54269:1;54265;:5;54257:251;;;54318:21;54327:8;54336:1;54327:11;;;;;;;;:::i;:::-;;;;;;;52489:16;;52465:4;52489:16;;;:7;:16;;;;;;;;;52409:104;54318:21;54292:114;;;;-1:-1:-1;;;54292:114:0;;10151:2:1;54292:114:0;;;10133:21:1;10190:2;10170:18;;;10163:30;10229:33;10209:18;;;10202:61;10280:18;;54292:114:0;9949:355:1;54292:114:0;54430:7;:20;54438:8;54447:1;54438:11;;;;;;;;:::i;:::-;;;;;;;54430:20;;;;;;;;;;;;;;;;54423:27;;;;;;;;;;;54470:26;54484:8;54493:1;54484:11;;;;;;;;:::i;:::-;;;;;;;54470:26;;;;;3364:42:1;3352:55;;;;3334:74;;3322:2;3307:18;;3167:247;54470:26:0;;;;;;;;54272:3;;;;:::i;:::-;;;;54257:251;;53732:388;53812:15;;53800:9;53858:255;53870:1;53866;:5;53858:255;;;53920:21;53929:8;53938:1;53929:11;;;;;;;;:::i;53920:21::-;53919:22;53893:120;;;;-1:-1:-1;;;53893:120:0;;9150:2:1;53893:120:0;;;9132:21:1;9189:2;9169:18;;;9162:30;9228:34;9208:18;;;9201:62;9299:6;9279:18;;;9272:34;9323:19;;53893:120:0;8948:400:1;53893:120:0;54053:4;54030:7;:20;54038:8;54047:1;54038:11;;;;;;;;:::i;:::-;;;;;;;54030:20;;;;;;;;;;;;;;;;:27;;;;;;;;;;;;;;;;;;54077:24;54089:8;54098:1;54089:11;;;;;;;;:::i;:::-;;;;;;;54077:24;;;;;3364:42:1;3352:55;;;;3334:74;;3322:2;3307:18;;3167:247;54077:24:0;;;;;;;;53873:3;;;;:::i;:::-;;;;53858:255;;51685:173;51741:16;51760:6;;;51777:17;;;;;;;;;;51810:40;;51760:6;;;;;;;51810:40;;51741:16;51810:40;51730:128;51685:173;:::o;14:184:1:-;66:77;63:1;56:88;163:4;160:1;153:15;187:4;184:1;177:15;1345:184;1415:6;1468:2;1456:9;1447:7;1443:23;1439:32;1436:52;;;1484:1;1481;1474:12;1436:52;-1:-1:-1;1507:16:1;;1345:184;-1:-1:-1;1345:184:1:o;2853:309::-;2912:6;2965:2;2953:9;2944:7;2940:23;2936:32;2933:52;;;2981:1;2978;2971:12;2933:52;3020:9;3007:23;3070:42;3063:5;3059:54;3052:5;3049:65;3039:93;;3128:1;3125;3118:12;3419:615;3505:6;3513;3566:2;3554:9;3545:7;3541:23;3537:32;3534:52;;;3582:1;3579;3572:12;3534:52;3622:9;3609:23;3651:18;3692:2;3684:6;3681:14;3678:34;;;3708:1;3705;3698:12;3678:34;3746:6;3735:9;3731:22;3721:32;;3791:7;3784:4;3780:2;3776:13;3772:27;3762:55;;3813:1;3810;3803:12;3762:55;3853:2;3840:16;3879:2;3871:6;3868:14;3865:34;;;3895:1;3892;3885:12;3865:34;3948:7;3943:2;3933:6;3930:1;3926:14;3922:2;3918:23;3914:32;3911:45;3908:65;;;3969:1;3966;3959:12;3908:65;4000:2;3992:11;;;;;4022:6;;-1:-1:-1;3419:615:1;;-1:-1:-1;;;;3419:615:1:o;4039:271::-;4113:6;4166:2;4154:9;4145:7;4141:23;4137:32;4134:52;;;4182:1;4179;4172:12;4134:52;4221:9;4208:23;4260:1;4253:5;4250:12;4240:40;;4276:1;4273;4266:12;4315:180;4374:6;4427:2;4415:9;4406:7;4402:23;4398:32;4395:52;;;4443:1;4440;4433:12;4395:52;-1:-1:-1;4466:23:1;;4315:180;-1:-1:-1;4315:180:1:o;4923:400::-;5070:2;5055:18;;5103:1;5092:13;;5082:201;;5139:77;5136:1;5129:88;5240:4;5237:1;5230:15;5268:4;5265:1;5258:15;5082:201;5292:25;;;4923:400;:::o;5328:184::-;5380:77;5377:1;5370:88;5477:4;5474:1;5467:15;5501:4;5498:1;5491:15;5517:274;5557:1;5583;5573:189;;5618:77;5615:1;5608:88;5719:4;5716:1;5709:15;5747:4;5744:1;5737:15;5573:189;-1:-1:-1;5776:9:1;;5517:274::o;5796:128::-;5836:3;5867:1;5863:6;5860:1;5857:13;5854:39;;;5873:18;;:::i;:::-;-1:-1:-1;5909:9:1;;5796:128::o;5929:228::-;5969:7;6095:1;6027:66;6023:74;6020:1;6017:81;6012:1;6005:9;5998:17;5994:105;5991:131;;;6102:18;;:::i;:::-;-1:-1:-1;6142:9:1;;5929:228::o;9760:184::-;9812:77;9809:1;9802:88;9909:4;9906:1;9899:15;9933:4;9930:1;9923:15;10309:195;10348:3;10379:66;10372:5;10369:77;10366:103;;;10449:18;;:::i;:::-;-1:-1:-1;10496:1:1;10485:13;;10309:195::o
Swarm Source
ipfs://e7b9befe8bca4207294bde6920ea4a1307fb9da660f9a32d8028c1c26b4dfbb7
Loading...
Loading
Loading...
Loading
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.