You mine it or you don't have one.

What you are mining

There are 21,000 pieces and no way to buy one into existence. A piece appears only when somebody's machine finds a hash below the current target. Nobody was allocated any, there was no presale, and the contract has no owner who could mint one.

The image is not stored anywhere. It is computed by the contract from the hash that created it, every time anyone asks. If this website vanishes the pieces are unaffected.

What your machine actually does

It hashes four values together, over and over:

keccak256(your address, nonce, previous piece's work, anchor)

Almost every result is above the target and is thrown away. One eventually is not, and that one buys you a piece. A near miss is worth exactly as much as a bad one: nothing carries over between attempts.

Your address is inside the hash, so a solution belongs to you alone. Nobody can copy it out of a transaction and use it. The previous piece's work is in there too, so nothing can be computed in advance, and the moment anyone mints, every solution being held anywhere becomes worthless.

The anchor, and why solutions expire

The fourth value is the hash of a recent block, read through ArbSys.arbBlockHash. The contract accepts one from the last 192 blocks, which is about 19 seconds. After that a solution is dead and the search starts again against a fresh anchor.

This is why the miner restarts every few seconds. It is not wasted work. Every attempt is independent, so restarting costs nothing in expectation, and it guarantees a solution always has time left to reach the chain.

Difficulty

Difficulty is a full 256 bit target, not a count of leading zeros. That matters: with whole bits the smallest possible change is a doubling, so a network running 1.5 times too fast could not be corrected at all without overshooting. A full target is adjusted proportionally, so a 1.5x error is answered by exactly 1.5x.

Three things set it, in this order:

• The epoch floor. The easiest the target may ever be. It starts at 32 bits and rises 3 bits at each of the ten epochs of 2,100 pieces. It never goes back down.
• The retarget. Every 8 pieces the contract compares the real pace against one piece per three minutes and scales the target by the ratio, at most four times harder or twice easier in one step.
• The streak. Each recent mint tightens the target further and cools off one step at a time. At the intended pace it decays to nothing between pieces, so it only bites during a burst.

There is also a failsafe: after ten minutes with nothing mined, the floor may be broken by exactly one epoch and no more.

The wall

The floor is a ratchet, and it rises whether or not anyone can keep up. While the network can afford the current floor the retarget holds the pace near three minutes. Once it cannot, the pace degrades and does not recover, and each further epoch multiplies the work by eight.

So the collection ends where the mining does, not at a supply cap. Most of the 21,000 will probably never exist. That is the design, not a flaw in it.

The picture

Once a solution lands, the contract hashes it again together with the clock rounded down to five minutes, and that number is the seed. Spare hashrate therefore cannot be spent hunting for a piece you like: work buys leading zeros and nothing else.

From the seed come a density threshold, a grain, and two flags:

• Grain is how coarse the noise is: Fine at one cell per pixel is 70% of the collection, then Medium 20%, Blocky 8%, and Coarse, at eight pixels a cell, 2.3%.
• Field is inverted on one piece in eight.
• Symmetry is mirrored on one in sixteen.
• Ink is how much of the 1,024 cells are filled, from nearly empty to nearly solid.
• Work records how many leading zeros the winning hash actually had, which is usually more than was required.

What it costs

The nth piece costs n times 0.0000005 ETH, so the first is free and the 2,100th is about 0.001 ETH. Payment is forwarded to a treasury address fixed at deployment, in the same transaction, and anything you overpay comes straight back. The contract never holds a balance and has no withdraw function, because it never keeps anything to withdraw.

A 5% royalty on secondary sales is declared through ERC-2981 to the same address. That is a declaration marketplaces read, not something this contract can enforce; many honour it, some do not.

CPU and GPU

The CPU miner runs keccak across your cores in web workers. The GPU miner runs the same hash as a WebGPU compute shader, which is typically a few hundred times faster.

The card is never trusted. It reports candidate nonces, not hashes, and every one is recomputed here before it can become a transaction. A card that keeps disagreeing is dropped and mining continues on your cores. An overclocked or faulty GPU can waste your time; it cannot spend your money.

Things worth knowing before you mine

• The contract is unaudited and immutable. There is no owner, no upgrade path, and no refunds.
• At low difficulty a miner with a lot of spare hashrate can find several valid solutions inside one anchor window and submit whichever makes a piece they prefer. Higher difficulty closes this quickly, but it is open early on.
• Every mint costs gas whether or not it lands, and a solution can be beaten to the chain by somebody else.
• Most of the collection will never be mined.