Preview · sample figures

Run the vault.

Nobody operates Pupate. Its upkeep is a handful of public functions on the vault and the tax hook: whoever calls one first moves the mechanism forward, and two of them pay the caller 0.5% of the ETH they spend. Ninety minutes after launch a stranger called burn() before the project's own keeper did, destroyed about 7.2 million PUPATE and kept the reward. The rows below read the chain and say which duty is ready right now, by the same rules the keeper uses. A button sends the call from your own wallet; each row also carries the call for a terminal.

Nothing is live here. These rows run against the preview's sample figures, and a button changes only this page. Live, the same rows read the chain and the buttons send real calls from your wallet.
3 of 7 readyno wallet connected
Ready

Flush the tax

0.0800 ETH is waiting in the hook. One call moves all of it into the vault.

Waiting in the hook0.0800 ETH
The keeper runs it from0.005 ETH

Moves the tax the hook has collected into the vault, which splits it: 85% to the seat and burn pots by the mode of the moment, 10% to the developer, 5% to the IMD burn.

Pays: Nothing. It is the step that fills the pots the paid steps spend from.

From a terminalcast send <hook> "flush()" --rpc-url $RPC --private-key $KEY
Ready

Burn

0.4100 ETH in the pot and the spacing has passed. The call spends what the 5% price-impact limit allows and pays you 0.5% of it.

Burn pot0.4100 ETH
Rewardup to 0.00204 ETH · on what the pool takes
Next burnnow

Spends the burn pot on PUPATE in the launch pool and destroys what it buys. One call may move the pool price by at most 5%, so a large pot takes several calls, 5 blocks apart.

Pays: 0.5% of the ETH the burn spends, in the same transaction.

From a terminalcast send <cocoon> "burn()" --rpc-url $RPC --private-key $KEY
Waiting

Settle a sold seat

6 seats still listed (1733, 0882, 1376, 0410, 1540, 0097); none has sold since the books were last settled.

Seats held6
Sold, not settlednone

After a buyer takes one of the vault's listings, this takes the seat off the books and cancels its other order on Seaport. The sale's ETH is already in the burn pot.

Pays: Nothing. It keeps the books right, and the next burn can follow.

From a terminalcast send <cocoon> "settleSeat(uint256)" <tokenId> --rpc-url $RPC --private-key $KEY
Ready

Harvest auctions

A lot is up: 4,120 FREE1376 for 0.0036 ETH right now, falling, free in 31h 42m. The first taker gets all of it, and the ETH goes to the seat pot.

Lot4,120 FREE1376
Price now0.0036 ETH
Running for16h 18m

Tokens the seats earn while they work sit in the vault. startAuction(token) puts the whole balance of one token up at a price that halves every 2 hours and is zero after 48; takeAuction(token) buys the lot at the price of the moment, and the ETH goes to the seat pot.

Pays: Nothing for starting. The taker keeps the gap between the falling price and what the lot is worth, which can be nothing.

From a terminalcast send <cocoon> "takeAuction(address)" <token> --value <auctionPrice> --rpc-url $RPC --private-key $KEY
By hand

The IMD auction

3.0600 ETH is set aside and no auction is running. The preview does not simulate the IMD auction.

IMD burn balance3.0600 ETH
Running auctionnone
IMD burned so far312 IMD

5% of the tax is set aside to buy IMD and destroy it. startImdAuction() offers that ETH; the IMD asked for it starts at 20,000 per ETH (a parameter) and falls on the same curve as the harvest auctions. takeImdAuction() pulls the IMD from the taker, sends it to the dead address and pays the taker the ETH lot.

Pays: Nothing for starting. The taker is paid the ETH lot for the IMD they deliver; the gain is the gap between the two.

From a terminalcast send <cocoon> "startImdAuction()" --rpc-url $RPC --private-key $KEY
Waiting

Report the reference price

Fresh in the preview: the sample report does not age. Live, this row says when the report goes stale and whether one is due.

Reference price2.74 ETH
Reportfresh (sample)

Stores a new reference price in FloorFeed from an attestation signed by IMD's oracle: a panel of twenty seats reads the collection's lowest listing and eleven must agree. The vault buys seats only while the report is fresh, six hours at most.

Pays: Nothing, and the attestation costs 0.5 IMD to request from IMD's oracle. The developer's keeper pays for one every six hours; submit your own only if that has stopped and you want the vault to keep buying.

By hand

Buy a seat

The pot covers a seat up to 1.94 ETH. Find a listing at or under 2.88 ETH on OpenSea or in Seaport's OrderValidated events and submit it; the keeper's candidates are in listings.json.

Reference price2.74 ETH · sample
Ceiling2.88 ETH · 5% over the reference
The pot covers1.94 ETH · price plus reward

Fulfils a Seaport listing of one Identity MD seat for ETH from the seat pot, then lists the seat for sale from the vault. You supply the order; the vault pays. It goes through when the reference price is fresh, the order asks at most 5% over it, what is paid is at least half of it, the seat pot covers price plus reward, and the order is one seat of the collection, in full, for native ETH, with nothing of it paid to the vault and not a seat the vault already holds.

Pays: 0.5% of the ETH the purchase spends, in the same transaction.

Who ran it

The last flushes, seat purchases and burns from the chain's events, newest first, with what the vault paid the caller. A flush names no caller in its event, so the sender of the transaction stands for it.

WhenStepCallerETHPUPATE burnedReward
day 23Bought a seat0xa90e…77d12.8400 ETH–0.01420 ETH
day 23Flush0x71c4…0be20.3100 ETH––
day 21Burn0x71c4…0be20.0570 ETH3,960,0000.00029 ETH
day 21Flush0xa90e…77d10.2700 ETH––
day 17Burn0x3d05…c4f80.0610 ETH4,210,0000.00030 ETH
day 17Flush0x71c4…0be20.2200 ETH––
For agents
The same duties, as a skill

skill.md tells an agent what each step is, when it can run, what it pays and how it fails, with the reads to make first. status.json is the keeper's own account of what is ready right now, rewritten after every tick, so one fetch replaces the reads.