4,200 fully on-chain generative dies on Robinhood Chain. To mint, your machine searches for a nonce whose keccak hash clears the floor — the winning hash is your die's seed, your difficulty is your bin grade, and the contract re-verifies the work forever. No allowlist. No approvals. No price — the work is the payment, and the mint function cannot even receive ETH. No server. Trust nothing; verify everything.
Paste to / value / data into any wallet's send screen. Value is 0 — always. This page never touches your keys, never sees a signature, and could vanish tomorrow — your mint still works.
Adds/switches to chain 4663 and sends the exact packet on the left via eth_sendTransaction — connection grants nothing beyond filling your address. Disabled until deployment.
This contract has no owner.
Not renounced. Never existed.
Everything after deploy is you, the chain, and 8,966 bytes of verified source anyone can read in a sitting. Full claim-by-claim receipts in the trust ledger.
Every die occupies a fixed public seat on a single 67×67 wafer (siteOf(id), a pure function anyone can verify). As dies are fabbed, this map fills in — the collection is one collective artwork built by the crowd, in real time, with zero trust required. A cell turns magenta when that die burns out on an overclock push.
Overclock headroom is fixed by your die's seed — decided the instant you mined it. Reading the source lets anyone precompute it; most won't. The lottery already happened at fab time. Push and find out.
A top-bin die with full headroom (3) physically cannot burn — a fourth overclock is impossible. The best silicon earns immortality; the fragile 14nm commons die on the first hard push, exactly like real trench-grade parts.
The hash binds to your address — a nonce mined for one wallet is worthless to any other, so nothing can be stolen in flight. Every winning hash mints exactly once, ever. The renderer runs inside tokenURI: mint stores only (minter, nonce); the art is recomputed by the chain itself, free, forever.
The only payable function is mint(uint256 nonce). The contract never asks for Approve / SetApprovalForAll / Permit. Check: read the verified source — the words don't appear in the mint path.
Your address is inside the hashed preimage. Check: recompute any minted token's hash yourself in the Verify terminal below — two machines, one truth.
usedSeed[hash] makes every proof single-use. Check: try replaying a used nonce on a fork; it reverts.
Minting is free and mint(uint256) is nonpayable — a transaction carrying ETH reverts, and receive() reverts too. Check: the function signature in verified source. Corollary: anyone asking you to pay to mint is a scam, by definition.
The constructor mints nothing. No genesis allocation, no reserve, no team dies, no allowlist. At deploy the collection is empty and the deployer owns exactly as much of it as you do: nothing. Check: call minted() before the mine opens — it returns 0.
There are no exempt tokens, so verify(id) re-runs the proof-of-work for every die in the collection from its stored (minter, nonce). Nothing in this contract can exist without work.
Minting opens automatically at OPEN_AT = deploy + 48h, an immutable timestamp baked into the constructor: 48 hours for anyone to read the code, then the mine opens on its own. No open function, no close function, no switch for anyone to flip — ever.
No Ownable, no onlyOwner, no withdraw, no rescue, no pause, no upgrade, no proxy, no setURI, no renderer swap. Check: grep the verified source for owner — the concept is absent. The deploy transaction is the last deployer action in the contract's life; the renderer is immutable from block one.
Wafer sites are a fixed public bijection of tokenId — siteOf(id) = id·2741 mod 67², a constant in the verified source. No salt, no reveal, no team liveness required. Coordinates carry zero rarity weight, so timing a mint for a pretty seat is sport, not an exploit.
Source verified exact-match on the chain explorer and Sourcify — links go live at deployment ceremony.
If the primary art renderer ever failed for some seed, tokenURI falls through to an immutable, ownerless fallback renderer that serves schema-valid metadata and a recovery image. Tested against a deliberately reverting primary. Your token can lose its portrait; it can never lose its identity.
Every die is drawn inside tokenURI by four ownerless, immutable contracts — no IPFS, no image host, no API. Check: call renderSVG yourself and compare bytes. QC before deploy: all 4,200 dies rendered plus 644 adversarial cases, zero failures.
Static file, no cookies, no tracking, no backend. Everything below also works as raw JSON-RPC you can paste anywhere. The canonical mint is the contract, not this site.
// calls verify(id) on-chain (free eth_call), then recomputes the proof-of-work // locally with the same keccak this page mines with, and compares. // PROTOTYPE: contract not deployed — this terminal activates at ceremony.
Allocation note: there is none. No premint, no reserve, no founder allocation, no allowlist, no special ids. Token #1 belongs to whoever mines it first. The deployer address receives an immutable ERC-2981 royalty on secondary sales and nothing else — it holds no tokens at deploy and has no power over the contract. Check it yourself: minted() is 0 until the mine opens.