ERC-721
Overview
Max Total Supply
1,856 CK
Holders
316
Market
Volume (24H)
N/A
Min Price (24H)
N/A
Max Price (24H)
N/A
Other Info
Token Contract
Balance
5 CKLoading...
Loading
Loading...
Loading
Loading...
Loading
# | Exchange | Pair | Price | 24H Volume | % Volume |
---|
This contract may be a proxy contract. Click on More Options and select Is this a proxy? to confirm and enable the "Read as Proxy" & "Write as Proxy" tabs.
Contract Name:
ChonkyProxy
Compiler Version
v0.8.10+commit.fc410830
Optimization Enabled:
Yes with 200 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import {ERC721MetadataStorage} from "@solidstate/contracts/token/ERC721/metadata/ERC721MetadataStorage.sol"; import {IERC721} from "@solidstate/contracts/token/ERC721/IERC721.sol"; import {Proxy} from "@solidstate/contracts/proxy/Proxy.sol"; import {SafeOwnable, OwnableStorage} from "@solidstate/contracts/access/SafeOwnable.sol"; import {IERC165} from "@solidstate/contracts/introspection/IERC165.sol"; import {ERC165Storage} from "@solidstate/contracts/introspection/ERC165Storage.sol"; import {ChonkyNFTStorage} from "../ChonkyNFTStorage.sol"; contract ChonkyProxy is Proxy, SafeOwnable { using ChonkyNFTStorage for ChonkyNFTStorage.Layout; using OwnableStorage for OwnableStorage.Layout; using ERC165Storage for ERC165Storage.Layout; event Upgraded( address indexed oldImplementation, address indexed newImplementation ); constructor( address implementation, address chonkyAttributes, address chonkyMetadata, address chonkySet ) { OwnableStorage.layout().setOwner(msg.sender); ChonkyNFTStorage.layout().implementation = implementation; { ERC721MetadataStorage.Layout storage l = ERC721MetadataStorage .layout(); l.name = "Chonkys"; l.symbol = "CK"; } { ChonkyNFTStorage.Layout storage l = ChonkyNFTStorage.layout(); l.chonkyAttributes = chonkyAttributes; l.chonkyMetadata = chonkyMetadata; l.chonkySet = chonkySet; } { ERC165Storage.Layout storage l = ERC165Storage.layout(); l.setSupportedInterface(type(IERC165).interfaceId, true); l.setSupportedInterface(type(IERC721).interfaceId, true); } } receive() external payable {} function _getImplementation() internal view override returns (address) { return ChonkyNFTStorage.layout().implementation; } function getImplementation() external view returns (address) { return _getImplementation(); } function setImplementation(address implementation) external onlyOwner { address oldImplementation = ChonkyNFTStorage.layout().implementation; ChonkyNFTStorage.layout().implementation = implementation; emit Upgraded(oldImplementation, implementation); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; library ERC721MetadataStorage { bytes32 internal constant STORAGE_SLOT = keccak256('solidstate.contracts.storage.ERC721Metadata'); struct Layout { string name; string symbol; string baseURI; mapping(uint256 => string) tokenURIs; } function layout() internal pure returns (Layout storage l) { bytes32 slot = STORAGE_SLOT; assembly { l.slot := slot } } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import { IERC165 } from '../../introspection/IERC165.sol'; import { IERC721Internal } from './IERC721Internal.sol'; /** * @notice ERC721 interface * @dev see https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721 is IERC721Internal, IERC165 { /** * @notice query the balance of given address * @return balance quantity of tokens held */ function balanceOf(address account) external view returns (uint256 balance); /** * @notice query the owner of given token * @param tokenId token to query * @return owner token owner */ function ownerOf(uint256 tokenId) external view returns (address owner); /** * @notice transfer token between given addresses, checking for ERC721Receiver implementation if applicable * @param from sender of token * @param to receiver of token * @param tokenId token id */ function safeTransferFrom( address from, address to, uint256 tokenId ) external payable; /** * @notice transfer token between given addresses, checking for ERC721Receiver implementation if applicable * @param from sender of token * @param to receiver of token * @param tokenId token id * @param data data payload */ function safeTransferFrom( address from, address to, uint256 tokenId, bytes calldata data ) external payable; /** * @notice transfer token between given addresses, without checking for ERC721Receiver implementation if applicable * @param from sender of token * @param to receiver of token * @param tokenId token id */ function transferFrom( address from, address to, uint256 tokenId ) external payable; /** * @notice grant approval to given account to spend token * @param operator address to be approved * @param tokenId token to approve */ function approve(address operator, uint256 tokenId) external payable; /** * @notice get approval status for given token * @param tokenId token to query * @return operator address approved to spend token */ function getApproved(uint256 tokenId) external view returns (address operator); /** * @notice grant approval to or revoke approval from given account to spend all tokens held by sender * @param operator address to be approved * @param status approval status */ function setApprovalForAll(address operator, bool status) external; /** * @notice query approval status of given operator with respect to given address * @param account address to query for approval granted * @param operator address to query for approval received * @return status whether operator is approved to spend tokens held by account */ function isApprovedForAll(address account, address operator) external view returns (bool status); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import { AddressUtils } from '../utils/AddressUtils.sol'; /** * @title Base proxy contract */ abstract contract Proxy { using AddressUtils for address; /** * @notice delegate all calls to implementation contract * @dev reverts if implementation address contains no code, for compatibility with metamorphic contracts * @dev memory location in use by assembly may be unsafe in other contexts */ fallback() external payable virtual { address implementation = _getImplementation(); require( implementation.isContract(), 'Proxy: implementation must be contract' ); assembly { calldatacopy(0, 0, calldatasize()) let result := delegatecall( gas(), implementation, 0, calldatasize(), 0, 0 ) returndatacopy(0, 0, returndatasize()) switch result case 0 { revert(0, returndatasize()) } default { return(0, returndatasize()) } } } /** * @notice get logic implementation address * @return implementation address */ function _getImplementation() internal virtual returns (address); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import { Ownable, OwnableStorage } from './Ownable.sol'; import { SafeOwnableInternal } from './SafeOwnableInternal.sol'; import { SafeOwnableStorage } from './SafeOwnableStorage.sol'; /** * @title Ownership access control based on ERC173 with ownership transfer safety check */ abstract contract SafeOwnable is Ownable, SafeOwnableInternal { using OwnableStorage for OwnableStorage.Layout; using SafeOwnableStorage for SafeOwnableStorage.Layout; function nomineeOwner() public view virtual returns (address) { return SafeOwnableStorage.layout().nomineeOwner; } /** * @inheritdoc Ownable * @dev ownership transfer must be accepted by beneficiary before transfer is complete */ function transferOwnership(address account) public virtual override onlyOwner { SafeOwnableStorage.layout().setNomineeOwner(account); } /** * @notice accept transfer of contract ownership */ function acceptOwnership() public virtual onlyNomineeOwner { OwnableStorage.Layout storage l = OwnableStorage.layout(); emit OwnershipTransferred(l.owner, msg.sender); l.setOwner(msg.sender); SafeOwnableStorage.layout().setNomineeOwner(address(0)); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; /** * @title ERC165 interface registration interface * @dev see https://eips.ethereum.org/EIPS/eip-165 */ interface IERC165 { /** * @notice query whether contract has registered support for given interface * @param interfaceId interface id * @return bool whether interface is supported */ function supportsInterface(bytes4 interfaceId) external view returns (bool); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; library ERC165Storage { struct Layout { mapping(bytes4 => bool) supportedInterfaces; } bytes32 internal constant STORAGE_SLOT = keccak256('solidstate.contracts.storage.ERC165'); function layout() internal pure returns (Layout storage l) { bytes32 slot = STORAGE_SLOT; assembly { l.slot := slot } } function isSupportedInterface(Layout storage l, bytes4 interfaceId) internal view returns (bool) { return l.supportedInterfaces[interfaceId]; } function setSupportedInterface( Layout storage l, bytes4 interfaceId, bool status ) internal { require(interfaceId != 0xffffffff, 'ERC165: invalid interface id'); l.supportedInterfaces[interfaceId] = status; } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import {EnumerableSet} from "@solidstate/contracts/utils/EnumerableSet.sol"; library ChonkyNFTStorage { bytes32 internal constant STORAGE_SLOT = keccak256("chonky.contracts.storage.ChonkyNFT"); struct Layout { address implementation; uint256 currentId; uint256[] genomes; // Offset IDs to randomize distribution when revealing uint256 offset; // Address of chonkyAttributes contract address chonkyAttributes; // Address of chonkyMetadata contract address chonkyMetadata; // Address of chonkySet contract address chonkySet; // Timestamp at which minting starts uint256 startTimestamp; } function layout() internal pure returns (Layout storage l) { bytes32 slot = STORAGE_SLOT; assembly { l.slot := slot } } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; /** * @notice Partial ERC721 interface needed by internal functions */ interface IERC721Internal { event Transfer( address indexed from, address indexed to, uint256 indexed tokenId ); event Approval( address indexed owner, address indexed operator, uint256 indexed tokenId ); event ApprovalForAll( address indexed owner, address indexed operator, bool approved ); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; library AddressUtils { function toString(address account) internal pure returns (string memory) { bytes32 value = bytes32(uint256(uint160(account))); bytes memory alphabet = '0123456789abcdef'; bytes memory chars = new bytes(42); chars[0] = '0'; chars[1] = 'x'; for (uint256 i = 0; i < 20; i++) { chars[2 + i * 2] = alphabet[uint8(value[i + 12] >> 4)]; chars[3 + i * 2] = alphabet[uint8(value[i + 12] & 0x0f)]; } return string(chars); } function isContract(address account) internal view returns (bool) { uint256 size; assembly { size := extcodesize(account) } return size > 0; } function sendValue(address payable account, uint256 amount) internal { (bool success, ) = account.call{ value: amount }(''); require(success, 'AddressUtils: failed to send value'); } function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, 'AddressUtils: failed low-level call'); } function functionCall( address target, bytes memory data, string memory error ) internal returns (bytes memory) { return _functionCallWithValue(target, data, 0, error); } function functionCallWithValue( address target, bytes memory data, uint256 value ) internal returns (bytes memory) { return functionCallWithValue( target, data, value, 'AddressUtils: failed low-level call with value' ); } function functionCallWithValue( address target, bytes memory data, uint256 value, string memory error ) internal returns (bytes memory) { require( address(this).balance >= value, 'AddressUtils: insufficient balance for call' ); return _functionCallWithValue(target, data, value, error); } function _functionCallWithValue( address target, bytes memory data, uint256 value, string memory error ) private returns (bytes memory) { require( isContract(target), 'AddressUtils: function call to non-contract' ); (bool success, bytes memory returnData) = target.call{ value: value }( data ); if (success) { return returnData; } else if (returnData.length > 0) { assembly { let returnData_size := mload(returnData) revert(add(32, returnData), returnData_size) } } else { revert(error); } } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import { IERC173 } from './IERC173.sol'; import { OwnableInternal } from './OwnableInternal.sol'; import { OwnableStorage } from './OwnableStorage.sol'; /** * @title Ownership access control based on ERC173 */ abstract contract Ownable is IERC173, OwnableInternal { using OwnableStorage for OwnableStorage.Layout; /** * @inheritdoc IERC173 */ function owner() public view virtual override returns (address) { return OwnableStorage.layout().owner; } /** * @inheritdoc IERC173 */ function transferOwnership(address account) public virtual override onlyOwner { OwnableStorage.layout().setOwner(account); emit OwnershipTransferred(msg.sender, account); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import { SafeOwnableStorage } from './SafeOwnableStorage.sol'; abstract contract SafeOwnableInternal { using SafeOwnableStorage for SafeOwnableStorage.Layout; modifier onlyNomineeOwner() { require( msg.sender == SafeOwnableStorage.layout().nomineeOwner, 'SafeOwnable: sender must be nominee owner' ); _; } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; library SafeOwnableStorage { struct Layout { address nomineeOwner; } bytes32 internal constant STORAGE_SLOT = keccak256('solidstate.contracts.storage.SafeOwnable'); function layout() internal pure returns (Layout storage l) { bytes32 slot = STORAGE_SLOT; assembly { l.slot := slot } } function setNomineeOwner(Layout storage l, address nomineeOwner) internal { l.nomineeOwner = nomineeOwner; } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; /** * @title Contract ownership standard interface * @dev see https://eips.ethereum.org/EIPS/eip-173 */ interface IERC173 { event OwnershipTransferred( address indexed previousOwner, address indexed newOwner ); /** * @notice get the ERC173 contract owner * @return conract owner */ function owner() external view returns (address); /** * @notice transfer contract ownership to new account * @param account address of new owner */ function transferOwnership(address account) external; }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import { OwnableStorage } from './OwnableStorage.sol'; abstract contract OwnableInternal { using OwnableStorage for OwnableStorage.Layout; modifier onlyOwner() { require( msg.sender == OwnableStorage.layout().owner, 'Ownable: sender must be owner' ); _; } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; library OwnableStorage { struct Layout { address owner; } bytes32 internal constant STORAGE_SLOT = keccak256('solidstate.contracts.storage.Ownable'); function layout() internal pure returns (Layout storage l) { bytes32 slot = STORAGE_SLOT; assembly { l.slot := slot } } function setOwner(Layout storage l, address owner) internal { l.owner = owner; } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; /** * @title Set implementation with enumeration functions * @dev derived from https://github.com/OpenZeppelin/openzeppelin-contracts (MIT license) */ library EnumerableSet { struct Set { bytes32[] _values; // 1-indexed to allow 0 to signify nonexistence mapping(bytes32 => uint256) _indexes; } struct Bytes32Set { Set _inner; } struct AddressSet { Set _inner; } struct UintSet { Set _inner; } function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) { return _at(set._inner, index); } function at(AddressSet storage set, uint256 index) internal view returns (address) { return address(uint160(uint256(_at(set._inner, index)))); } function at(UintSet storage set, uint256 index) internal view returns (uint256) { return uint256(_at(set._inner, index)); } function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) { return _contains(set._inner, value); } function contains(AddressSet storage set, address value) internal view returns (bool) { return _contains(set._inner, bytes32(uint256(uint160(value)))); } function contains(UintSet storage set, uint256 value) internal view returns (bool) { return _contains(set._inner, bytes32(value)); } function indexOf(Bytes32Set storage set, bytes32 value) internal view returns (uint256) { return _indexOf(set._inner, value); } function indexOf(AddressSet storage set, address value) internal view returns (uint256) { return _indexOf(set._inner, bytes32(uint256(uint160(value)))); } function indexOf(UintSet storage set, uint256 value) internal view returns (uint256) { return _indexOf(set._inner, bytes32(value)); } function length(Bytes32Set storage set) internal view returns (uint256) { return _length(set._inner); } function length(AddressSet storage set) internal view returns (uint256) { return _length(set._inner); } function length(UintSet storage set) internal view returns (uint256) { return _length(set._inner); } function add(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _add(set._inner, value); } function add(AddressSet storage set, address value) internal returns (bool) { return _add(set._inner, bytes32(uint256(uint160(value)))); } function add(UintSet storage set, uint256 value) internal returns (bool) { return _add(set._inner, bytes32(value)); } function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _remove(set._inner, value); } function remove(AddressSet storage set, address value) internal returns (bool) { return _remove(set._inner, bytes32(uint256(uint160(value)))); } function remove(UintSet storage set, uint256 value) internal returns (bool) { return _remove(set._inner, bytes32(value)); } function _at(Set storage set, uint256 index) private view returns (bytes32) { require( set._values.length > index, 'EnumerableSet: index out of bounds' ); return set._values[index]; } function _contains(Set storage set, bytes32 value) private view returns (bool) { return set._indexes[value] != 0; } function _indexOf(Set storage set, bytes32 value) private view returns (uint256) { unchecked { return set._indexes[value] - 1; } } function _length(Set storage set) private view returns (uint256) { return set._values.length; } function _add(Set storage set, bytes32 value) private returns (bool) { if (!_contains(set, value)) { set._values.push(value); set._indexes[value] = set._values.length; return true; } else { return false; } } function _remove(Set storage set, bytes32 value) private returns (bool) { uint256 valueIndex = set._indexes[value]; if (valueIndex != 0) { uint256 index = valueIndex - 1; bytes32 last = set._values[set._values.length - 1]; // move last value to now-vacant index set._values[index] = last; set._indexes[last] = index + 1; // clear last index set._values.pop(); delete set._indexes[value]; return true; } else { return false; } } }
{ "optimizer": { "enabled": true, "runs": 200 }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "libraries": {} }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address","name":"implementation","type":"address"},{"internalType":"address","name":"chonkyAttributes","type":"address"},{"internalType":"address","name":"chonkyMetadata","type":"address"},{"internalType":"address","name":"chonkySet","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"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":"oldImplementation","type":"address"},{"indexed":true,"internalType":"address","name":"newImplementation","type":"address"}],"name":"Upgraded","type":"event"},{"stateMutability":"payable","type":"fallback"},{"inputs":[],"name":"acceptOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getImplementation","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nomineeOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"implementation","type":"address"}],"name":"setImplementation","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"transferOwnership","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)
000000000000000000000000aec96ba634637f0b31cd3d42b8e259b8ecfcc054000000000000000000000000d35b3577859237e000e96da8fa447008bce69b0a000000000000000000000000f757ae9ff22beacd841f8eaaca09789801d2483b000000000000000000000000bfeeb6d89e7ee3dad94a02f11a384564ea372678
-----Decoded View---------------
Arg [0] : implementation (address): 0xaEc96bA634637f0B31cd3d42b8e259B8eCfcc054
Arg [1] : chonkyAttributes (address): 0xd35B3577859237e000e96Da8FA447008bcE69B0A
Arg [2] : chonkyMetadata (address): 0xf757Ae9FF22BEacd841f8EaACA09789801D2483B
Arg [3] : chonkySet (address): 0xbfEeb6d89E7ee3DAd94a02f11A384564eA372678
-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 000000000000000000000000aec96ba634637f0b31cd3d42b8e259b8ecfcc054
Arg [1] : 000000000000000000000000d35b3577859237e000e96da8fa447008bce69b0a
Arg [2] : 000000000000000000000000f757ae9ff22beacd841f8eaaca09789801d2483b
Arg [3] : 000000000000000000000000bfeeb6d89e7ee3dad94a02f11a384564ea372678
Loading...
Loading
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.