Not Argonauts: Argonauts Decoded and Recomputed
9,999 Argonauts were originally deployed fully onchain by ACK. No IPFS, no server, no off-chain metadata: 78 sprites packed into contract bytecode via SSTORE2, palette tables plus run-length encoded rows, reassembled into ~200 SVG rects by the EVM on every tokenURI call. The contract says it itself: “The digital lives here, inside the contract, forever.” Bet. We took that literally. We reversed the renderer, extracted the full trait table from raw storage, recovered the generation ruleset from 9,999 rows of evidence, and computed the supply the machine could always draw but never minted. Grails shipped in the deploy and never touched. Backgrounds no Argonaut can ever render. Then we mirrored the canvas. Same bytecode, opposite direction, zero collisions. Not a derivative. The other half of the machine.
DECODE
No API. No snapshot. No handshake with the team. The whole thing came off the chain itself, in five moves:
Probe the renderer
render(uint8[7]) is public view. Raw indices in, SVG out, no token gate, no msg.sender check: the whole combination space composites via eth_call for free. Out-of-range indices revert with "trait index out of range", and a revert is data. Binary-search the revert boundary per layer and the layout table gives up its cardinalities: 34, 10, 6, 2, 15, 3, 8. Verified source later matched every count. The machine snitched on itself.
Isolate by diff
A compositing renderer never exposes a layer, so we diffed them out. Render the all-zero baseline, mutate one index, XOR the rasters: the changed pixel set is that trait’s exact footprint at native 24x24, occlusion and all. This is how a trait with a 2 pixel footprint got caught riding 34.84% of the parent supply. Two pixels. A third of the collection.
Decode the sprites from bytecode
The art is not files. Each sprite is an SSTORE2 data contract: a STOP byte, a 2 byte big-endian palette count, N RGBA entries, then (colourIndex uint16, runLength uint8) tuples, row-major across a 24x24 grid. We pulled all 78 via extcodecopy and wrote our own decoder. One footgun, documented because it bit: the colour index is one-based, ci == 0 is transparent and entry k lives at offset 2 + (k-1)*4. Decode it zero-based and every colour shifts one palette slot while still looking plausible. Only diffing our decode against the SVG the contract actually emits caught it. Verify, don’t vibe.
Read the whole trait table
The parent packs 7 bytes per token into three frozen SSTORE2 chunks, 3,400 tokens per chunk, sized under the EIP-170 limit. Six eth_calls and the entire population is local: 9,999 rows, 69,993 bytes. Then receipts: 40 live traitsOf calls replayed against our copy, including every rare-palette token in existence, 40 of 40 byte-identical. Every rarity figure on this page is the full population read from storage. Not a sample, not an indexer, not an API. The chain.
Reverse the generator
With the full table local, the ruleset falls out of the joint distribution: 33 forced implications (any Cloak implies no Crown: 2,429 rows, zero exceptions), 80 hard exclusions (Void ground x black Eye Patch: expected co-occurrence 76, observed 0, invisible art was vetoed at generation time), 2 locked biconditionals (Radioactive body iff Radioactive ground, 25 of 25 both directions). Order analysis on the table: adjacent-row correlation matches i.i.d., rare traits spread the full id range, so the parent was sampled per row and shuffled, not seeded-walked. Our extracted spec re-validates all 9,999 parent rows with zero violations. We did not guess the meta. We recovered it.
ALPHA FROM THE CONTRACT
The gap between what the contract can draw and what the collection minted is the whole play. That gap has been sitting in verified bytecode since deploy, in plain sight, waiting for someone to actually read it.
Finished art, onchain since day one, minted zero times. Yellow, Wine, Ancient, Emerald and Paper White: five backgrounds with working sprites and a supply of nothing. Sight “Designer” and a second “Eye Patch”, same story. The parent renderer is locked forever, so on Argonauts these stay unmintable until the heat death of the chain. On Not Argonauts they are live grails.
Two orphan gradients, the hardest art in the contract, wired to nothing. Blobs 7 and 10: full 576 pixel canvases, 348 colours each, the only per-pixel backgrounds in a collection of flat fills. The layout table never points at them. No Argonaut has ever shown one and none ever can. We wired them in as palette slots 21 and 22, Ice Prism and Dawn Prism, four tokens each. Eight tokens total carrying art the parent collection is physically incapable of rendering.
RECOMPUTE
Run the full space over live traits: 1,166,400 combinations. The extracted rules execute 1,044,258 of them on sight. 122,142 survive as legal. The parent minted 9,999. That leaves 112,143 combinations the machine was always allowed to draw and never did: the ghost supply. Not Argonauts is drawn from exactly there. Every row rule-legal, every row absent from the parent, checked row by row against all 9,999 originals. Zero collisions. You cannot mint an Argonaut here and nobody can mint your Not Argonaut there.
The rarity is authored, not inherited. A lazy uniform draw would have made the recovered grails the most common traits in the collection, flipping the entire meta upside down. So the curve is pinned in tiers, base weights lifted from the parent’s own frequencies so the rarity language transfers:
| Tier | Traits | Pinned | Why |
|---|---|---|---|
| 0 · Orphans | Ice Prism, Dawn Prism | 4 each | art the parent is physically incapable of rendering |
| 1 · Recovered | Yellow, Wine, Ancient, Emerald, Paper White | 45 each | shipped at deploy, minted never |
| 1 · Recovered | Designer, the second Eye Patch | 60 each | same, eyewear |
| 2 · Inherited grails | Alien 9 · Radioactive 25 · Gold 88 | parent scale | so the parent rarity meta transfers 1:1 |
| 3 · Everything else | the other 60-odd traits | floats | quota-fit to the parent curve |
All pins land exact. Then a Fisher-Yates shuffle over the finished table, because rows leave the sampler with the grails clustered at the front, and a starting index at mint can only rotate an array, never unsort it. No snipeable mint order, no rarity clumped in the first hundred tokens. The whole generation is seeded and reproducible from not-argonauts-v1: run it yourself, get the same 70,000 bytes.
SOURCE
The tell: every Not Argonaut faces the other way. Not a re-render, not an edit, a mathematical mirror of the exact same sprite data, and it is provably lossless. We scanned every run in every blob first: 6,423 runs, zero crossing a row boundary, which makes the flip one line of code, x = 24 - x - run. A pixel permutation. Nothing resampled, nothing redrawn, nothing lost. Argonauts sail one way. Not Argonauts sail back.
Then we proved it where it counts: on a mainnet fork against the live parent renderer. Same combos through both contracts, rasterised, compared cell against mirrored cell. Zero mismatched pixels. And the orphan gradients draw: 41,756 bytes of rects out of our renderer where the parent returns a bust floating on nothing.
VERIFY, DONT TRUST.
Two contracts, one dependency, zero uploaded art. The Not Argonauts renderer reads the parent’s 78 sprite contracts directly, the same immutable data the parent draws from. Those are inert: a stop byte then raw bytes, no owner, no admin key, no callable surface, unchangeable while Ethereum exists. The parent’s renderer is not in our dependency chain at all. Nobody can rug the art, including us. Your Not Argonaut renders as long as the chain does.
The parent’s grain pass, three seeded specks of texture per token, is deliberately omitted. The grain was made for the physical prints. There are no prints. This is the digital-native half of the machine and it does not pretend otherwise.
DYOR made easy: every figure above was read from deployed bytecode or a live call, and both Not Argonauts contracts are verified. Parent 0x387c41b0…392c, parent renderer 0x7f277a7d…8597, Ethereum mainnet. Read it yourself. That is the entire point.