Read, render, retune.
Every Ousia token can be read, rendered, and adjusted through the Ethereum contract. This website is an interface. From a block explorer, you can verify metadata, inspect Punk-derived data, render the HTML artwork, update owner display settings, and advance the mint directly after commit.
The tokenURI(tokenId) function returns the token's complete metadata as a base64-encoded JSON data URI. It includes the standard fields read by marketplaces — name, description, attributes — along with two fields that carry the artwork itself: image and animation_url.
The image field contains the static SVG preview, generated in Solidity. The animation_url field contains the animated artwork as a self-contained HTML page, inlined as a data:text/html URI. Both are returned directly by the contract. The metadata does not reference IPFS, an external server, or a gateway. If Ethereum is accessible, the artwork is accessible.
The Ousia contract stores the palettes and pixel counts for all 10,000 Punks on-chain. getPunkData(tokenId) returns the data for a given Ousia token in one call: color count, pixel count, and the exact HEX palette associated with its source Punk.
This data is public and requires no wallet to read. It appears in the token metadata and is used by the contract to generate the Solidity SVG preview.
// Read Contract → 31. getPunkData getPunkData(4067) // returns → 0. numColors uint8 : 14 1. numPixels uint16 : 193 2. colorIndices uint8[13] : 12,51,52,120,70,71,121,55,56,123,13,22,72 3. hexColorsJSON string : ["#000000","#DBB180","#1A43C8","#1637A4", …]
For any minted Ousia token, getHTML(tokenId) returns a complete, self-contained HTML page: the p5.js library, the Ousia script, and the Punk data assembled on-chain into a single file. Save it as .html and open it in any browser. Once saved, the artwork can run locally, without the website.
You can also use the animation_url returned by tokenURI(tokenId). It is already a runnable data:text/html;base64,… URI. Copy it into your browser’s address bar, and the animation opens directly.
Enter an Ousia ID. We'll call the on-chain getHTML and hand you the finished file — preview or download it and open offline. No server touched.
Fetch the full on-chain HTML, then save it or open it — it runs offline, forever.
Each Ousia token has owner controls stored on-chain. They do not change the core artwork; they define how it is displayed — whether the original Punk sprite is shown, whether the glowing sphere layer is enabled, and what canvas resolution is used.
On Etherscan, open Write Contract and connect the wallet that owns the token. Call setSettings(tokenId, size, showPunk, showSphere) to update all settings in one transaction. To change one setting at a time, use setCanvasSize, setShowPunk, or setShowSphere individually. Each update requires a signed transaction and is stored on-chain for that token.
Paste these exact arguments into the settings fields on Etherscan, then sign the transaction.
setSettings( tokenId 4067 size 800 showPunk true showSphere true )
A compact map of the functions worth knowing. Read functions are open to anyone and do not require a wallet. Write functions require the connected wallet to own the token and submit a transaction.
After you commit, the mint becomes an open process. The contract has recorded your mint request and reserved the number of tokens, but no token ID has been assigned yet.
Everything after commit is permissionless and deterministic. A keeper normally runs these calls, but it has no special authority. It only calls public functions on time. Anyone can carry a mint to completion directly from the contract.
When your round ends, its final blockhash becomes the assignment seed. That seed does not exist when you commit, so no one can predict or steer the outcome in advance. From there, the mechanism is public: captureRoundSeed and resolveCommits settle the round, then reveal mints the assigned tokens to the original committer.
Everything needed to settle and finish a mint from the contract is here.
When you commit, the contract emits Committed(commitId, minter, amount, round). The commitId is your reference for everything that follows; you can find it in your transaction logs on the block explorer.
Read commits(commitId) to inspect the current status of your commit: minter, amount, round, resolved, and revealed. Once the round has been settled, getCommitTokens(commitId) returns the exact token IDs assigned to that commit.
nextCommitToResolve and nextCommitId show how far the commit queue has advanced, so you can see whether your commit is still waiting or has already been processed.
Once the round has closed, it can be settled in two steps. captureRoundSeed(round), using the round from your commit, records the round-end blockhash as the assignment seed. Then resolveCommits(maxCount) walks the commit queue in order and assigns token IDs to queued commits using that seed, up to maxCount commits per call.
Any wallet can call these functions. No token ownership or allowlist status is required. If the keeper has not run them yet, you can run them yourself. Each call is a single transaction; call resolveCommits again to continue a long queue.
Once token IDs have been assigned, reveal is the final step. reveal(commitId) mints that commit's Ousia tokens to the original committer. Anyone can call it — for themselves or for someone else — but the tokens always go to the committer's wallet, never the caller's. revealMany(commitIds) reveals multiple commits in a single transaction.
After reveal, the Ousia token exists on-chain. From there, it can be verified, rendered, and retuned using the sections above.
A blockhash can only be read for about 256 blocks. If a round was not settled in time and its seed block is no longer available, reanchorRound(round) moves the round to a fresh future block. After that, it can be settled normally.
Until a valid seed exists, no assignments can be resolved. The mint waits; it does not guess.
Ousia does not depend on a website.
The site is an interface. Marketplaces are interfaces. The contract is where the work is stored, rendered, and controlled. This page only translates what is already available on-chain.