This is the expected shape of a mining launch, not a problem — but it is the first moment where the numbers say something, so here they are. Every one of them is read from the contracts, and every one can be read again by anyone.

Cat #9 204, the last one of the wave, drawn from the seed the contract stores for it. Hashcat from seed 0x3dba8920e6fd8e2a9f4e71fab58510fc14554df3d2c24a6b0fa40f52c902d6c4

Where it stands

Two of those deserve a second look.

Four cats in ten have been burned

3 758 of 9 204 is 40.8%, and it happened in three days. Burning is not a failure mode here — it is one of the three exits the design gives a cat, and the only one that produces $HASH. A burned cat stops earning rent, and its share goes to the cats still alive.

The exits compete, which is the point

Hold and the rent accrues. Burn and you get tokens instead, at a rate that halves over the course of each epoch. Sell and you get whatever someone pays. The rate decays so that waiting is never free: a cat held for another epoch is worth half as much $HASH as it was, and that is the pressure that keeps the three exits honest against each other.

The price went up 2 372 times

Epoch 0 cost 0.000069 ETH. Epoch 10 costs 0.16368 ETH. That is not inflation and not a fee change — it is the same single line running the whole time: the price of a mint is the number of cats that already exist, times 0.00002 ETH.

Every one of those steps went somewhere specific: 0.000014 ETH of each step to the cats already alive, 0.000006 ETH to the hook. Nothing is left over — the price is exactly the sum of the two.

Where the $HASH is

Burning cats has produced 3 708 712 $HASH. The hook has bought back and destroyed 2 125 590 of them — 57% of everything burning has produced — spending 234 ETH from the buyback queue to do it.

The first million came before any of that

$HASH was deployed with 1 000 000 tokens minted to the deployer, and they did not stay there. One transfer in block 60 412 646 — before the first cat existed — moved the entire amount to the hook, which put it into the pool as liquidity. That address has had exactly two token transfers in its life — the mint in, and that one transfer out — so its balance of $HASH has been zero ever since, and the token page says so in one line.

What happens next is mechanical

Nobody has to do anything for mining to resume. The target loosens on its own until cats arrive at the pace the contract aims for — one every ten seconds — and it will keep loosening while nobody is mining. The entry price does not move with it: that number only ever depends on how many cats exist, so it stays at 0.16368 ETH until cat 16 377 starts epoch 11.

Meanwhile the rent keeps accruing to whoever is still holding, and the 38.25 ETH in the collection is waiting to be claimed by the cats that earned it.

Read it yourself

• The collection — totalMinted, burnedCount, mintPrice, and the ether balance that is the rent pool

• The hook — buybackSpent and buybackBurned

• $HASH — supply, holders, and the pool

• Stats — the same readings, plotted and refreshed

What is counted

Five series went in, and they measure different things. The names are DefiLlama's, and they are not interchangeable:

Two identities hold on the page, and they are the quickest way to see that the series mean what they say:

Fees     = Revenue + Supply-side revenue
Revenue  = Holders' revenue + Protocol revenue

The rent is supply-side and not "holders' revenue" on purpose. A cat holder is a supplier whose asset earns — the rent is a cost of doing business, not a dividend. What DefiLlama calls holders' revenue is the buyback: money that leaves the protocol to purchase $HASH and destroy it.

Mint price is derived, not read from the transaction

The adapter computes each mint from the contract's own curve — cats created so far, times PRICE_STEP — instead of taking the ether attached to the call. Send a mint with excess value and the figure does not move.

TVL is one number, and a small one

TVL is the ether sitting in the collection contract: rent that has accrued to living cats and has not been claimed yet. Nothing else.

On the day of the listing it stood at about $149 000, while fees for the preceding 24 hours came to about $479 000 — three days' worth of TVL moving through the protocol in one of them. That is not an error and not a good thing or a bad thing: it is what a mining protocol looks like. Value passes through rather than sitting still, and rent is claimed continuously, so the balance never accumulates.

What is not counted, and why

The hook holds a Uniswap V4 position and a buyback queue. Neither is in TVL. This was argued, not assumed: a maintainer asked whether hook-owned liquidity counts, and the honest answer is that it does not.

The test that settles it

Both removeLiquidity and withdrawQueue on the hook are owner-only — call either from any other address and it reverts. Value that one address can remove at will is not locked value, it is inventory. Counting it would inflate TVL by the protocol's own holdings, which is exactly the number DefiLlama exists to keep honest.

The collection's ether balance is a different matter, and it does count. The contract has no owner withdrawal, no sweep and no rescue — there is no function that takes ether out of it to an arbitrary address. Two paths move ether out, and both are someone's earned share: the hook's cut, and the claim that pays a cat's owner. Nobody else can take it.

Two things we had to fix after the merge

Maintainers at DefiLlama do not merge external pull requests directly — they copy the code into their own and merge that. It is a sensible way to run a repository with thousands of adapters, and it means the code that ships is not always the code you wrote. Ours came out with two changes, and both were wrong.

What shipped

options.api.call({ block }) — a per-call block argument, which ChainApi accepts and silently ignores. The reader stays pinned to the head of the window.

What it should have been

new ChainApi({ chain, block }).call(...) — a separate reader pinned to the block we actually asked for.

The second was the deployment guard. The original returned an empty result for any window that ended before the collection existed; the rewrite compared timestamps instead of block numbers, and on the hour of launch that check passed while the contract call underneath still reverted.

Both were provable rather than arguable, which is the only reason the fix went in quickly:

window of Sep 11, 09:00–10:00 UTC

  master   → Failed to call: uint256:PRICE_EPOCH0
  ours     → dailyFees = {}

Merged

dimension-adapters#9419 — the fix, on top of the original fees adapter in #9418 and the TVL entry in DefiLlama-Adapters#21006.

Checking it yourself

Every figure is a difference of two on-chain reads, and you can take them yourself. The rent owed to the hook, for instance, is read at both ends of the window and subtracted:

const [dueBefore, dueAfter] = await Promise.all([
  new ChainApi({ chain, block: windowStart - 1 }).call({
    abi: 'uint256:hookDue',
    target: COLLECTION,
  }),
  options.toApi.call({ abi: 'uint256:hookDue', target: COLLECTION }),
])

The - 1 is the whole subtlety. Log ranges include the block they start at, but fromApi is the state after that block has run — read it without the offset and the first block of every window is counted twice.

The cheapest check of all needs no adapter and no logs. Ask the collection how many cats exist (totalMinted), put that number through the price curve — each epoch's entry price times the cats in it — and you have every mint ever paid for, in ether. It should land just under the fees total. The gap is the other two flows: the pool fee and the royalties. While the pool is young that gap is small, and watching it widen is the most direct way to see trading start to matter.

Their chart is labelled by the start of the day

A point on the DefiLlama chart carries the day it opens, and the day in progress holds a rolling 24-hour sum. This means the all-time total can go down when a day closes — which looks alarming and is not.

Where to look

• The Hashcats page on DefiLlama

• Our stats site, which reads the same contracts directly and updates faster

• The collection on RobinScan — the balance that TVL reports is this contract's

• The adapters themselves, in dimension-adapters/fees/hashcats and DefiLlama-Adapters/projects/registries/sumTokens.js

The contracts

Three addresses, deployed in that order — the token first, because the hook needs it, and the collection last, because it needs the hook:

Each address is also readable from the one before it: the collection returns the hook, and the hook returns the token. Nothing here has to be taken on trust — hook() and token() are public views, and the three addresses above are what they answer.

First cat

Block 60 415 844, 3 374 blocks after the collection went up — the time it took for somebody to find a hash below the opening target. The mint cost 198 883 gas.

What mining actually is

The contract does not pick your cat. It reads it out of the work you did.

Three parts, and only the first one is slow.

1. You search

   Your machine tries nonces until a hash comes out below the current target. This happens entirely on your side — no transaction, no gas, nothing on chain until you have won.

2. The contract checks

   It recomputes the hash from what you submit. There is nothing to trust here: the check either passes or the call reverts.

3. The cat is read from the hash

   Fur, traits and background are positions inside the number you found. The same function the site uses to draw it is the one the contract uses to store it.

Cat #1, drawn here from its own seed — the one seedOf(1) returns — by the same code the contract runs. Hashcat from seed 0x6c869bc51d6a31fd5ce501b74c80f9d102ffaf6c5d026b50dec24106063fd8ff

Difficulty

The target moves so that cats keep arriving at roughly the same rate no matter how much hardware is pointed at it: the contract aims for one cat every 10 seconds and retargets against that. If more people mine, the target tightens; if they stop, it loosens. Nothing about this is unusual — it is the same mechanism Bitcoin uses, at a much smaller scale.

What a mint costs

The price is not a number somebody sets. It comes out of one line in the contract: the number of cats that already exist, times 0.00002 ETH.

Each epoch holds twice as many cats as the one before it, so the price roughly doubles from epoch to epoch — exactly ×2 once the counts get large, more than that at the start.

Mining late costs more and earns less

That 0.00002 ETH step splits in two: 0.000014 goes as rent to every cat already alive, and 0.000006 goes to the hook. Both numbers are constants in the contract, and the price is exactly their sum — a mint cannot pay one without the other.

So a late cat pays for every cat before it, and then earns the same fixed step from everyone who comes after. Epoch 0 is the one exception: those eight cats have nobody to pay, and their price goes to the hook whole.

Where to go next

• Mine a cat — the miner runs in the browser

• How it works — the full mechanism, with instruments you can turn

• Stats — difficulty, rent, burns and holders, read from the chain