■ cryptopunks open source

every ethereum contract this site reads or writes, with the exact abi surface in use. addresses are mainnet.

■ CryptoPunksMarket

0xb47e3cd837dDF8e4c57F05d70Ab865de6e193BBB

the marketplace contract deployed by Larva Labs in june 2017. tracks ownership, listings, bids, and pending balances. all buy / bid / transfer flows on the home page hit this contract.

▸ view functions (11 read · 9 write)

■ read functions

  • name() → (string)

    ERC-20-style token name (“CRYPTOPUNKS”).

  • symbol() → (string)

    Token symbol (“C”).

  • imageHash() → (string)

    SHA-256 of the original 10,000-Punks composite PNG, fixed at deploy.

  • totalSupply() → (uint256)

    Total Punks ever minted (10,000).

  • punksRemainingToAssign() → (uint256)

    Punks not yet claimed during the original 2017 distribution. Should be 0 today.

  • nextPunkIndexToAssign() → (uint256)

    Internal pointer used during initial assignment. Vestigial post-2017.

  • punkIndexToAddress(uint256) → (address)

    Current owner of a given Punk index.

  • balanceOf(address) → (uint256)

    Number of Punks held by an address.

  • punksOfferedForSale(uint256) → (bool isForSale, uint256 punkIndex, address seller, uint256 minValue, address onlySellTo)

    Active sale listing for a Punk (isForSale, seller, minValue, optional onlySellTo).

  • punkBids(uint256) → (bool hasBid, uint256 punkIndex, address bidder, uint256 value)

    Top standing bid for a Punk (hasBid, bidder, value).

  • pendingWithdrawals(address) → (uint256)

    ETH owed to an address from sales / outbid refunds. Claim with withdraw().

■ write functions

  • offerPunkForSale(uint256 punkIndex, uint256 minSalePriceInWei)

    Owner lists a Punk at a minimum sale price in wei.

  • offerPunkForSaleToAddress(uint256 punkIndex, uint256 minSalePriceInWei, address toAddress)

    Owner lists a Punk to a specific buyer at a minimum price.

  • punkNoLongerForSale(uint256 punkIndex)

    Owner cancels their active sale listing.

  • buyPunk(uint256 punkIndex) [payable]

    Anyone can take a Punk that’s for sale by sending ≥ minValue.

  • enterBidForPunk(uint256 punkIndex) [payable]

    Place a bid in ETH; previous top bidder is refunded into pendingWithdrawals.

  • acceptBidForPunk(uint256 punkIndex, uint256 minPrice)

    Owner accepts the current top bid (must specify a minimum acceptable price).

  • withdrawBidForPunk(uint256 punkIndex)

    Bidder cancels their bid and reclaims the locked ETH.

  • transferPunk(address to, uint256 punkIndex)

    Owner transfers a Punk to another address. No payment.

  • withdraw()

    Pull all ETH owed to msg.sender out of pendingWithdrawals.

■ CryptopunksData

0x16F5A35647D6F03D5D3da7b35409D65ba03aF3B2

onchain image & attribute data, added by Larva Labs in 2021. returns a punk’s pixel art as an svg and its trait list as a comma-separated string — the source for the rendered punk on the home page.

// interact

▸ view functions (2 read · 0 write)

■ read functions

  • punkImageSvg(uint16 index) → (string svg)

    Render a Punk as an inline SVG (24×24 viewBox). Returns a data:image/svg+xml URL.

  • punkAttributes(uint16 index) → (string text)

    Comma-separated list of attributes. First entry is the head type (Male, Female, Zombie, Ape, Alien).

■ WrappedPunks (WPUNKS) — legacy

0xb7F7F6C52F2e2fdb1963Eab30438024864c313F6

the original third-party erc-721 wrapper. to wrap, call registerProxy() once, transfer the punk to the resulting proxy, then call mint(punkIndex). holders are encouraged to migrate to the newer cryptopunks721 below via migrateLegacyWrappedPunks.

▸ view functions (16 read · 13 write)

■ read functions

  • name() → (string)

    ERC-20-style token name (“CRYPTOPUNKS”).

  • symbol() → (string)

    Token symbol (“C”).

  • totalSupply() → (uint256)

    Total Punks ever minted (10,000).

  • balanceOf(address owner) → (uint256)

    Number of Punks held by an address.

  • ownerOf(uint256 tokenId) → (address)

    ERC-721 owner of a wrapped Punk token.

  • tokenURI(uint256 tokenId) → (string)

    Metadata URI for a wrapped token (concatenates baseURI + id).

  • baseURI() → (string)

    Current base for tokenURI(); set by the contract owner.

  • tokenByIndex(uint256 index) → (uint256)

    ERC-721 enumerable: token ID at the global index.

  • tokenOfOwnerByIndex(address owner, uint256 index) → (uint256)

    ERC-721 enumerable: nth token held by a given owner.

  • getApproved(uint256 tokenId) → (address)

    ERC-721 single-token approval target.

  • isApprovedForAll(address owner, address operator) → (bool)

    ERC-721 operator approval status.

  • supportsInterface(bytes4 interfaceId) → (bool)

    EIP-165 interface check.

  • proxyInfo(address user) → (address)

    Returns the UserProxy address for a given user, or 0x0 if not registered.

  • punkContract() → (address)

    Address of the underlying CryptoPunksMarket this wrapper is bound to.

  • owner() → (address)

    Current contract owner (Ownable).

  • paused() → (bool)

    Whether the contract is currently paused.

■ write functions

  • registerProxy()

    One-time setup: deploys a UserProxy contract for msg.sender. The Punk must be transferred to this proxy before mint().

  • mint(uint256 punkIndex)

    Wrap a Punk: caller's UserProxy must already hold punkIndex. Mints a matching ERC-721 token to the caller.

  • burn(uint256 punkIndex)

    Unwrap: burns the WPUNK and returns the underlying Punk to msg.sender.

  • approve(address to, uint256 tokenId)

    ERC-721 approve another address to transfer a single token.

  • setApprovalForAll(address to, bool approved)

    ERC-721 grant/revoke an operator over all of caller's tokens.

  • transferFrom(address from, address to, uint256 tokenId)

    ERC-721 transfer (no receiver-hook check).

  • safeTransferFrom(address from, address to, uint256 tokenId)

    ERC-721 transfer with onERC721Received hook on contract recipients.

  • safeTransferFrom(address from, address to, uint256 tokenId, bytes _data)

    ERC-721 transfer with onERC721Received hook on contract recipients.

  • setBaseURI(string baseUri)

    Owner-only: update the tokenURI base.

  • pause()

    Owner-only: halt mint / burn / transfer.

  • unpause()

    Owner-only: resume operations.

  • transferOwnership(address newOwner)

    Owner-only: hand ownership to another address.

  • renounceOwnership()

    Owner-only: drop ownership permanently (sets owner to 0x0).

■ CryptoPunks721

0x000000000000003607fce1aC9e043a86675C5C2F

the current canonical erc-721 wrapper for cryptopunks. supports single and batch wrap / unwrap, direct migration from the legacy wpunks, and a rescuePunk path for punks sent here by mistake. each user gets a per-address proxy via punkProxyForUser; transfer the punk to that proxy, then call wrapPunk.

▸ view functions (12 read · 11 write)

■ read functions

  • name() → (string)

    ERC-20-style token name (“CRYPTOPUNKS”).

  • symbol() → (string)

    Token symbol (“C”).

  • licensingTerms() → (string)

    Onchain pointer to the CryptoPunks license text.

  • totalSupply() → (uint256)

    Total Punks ever minted (10,000).

  • balanceOf(address owner) → (uint256)

    Number of Punks held by an address.

  • ownerOf(uint256 id) → (address)

    ERC-721 owner of a wrapped Punk token.

  • tokenURI(uint256 tokenId) → (string)

    Metadata URI for a wrapped token (concatenates baseURI + id).

  • tokensOfOwner(address owner) → (uint256[])

    All token IDs an address currently holds.

  • punkProxyForUser(address user) → (address)

    User's per-address proxy that holds Punks before wrapping. CryptoPunks721 deploys these on demand.

  • getApproved(uint256 id) → (address)

    ERC-721 single-token approval target.

  • isApprovedForAll(address owner, address operator) → (bool)

    ERC-721 operator approval status.

  • supportsInterface(bytes4 interfaceId) → (bool)

    EIP-165 interface check.

■ write functions

  • wrapPunk(uint256 punkIndex)

    Wrap a single Punk into a CryptoPunks721 token. Caller must have transferred the Punk to their punkProxyForUser first.

  • wrapPunkBatch(uint256[] punkIndexes)

    Wrap many Punks in one transaction.

  • unwrapPunk(uint256 punkIndex)

    Burn the ERC-721 and return the underlying Punk to the holder.

  • unwrapPunkBatch(uint256[] punkIndexes)

    Unwrap many Punks at once.

  • migrateLegacyWrappedPunks(uint256[] punkIndexes)

    Bulk-migrate WPUNKS (the 0xb7F7… legacy wrapper) into CryptoPunks721 tokens.

  • rescuePunk(uint256 punkIndex)

    Recover a Punk transferred directly to this contract by mistake.

  • approve(address account, uint256 id) [payable]

    ERC-721 approve another address to transfer a single token.

  • setApprovalForAll(address operator, bool isApproved)

    ERC-721 grant/revoke an operator over all of caller's tokens.

  • transferFrom(address from, address to, uint256 id) [payable]

    ERC-721 transfer (no receiver-hook check).

  • safeTransferFrom(address from, address to, uint256 id) [payable]

    ERC-721 transfer with onERC721Received hook on contract recipients.

  • safeTransferFrom(address from, address to, uint256 id, bytes data) [payable]

    ERC-721 transfer with onERC721Received hook on contract recipients.

■ StashFactory

0x000000000000A6fA31F5fC51c1640aAc76866750

factory that deploys per-owner stash contracts at deterministic addresses. users call deployStash to create their stash, then upgradeStash to opt into newer implementations. also maintains a registry of valid stashes (isStash) and an allow-list of auction venues (isAuction).

// interact

connect a wallet to deploy your own stash.
▸ view functions (12 read · 12 write)

■ read functions

  • currentVersion() → (uint256)

    Index of the latest registered stash implementation.

  • implementations(uint256 version) → (address implementation)

    Implementation address for a given version index.

  • stashAddressFor(address stashOwner) → (address)

    Deterministic stash address for an owner, whether or not it has been deployed yet.

  • ownerHasDeployed(address owner) → (bool)

    Whether an owner has already deployed their Stash via this factory.

  • isStash(address stashAddress) → (bool)

    Registry check: was this address deployed by the factory?

  • isAuction(address auctionAddress) → (bool)

    Whether an address is on the factory's auction allow-list. Used by stashes to validate counterparties.

  • stashVerifier() → (address)

    Address of the off-chain verifier component the factory points stashes at.

  • owner() → (address result)

    Current contract owner (Ownable).

  • ownershipHandoverExpiresAt(address pendingOwner) → (uint256 result)

    Expiration timestamp of a pending two-step handover request (Solady Ownable).

  • rolesOf(address user) → (uint256 roles)

    Bitmask of roles held by a user.

  • hasAllRoles(address user, uint256 roles) → (bool)

    Whether a user has every role in the given bitmask.

  • hasAnyRole(address user, uint256 roles) → (bool)

    Whether a user has at least one role in the bitmask.

■ write functions

  • deployStash(address _owner) → (address deployedAddress)

    Deploy a new Stash for the given owner (CREATE2-style — predictable address via stashAddressFor).

  • upgradeStash()

    Caller-initiated: upgrade msg.sender's stash to the latest registered implementation.

  • addVersion(address implementation)

    Owner-only: register a new stash implementation as the current version.

  • setAuction(address auction, bool _isAuction)

    Owner-only: flip an address on/off the auction allow-list.

  • transferOwnership(address newOwner) [payable]

    Owner-only: hand ownership to another address.

  • renounceOwnership() [payable]

    Owner-only: drop ownership permanently (sets owner to 0x0).

  • requestOwnershipHandover() [payable]

    Caller opts into a two-step ownership handover from the current owner.

  • completeOwnershipHandover(address pendingOwner) [payable]

    Owner finalizes a previously requested handover to pendingOwner.

  • cancelOwnershipHandover() [payable]

    Caller cancels their own pending handover request.

  • grantRoles(address user, uint256 roles) [payable]

    Owner grants a role bitmask to a user (Solady OwnableRoles).

  • revokeRoles(address user, uint256 roles) [payable]

    Owner removes a role bitmask from a user.

  • renounceRoles(uint256 roles) [payable]

    Caller drops their own roles.

■ Stash

per-owner address — look yours up via the factory panel above.

the per-owner contract deployed by the factory above. holds the owner's liquidity and resting orders, and accepts signed processPunkBid calls from allow-listed auctions.

// process a punk bid

signed punk bids are produced off-chain and submitted onchain by the bid's target auction (order.auction). this form helps you shape the call — paste the JSON below and verify the decoded fields before sending.

connect a wallet to submit the call.
▸ view functions (7 read · 3 write)

■ read functions

  • owner() → (address)

    Current contract owner (Ownable).

  • version() → (uint256)

    Implementation version of this stash.

  • availableLiquidity(address tokenAddress) → (uint256 availableAmount)

    ETH/ERC-20 currently free for new bids on this stash, after subtracting locked balances.

  • getOrder(address auction) → (tuple order)

    Active resting order this stash exposes to a given auction (numberOfUnits, pricePerUnit, auction).

  • punkAccountNonce() → (uint56)

    Current account nonce. Bumped to invalidate every outstanding bid in one shot.

  • punkBidNonceUsesRemaining(uint256 punkBidNonce) → (uint256 usesRemaining)

    How many fills are still allowed for a given bidNonce before it's exhausted.

  • usedPunkBidNonces(uint256 punkBidNonce) → (bool isUsed)

    Whether a specific bidNonce has been fully consumed.

■ write functions

  • processPunkBid(tuple bid, uint256 punkIndex, bytes signature, bytes32[] proof)

    Auction-only: present a signed PunkBid + Merkle proof for a punk and have the stash pay for it.

  • cancelPunkBid(uint256 bidNonce)

    Owner cancels a single bid by its bidNonce.

  • cancelAllPunkBids()

    Owner bumps the account nonce, invalidating every outstanding bid at once.