How it works
Hashbits is one ERC-721 contract that mints Hashbits Monsters. Nothing here is sold ready made: the only way a Monster comes into existence is a hash below the current target, paid for at the entry price of the current epoch, and it is always the next one in line.
Every moving part is below, and the instruments are real — keccak256 in your browser, the live chain, and the same formulas the contract uses.
What your browser
actually computes
Four values, one hash, one comparison — and you can run them right here. Everything else on this page is a consequence of them.
A miner picks a nonce and hashes four values together: their own address, the nonce, the work behind the previous Monster, and an anchor — the hash of a recent block. 20 + 32 + 32 + 32 bytes, keccak256, 32 bytes out. If the result has at least as many leading zero bits as the target asks for, the contract accepts it, takes the entry price of the current epoch and mints the next Monster in line.
Every Monster is chained to the one before it. The work of the last Monster goes into the next one, so nothing can be mined ahead of time, and the moment somebody else mints, every solution being held becomes worthless.
The address is part of the work. That is what makes a solution untradeable: the same nonce and anchor produce a different hash for anybody else.
The miner runs on processor cores, or on the graphics card. On the cores, one Web Worker per core, minus one so the page keeps drawing; each worker walks its own stride of nonces with the same keccak256 the contract uses, changing only the 32 nonce bytes of a reused 116-byte buffer. On the card, the same round of keccak runs as a WebGPU compute shader, in waves short enough that the page keeps drawing. The card returns candidates, not results: every promising attempt is recomputed on the processor before it can become a transaction, and a card that miscounts is dropped at the first disagreement.
A solution is checked before it costs anything. The worker reports it, the page hashes it again, then asks the contract's own checkSolution view against the chain as it stands. Only then is mine(nonce, anchorBlock) sent, with the entry price attached. The contract recomputes the whole thing itself; the browser's hash is a preview, never a claim.
| Miner | 0x0000…0000 No wallet connected, so the zero address stands in. Connect one and this row — and every hash below — becomes yours. |
|---|---|
| Nonce | 4 815 162 342 The only free value of the four — this is what the workers spin, hundreds of thousands of times a second per core. |
| Previous work | — The work behind the Monster before yours. Every mint replaces it, and everything found under the old one is spent. 0x································································ |
| Anchor | — A recent block hash, read from the live chain. The contract accepts any of the last 250 blocks — about 500 seconds on Base Sepolia. |
The hash does not pick the picture. Monsters are numbered, and the next number in line goes to whoever mints next: your hash is the proof of work behind Monster #n, recorded with it for ever, but #n was drawn long before you found it. Spare hashrate buys zero bits, and nothing else.
At 1.9 MH/s — thirteen workers of an ordinary desktop, pure JavaScript keccak, no GPU. Every extra bit doubles all three numbers; there is no shortcut, and that is the whole point.
A solution dies with the next mint, or when its anchor leaves the window — whichever comes first. The anchor is the hash of a recent block, and the contract accepts one of the last 250 of them. At the planned pace the next Monster usually arrives first; the anchor is the backstop for a quiet hour.
One cell is 5 blocks of the 250-block window — about 8m 20s at Base Sepolia's 2 s blocks. A solution found against this anchor is sent with its block number; when the window runs out the solution is dead and the search starts again against a fresh anchor. The next mint usually ends it sooner: every mint replaces the previous work, which is inside the preimage too.
- Your browser reads the current target, the anchor, the work behind the last Monster and the entry price.
- Web Workers hash nonces until one lands below the target.
- The candidate is dry-run through
checkSolution, then sent to the contract with the entry price attached. - The contract recomputes the hash from your address and checks it itself — against the target for your address in that block, the price, the anchor and the one-per-block rule.
- The next Monster in line is minted to you, and its work becomes the previous work of everyone else’s search.
- The entry price stays in the contract until the owner withdraws it to the treasury. No rent, no hook, no token.
Six rules that
set the target
Difficulty is not one number drifting upward: a floor that rises with the epoch, a retarget every eight mints, and a streak that doubles the work for every recent mint.
Every bit doubles the search, so the two sliders multiply: the epoch sets the floor (14 + epoch on this chain), the streak stacks on top of it, and the price of that epoch moves alongside — money and work grow together. The floor is only the lowest the base can sit; the retarget can hold it higher.
Epoch floor floorBase + epochWork doubles every epoch, and the retarget may never go below that line. Measured on the base difficulty, before the streak is added.
Base difficulty read from the chainWhat the retarget works on. The first Monster was mined at the number the deployment set; from there the pace alone moves it, and it never goes below the epoch floor.
Retarget every 8 mintsCompares the real pace of the last eight mints with the plan of 10 seconds each and moves the base: up to 4× harder in one window (+2 bits), at most 2× easier (−1), and never below the floor.
Streak ×2 per recent mintAdds one bit for every recent mint and cools one step at a time, every 10 seconds, counted per network and per address. Twelve mints in a row cost 4 096× the work of one; the doubling stops after 16 steps.
Failsafe 5 min, one bitAfter that much silence the target is one bit easier — never more. The first mint switches it off again.
One Monster per block 1 per blockA hard ceiling, counted by the chain’s own block number. On a 2-second chain that is 30 Monsters a minute at the very most; the rules above keep the real pace near one every 10 seconds.
Every epoch doubles three things at once: the floor's work, the size of the epoch and the price step — and halves what a burn returns. The last epoch, #2 041–3 333, is cut short by the cap: 3 333 Monsters, then the contract refuses every solution.
| constant | value | note |
|---|---|---|
| baseBits | reading… | |
| floorBase | reading… | |
| TARGET_INTERVAL | 10 s | one mint every ten seconds is the plan |
| RETARGET_WINDOW | 8 mints | — / 8 into the current window |
| STREAK_COOLDOWN | 10 s per step | cap 16 |
| FAILSAFE_IDLE | 5 min, one bit | never deeper |
| ANCHOR_WINDOW | 250 blocks · 8m 20s | Base Sepolia |
| BLOCK_CEILING | 1 per block · 2 s | counted by the chain, not by the clock |
What the price is,
and where it goes
The entry price is the number of Monsters that already exist times a fixed step. It is derived, not chosen.
Epochs double. The first is 8 Monsters, each next one twice as large: 8, 16, 32 … up to the last, which the 3 333 cap cuts short. The price is constant inside an epoch and changes only at its border.
The price is derived, not chosen. It equals the number of Monsters minted before the epoch began times 0.00002 ETH. Epoch 3 starts after 56 Monsters, so every Monster in it costs 56 × 0.00002 = 0.00112 ETH. There is no list of prices in the contract, only that one line.
The first 8 Monsters are the exception. Nobody exists before them, so they cost a flat 0.000069 ETH. From the second epoch on, the formula above is the whole story.
Where it goes. Every entry price stays in the contract until the owner calls withdraw(), which sends the balance to the treasury address. There is no rent to earlier Monsters, no hook, no buyback and no token to buy back: what a Monster costs is the work behind it, and the price is the ticket.
mine() reverts with SoldOut whatever the hash.| Epoch | Monsters | Size | Before it | Price (ETH) |
|---|---|---|---|---|
| 0 | #1–8 | 8 | 0 | 0.000069 |
| 1 | #9–24 | 16 | 8 | 0.00016 |
| 2 | #25–56 | 32 | 24 | 0.00048 |
| 3 | #57–120 | 64 | 56 | 0.00112 |
| 4 | #121–248 | 128 | 120 | 0.0024 |
| 5 | #249–504 | 256 | 248 | 0.00496 |
| 6 | #505–1 016 | 512 | 504 | 0.01008 |
| 7 | #1 017–2 040 | 1 024 | 1 016 | 0.02032 |
| 8 | #2 041–3 333 | 1 293 | 2 040 | 0.0408 |
The identity the price rests on: the number of Monsters that already exist, times one fixed step. Nothing is chosen per epoch; the table above is that one line evaluated nine times.
The other exit:
burn it for points
A Monster burned in its own epoch credits 1 000 BITS points to the address that burns it. Wait an epoch and it is 500; wait two and it is 250. Burning is final.
A Monster cannot be burned the minute it is mined. Two doors stand before the burn: at least one more Monster has to exist after yours, and 10 minutes have to pass since the mint. The contract answers both separately (burnQuote), so the Monster page can tell you which one you are waiting on.
Points are a number on-chain, next to your address. points[owner] goes up, the token goes away, Burned is emitted. The site shows the balance next to the wallet button. There is no ERC-20, nothing to trade and nothing to approve: BITS points are an airdrop promise, not a token.
The supply stays 3 333 for ever. A burned id is never reissued and minted never goes down, so a burn does not make room for another mint. It makes the collection smaller.
The halving is per epoch, not per day. The clock is epoch() − monster.epoch: the epoch of the next mint, minus the one your Monster was mined in. On a quiet chain a Monster can sit in its own epoch for a long time at the full rate; a busy chain melts it faster.
| Waited | Points |
|---|---|
| own epoch | 1 000 |
| 1 epoch | 500 |
| 2 epochs | 250 |
| 3 epochs | 125 |
| 4 epochs | 62 |
| 5 epochs | 31 |
| 6 epochs | 15 |
| 7 epochs | 7 |
| 8 epochs | 3 |
1 000 points if the burn lands in the same epoch the Monster was mined in, half of that for every epoch waited, never below 1. Points are credited to the burner's address on-chain and shown next to the wallet; the Monster is gone for good and its number is never reissued.
3 333 monsters,
drawn before the first hash
Every Hashbits Monster is a 128 × 128 pixel monster, pre-rendered and scaled 8× to 1 024 px with no smoothing. The set was fixed before deployment; mining decides who gets the next one, not what it looks like.
- Blood Moon
- Toxic Sewers
- Rotten Swamp
- Cursed Forest
- Slime Lab
- Crypt Fog
- Deep Void
- Haunted Violet
- Fungal Cave
- Flesh Portal
Sequential assignment. Token id, edition and artwork number are the same integer. The next Monster in line is yours — the hash does not pick the picture, and no amount of hashrate reaches past the queue. A farm cannot grind for a rare Monster; it can only be first to the next one.
Six species. Toxic Slime, Abyss Spawn, Frost Ghoul, Magma Fiend, Fungal Brute and Stone Golem — the skin of every Monster is one of these six. Each wears one of six corrupted streetwear fits: Spiked Biker, Void Hoodie, Swamp Bomber, Graveyard Denim, Blood Varsity or Biohazard Techwear.
Ten scenes. Blood Moon, Toxic Sewers, Rotten Swamp, Cursed Forest, Slime Lab, Crypt Fog, Deep Void, Haunted Violet, Fungal Cave and Flesh Portal stand behind them; face, eyes, head and equipment are the cursed traits on top.
Seven trait types. 7 layers per Monster, 81 traits in all. Rarity is a share of the 3 333, known in advance and printed on every Monster page next to the trait.
Provenance. Every image has a SHA-256, and the SHA-256 of all 3 333 of them in order is the provenance hash below. The per-image hash is printed on the Monster's page; recompute it from the PNG and it matches, or the site is lying.
Served by this site. Images and metadata come from /api/image/[id] and /api/metadata/[id]; the contract's baseURI points here and the owner can move it. No IPFS yet — the provenance hash is what pins the set until then.
| Trait | Values | Rarest |
|---|---|---|
| Background | 10 | Fungal Cave · 280 |
| Equipment | 15 | Royal Reaper · 4 |
| Skin | 6 | Fungal Brute · 555 |
| Clothes | 6 | Biohazard Techwear · 555 |
| Face | 6 | Bone Tentacles · 51 |
| Eyes | 11 | Plague Beam · 54 |
| Head | 27 | Golden Skull · 7 |
Concatenate the SHA-256 of /monsters/1.png through /monsters/3 333.png as hex, in order, hash the string once more, and this is what you get.
The whole thing,
by address
One contract: the ERC-721, the mining rules, the price table, the burn and the points all live in MonsterMiner. The site is told its address; everything else on this page it asked the chain for.
| 01 MonsterMiner | 0x58b80d69a731e10a160bc93f0393d4b7489032de The collection: mining, the target, epochs, burning, BITS points. An ERC-721 that mints to nothing but a hash below the target, paid at the entry price. |
|---|---|
| 02 Treasury | reading… Where |
| 03 Chain | Base Sepolia · id 84 532 RPC |
ArbSys, with a 32-bit start and a 26-bit floor.Things people
ask first
10 answers about getting one, mining against a farm, and the art.
Getting one
Can I just buy one?
mine() refuses anything that is not a hash below the target. Somebody who already mined one can sell it on any marketplace, like any ERC-721 — that is the only way a Monster changes hands without work.What am I paying for, then?
Why does the price go up?
The art
Can the art disappear?
baseURI at a new home. The tokens, the work hashes and the points live on-chain regardless.What are BITS points?
Mining against a farm
Does mining in a browser stand a chance?
Can someone steal my solution?
Can a farm grind for a rare Monster?
Does a big holder mine cheaper?
What happens when all 3 333 are mined?
mine() reverts with SoldOut for ever. Burning still works — the doors only need a later Monster and ten minutes — and points keep accruing; ids are never reissued, so the supply only shrinks from there.Real keccak256 in your browser, at the current target and the current price.
Mine a MonsterEvery Monster mined so far, with the work behind each one.
Browse all MonstersThe one contract that holds the rules, the ids and the points.
Contract