Proof of Blob · Blob of Affection

01 / the scheme

One pool, one moment, no way back.

Most projects put this part in a diagram with arrows and the word ecosystem. Ours fits in one paragraph. Then we took the paragraph apart, piece by piece, so every claim in it can be checked against the contract.

Somebody who made a token hands part of it to a pool. The pool cannot hand it back, not to them, not to me, not to anyone who asks nicely. They name a moment. Until that moment a clock counts down and any holder can see whether they are inside the cut. At the moment, the round runs. A tenth is bought into $BLOB for the treasury and called a fee, because it is one. The dev's burn share buys the token they chose and sends it to the dead address. A small bounty pays whoever pressed the button. That block becomes the snapshot. Then the engine ranks the holders at that block, leaves out pools, contracts and the dev, and pushes each of the largest N their share. Nobody claims anything. The hash of the list goes on the chain with the last batch, and anyone can recompute the list from public data.

// what this is

A pool contract with no owner, no pause, no upgrade path, no withdraw function and no arbitrary call. The only ways funds leave are the five listed further down.
A fee in the open. Ten percent of every round whose target is not $BLOB, converted into $BLOB and sent to one treasury address. It is printed on every row of the ledger and called a fee.
A snapshot chosen by a block, not by a person. The round is marked executed and its block recorded before a single swap happens.
A payout that is pushed, never claimed. The shares land in the listed wallets. There is no claim page, no form, and no button for holders to press.
A list anyone can recompute from public data, with its hash written on the chain when the last batch lands.

// what this is not

Not yield. Nothing is promised to anyone. A round exists only when somebody chooses to commit one, and nobody here has promised to commit any.
Not a proof that a dev is honest. A round proves what was handed over. It says nothing about what the same dev kept in another wallet.
Not a guarantee that the list is right. The publisher could pay the wrong addresses. What binds it is that the list, the script and the hash are all public, so a wrong list is provable by anyone. Treat that as a reputation bond, not a proof.
Not audited. Same as the token, same as this whole site. Read the source, then decide.
Not a claim page, and there will never be one. A page that asks you to connect a wallet to collect a Proof of Blob share is a page built to empty it.

// a worked example. one thousand of a token, burn share set to fifty percent

the fee, 100A tenth of the whole, off the top before anything else. Bought into $BLOB and delivered to the treasury. Zero when the target token is $BLOB itself, because $BLOB does not charge $BLOB.

the burn share, 450Fifty percent of what is left, in this example. Any share from zero to all of it, chosen by the dev. Bought into whichever token they name, then delivered to the dead address.

the pot, 450What is left. Divided among the largest N holders in proportion to what each one held at the snapshot block, each share rounded down.

02 / a round, moment by moment

Four states, and no branch that goes home.

A round enters the first state when somebody commits it. Every state after that is reachable by a different set of people, and not one of them contains a path that returns funds to the committer.

01 scheduled commit

The commit is the proof

The dev has already let go. From here the engine starts counting who holds what, and the clock on this page starts telling the truth. Nothing in any later state hands it back.

// what actually happens

The pool takes the amount and the bounty. A native round sends the amount plus the bounty as value. A token round sends only the bounty as value and pulls the amount by allowance.
What actually landed is measured. A token that keeps part of every transfer delivers less than it promised, and the whole commit reverts rather than being found out later, after the committer has gone.
The fee comes off first, the burn share off what is left, and the rest is the pot. All three are fixed at this moment and written into the round.
A moment in the past means now. The round becomes due at once instead of failing.
One event carries every term, including the excluded addresses and the note. Those two live only in the event, which keeps the round cheap and the receipt complete.

what the engine does meanwhile From the first block after the commit, the engine tracks every transfer of the target token so that the snapshot, when it comes, can be read from a list it has already been keeping. The live standing on this page is served from that list.

02 executed execute

The execution is the receipt

For one day from the moment, only the publisher may run it, with its own quote as each swap's floor. After that day, anyone may, for the bounty. Either way the block it lands in is the snapshot, and that block is written before a single swap happens.

// what actually happens

The round is marked executed first. The time and the block number are recorded before the router is called, so no swap can move the snapshot.
The fee moves. If the asset is $BLOB it is transferred to the treasury as it is. Otherwise it is swapped into $BLOB with the treasury as the router's recipient, so the pool never holds the proceeds.
The burn share moves. If the asset is already the burn token it goes to the dead address as it is. Otherwise it is swapped with the dead address as the recipient. After the grace day an empty route is allowed, which sends it unswapped rather than letting a dead engine hold a round hostage.
The bounty is paid last, in ETH, to whoever sent the transaction.
The receipt is emitted: the executor, the snapshot block, what the fee bought, what the burn bought, and whether it was burned as is.

a route that lies is refused Every route has to say exactly what the round says. Wrong token in, wrong token out, wrong amount, a recipient that is not the treasury or the dead address, a zero minimum, or no legs at all, and the call reverts. After the grace day anyone may execute with any route that passes those checks, and a poor price on that swap lands on the fee and the burn, never on the holders' pot.

03 distributed distribute

The ledger is the record

The engine reads every balance at the snapshot block, drops the pools, the contracts and the committer, sorts, takes the top N, and pushes. In batches of 125. Nobody claims anything, ever.

// what actually happens

Only the publisher may distribute, and only for a round that has been executed.
As many batches as the list needs. The sum of every batch can never exceed the pot. A batch that asks for more than is left is refused whole.
A wallet that refuses ether keeps its share in the pot. A token transfer that fails reverts the batch instead, so a broken recipient is visible rather than silently skipped.
The last batch closes the round. It writes the hash of the whole list, burns whatever is left in the pot, and marks the round distributed.
Two receipts: one per batch with the count and the total, and one at the end with the list hash and the remainder burned.

how a share is sized Each of the top N gets pot × balance / total, where total is the sum of the top N balances, rounded down. The rounding dust is part of what the last batch burns. A holder with twice the balance of another gets twice the share, and nobody outside the N gets anything.

04 abandoned abandon

If the publisher never finishes

The pot does not sit there forever, and it does not go home. Thirty days after execution, anyone may abandon the round, and the remainder burns.

// what actually happens

Any address may call it, thirty days after the execution time, on a round that was executed and never finished.
Whatever is left of the pot goes to the dead address. Batches already pushed stay with the wallets that received them.
The round is marked abandoned and the event names who pressed the button and how much burned.

why this exists This is the only path a round has when the engine dies. It is deliberately slow, deliberately public, and it still does not return anything to the committer.

03 / who does what

Five roles, two of them trusted.

Everything the contract allows is sorted by who may do it. Two addresses are fixed at deployment and carry all of the trust. Both are readable on the contract further down, so you never have to take our word for either.

role_01

The committer

Any address. Chooses every term of a round: the token, the amount, the burn share, how many holders, the floor, the moment, the bounty, the exclusions and the note. Has no path back to the funds once committed, and is left out of the payout.

role_02

The publisher

One address, fixed at deployment, the key the pond's engine holds. For a day from a round's moment only the publisher may execute it, and only the publisher may ever distribute. It can spend its own gas on those two calls and nothing else.

role_03

The treasury

One address, fixed at deployment. Receives the fee, already converted into $BLOB by the round's own swap. It cannot reach anything else in the pool, and it cannot be changed.

role_04

The holders

Whoever holds the target token at the snapshot block, ranked by balance after the exclusions. They do nothing. If they are inside the cut, the share arrives. If they are not, nothing arrives and nothing was owed.

role_05

Anyone

May execute a round after the day of grace, for the bounty, with any route that passes the checks. May abandon a round the publisher never finished, thirty days after execution. May recompute any list and compare the hash.

where the trust actually sits What the publisher can do wrong is pay the wrong list. The list is public, the script that recomputes it is public, and the hash is on the chain, so a wrong list is provable by anyone within minutes. That is a reputation bond, and we call it one. What the treasury can do wrong is nothing. It only receives.

what the toad cannot do There is no admin key. Nobody can pause a round, change the fee, redirect the treasury, move the snapshot, or pull funds out early. If the engine is switched off, rounds still execute for the bounty and still burn on abandonment. The contract does not need us to keep its promises.

04 / the parameters

Eleven parameters, one rule each.

A round is one call with eleven arguments. Every argument has exactly one rule, checked by the contract, and the same rules are printed beside the fields in the commit panel below so nothing is signed on a guess.

Parameter	What it means	The rule
target	The token whose holders receive the pot	Not the zero address, not the dead address
asset	What is handed over	The zero address for native ETH, otherwise an ERC-20
amount	How much	Measured on arrival. A token that delivers less reverts the commit
burnToken	What the burn share buys before burning	The zero address means the target token itself
burnBps	The burn share, of what is left after the fee	0 to 10,000 basis points, so zero to all of it
topN	How many of the largest holders are paid	1 to 500
minHolding	A floor under which a holder does not count	Zero counts everyone
executeAt	The moment, as a unix timestamp	A past time means now
bounty	Paid in ETH to whoever executes	Sent with the commit, on top of the amount
excluded	Extra addresses left out of the list	Recorded in the event only, read by the engine
note	A sentence for the receipt	Up to 140 characters, in the event only

The arithmetic, at the moment of commit

fee = target is $BLOB ? 0 : amount × 1000 / 10000
burn = (amount − fee) × burnBps / 10000
pot = amount − fee − burn
// native rounds send amount + bounty as value
// token rounds send bounty as value and pull amount by allowance

Integer division, rounded down at every step, exactly as the contract does it. The three results are stored in the round and never recomputed, so the ledger shows the same numbers the chain holds.

Constants chosen once, at deployment

FEE_BPS is 1,000, a tenth. It is a constant in the source, not a setting, so there is no function anywhere that could raise it.
MAX_TOP is 500. Five hundred recipients is four batches on a chain with a thirty million gas block.
GRACE is one day. How long only the publisher may execute, counted from the round's moment.
ABANDON_AFTER is thirty days. How long after execution a round nobody finished may be abandoned by anyone.
DEAD is 0x000…dEaD, the address everything burned is delivered to. Nothing has ever come back out of it.

05 / what the contract promises

Five ways out, and no sixth.

A pool is only as honest as the list of ways money can leave it. Ours is short enough to memorise. Everything below it is either in the source or not in the source, and the source is linked.

// guaranteed by the code

Funds leave in exactly five ways: the fee swap to the treasury, the burn swap to the dead address, the bounty to the executor, the pushed shares to the listed wallets for the listed amounts, and the remainder to the dead address.
No owner, no pause, no upgrade, no withdraw, no arbitrary call. The one outside contract it calls that it was not handed in a call is the router, fixed at deployment.
The fee rate, the fee token and the treasury are immutable. So is the publisher.
Distribution never exceeds the pot, and it ends with the hash of the list on the chain.
Every state change is an event. Committed, Executed, Distributed, Finished, Abandoned. The ledger on this page is built from nothing else.
No allowance outlives the call that granted it. A token swap approves exactly the amount, and anything left afterwards is withdrawn in the same transaction.

// not guaranteed, and said out loud

That the list is honest. The publisher could pay the wrong addresses. The list, the script and the hash are public, so a wrong list is provable, and that is what binds the publisher. Reputation, not code.
A good price on the two swaps after the grace day, when anyone may execute with any route. That cost lands on the fee and on the burn, never on the holders' pot.
Anything about what the dev kept. A round proves what was handed over, not what stayed in another wallet.
That a round will ever be committed. The pool waits. Nobody is obliged to use it, and nobody here has promised to.
An audit. There is none, same as everything else with this toad's face on it.

the pool · robinhood chain solidity 0.8.24 · no libraries · no proxies

// pool contract address, read the highlighted ends and then the middle

Read the verified source

The immutables, read from the contract itself
Router	-
Fee token	-
Treasury	-
Publisher	-
Fee	1,000 bps, a tenth, zero when the target is $BLOB
Largest recipients	up to 500 per round
Grace	1 day, publisher only
Abandon after	30 days from execution
Rounds so far	-

// the four addresses fill in from the contract, not from this page. a dash means the chain has not been read yet, or there is no pool to read.

Read the contract, all of it

06 / the engine

The half a contract cannot do.

A contract cannot rank ten thousand holders at a block and push five hundred transfers on its own. The engine does, with the publisher's key, and everything it does is designed to be redone by a stranger with a public node.

eng_01

Reading rounds

The round count, then every round by id, plus the contract's own logs walked incrementally. Committed carries the note and the excluded list, and the four receipts carry everything else. The ledger on this page reads the same rounds straight from the contract.

eng_02

Tracking balances

Find the mint block from the first transfer out of the zero address, then walk every transfer from there to the head in spans the node accepts, forty thousand blocks at a time on this chain. If the node refuses a range even at the smallest span, the walker stops and does not advance past the hole, because a list built over a hole is wrong.

eng_03

Exclusions

The dead and zero addresses, the target's own contract, the pool, the router, the committer, every address the committer listed, every liquidity pool that pairs the target, and every address that has code. On a launchpad token the launchpad's contract alone can hold close to half the supply. It is a contract, so it is out.

eng_04

Standing, live

For a scheduled round: sort the eligible balances, find an address's rank, the balance of the N-th place, whether it is inside, its share if the round ran right now, and what more it would need to get inside. The checker below asks the engine that question every ten seconds.

eng_05

The list at the snapshot

Take every address ever credited, drop the exclusions, read each balance at the snapshot block, drop anything with code, apply the floor, sort, take the top N, and size each share as pot × balance / total, rounded down. The list is served as JSON next to a script that recomputes it and compares hashes.

eng_06

The publisher loop

Every fifteen seconds: for each due round, build the fee route and the burn route from the router's own quoter with a slippage floor, simulate, send, wait. For each executed round, compute the list and distribute in batches of 125, with the last batch carrying the hash. After a restart the paid prefix is the one whose sum matches what the contract reports as distributed.

The hash anyone can recompute

listHash = keccak256(utf8(JSON.stringify({ id, block, accounts, amounts })))
// id and every amount as decimal strings
// accounts in list order, checksummed exactly as served

The same four fields, in the same order, hashed the same way. Recompute the list from the chain with your own node, hash it, and compare with the value the last batch wrote. If they differ, the publisher paid a different list than the one it published, and you can prove it to anyone.

What that means for a holder

Keep the token in a wallet you control. A balance sitting on an exchange or inside a contract is excluded, because a contract cannot be paid on your behalf.
Rank is measured at one block, the block the execution lands in. Moving tokens after that block changes nothing about that round.
Nothing to do on your side. No claim, no signature, no connection. If a page says otherwise it is not this page.
The share arrives as the round's asset, ETH or the token that was handed over, straight into the wallet that held the target at the snapshot.

07 / the ledger

Every round, on the record.

Read from the pool contract by this page, in your browser, through the public node. No number here comes from us. A round that is not on the chain is not on this table, and a countdown you see is the contract's own clock.

Reading the pool contract.

Round	Target	Handed over	Fee	Burn share	Pot · top N	State	Snapshot	Record

// not read yet

08 / am I in

Where you stand, right now.

For any scheduled round, the engine ranks the eligible holders as they are at this moment and tells you whether an address is inside the cut, by how much, and what it would take to get in. It refreshes every ten seconds while this section is on screen.

09 / commit a round

Hand it over, on purpose.

This panel is for the dev of a token. Every field carries its rule, the row the ledger will show is previewed before anything is signed, the fee line included, and the transaction is simulated on the node before your wallet ever sees it. Read the preview twice. There is no undo.

// no wallet connected. the preview works without one, the commit does not.

target Not the zero address, not the dead address, and it has to be an address. // the token whose holders receive the pot

asset

ETH a token

A token round needs the token's address. // the zero address for native ETH, otherwise an erc-20. what lands is measured, a token that delivers less reverts

amount A positive number, with no more decimals than the asset has. // how much is handed over. in whole units, converted with the asset's decimals

burnToken Either blank or an address. // what the burn share buys before it is burned. blank means the target token itself

burnBps A whole number from 0 to 10000. // the burn share, in basis points of what is left after the fee. 5000 is half

topN A whole number from 1 to 500. // how many of the largest holders are paid

minHolding Zero or a positive number, in the target token's units. // a floor under which a holder does not count. zero counts everyone

executeAt Pick a moment, or leave it blank to mean now. // the moment, in your local time. blank or past means now

bounty Zero or a positive amount of ETH, at most 18 decimals. // in ETH, paid to whoever executes. sent with the commit

note Up to 140 characters. // up to 140 characters, stored in the event only

excluded Every line has to be an address. // extra addresses left out of the list, one per line. the committer, pools and contracts are excluded anyway

// the row the ledger will show, computed the way the contract computes it

handed over: -
fee: -
burn share: -
pot: -
largest: -
moment: -
sent as value: -

before you press anything There is no path back. Not for the dev, not for the toad, not for a court order. The amount, the fee, the burn and the pot are fixed the moment the commit lands. The approval for a token round is edited down to exactly the amount, and the commit spends it in the same minute, so nothing stays approved afterwards.

10 / questions people ask first

Sorted by how often the toad gets asked.

The short answers. The long ones are the sections above, and the longest one is the contract itself.

Do I need to claim anything?

No. Never. If you hold the target token in your own wallet at the snapshot block and you are inside the cut, the share is pushed to that wallet by the publisher. There is nothing to press.

Any page, bot or message asking you to connect a wallet, sign something, or pay gas to receive a Proof of Blob share is a scam, with no exceptions. Report it in the open channel and move on.

Why is there a fee, and where does it go?

A tenth of every round whose target is not $BLOB is bought into $BLOB by the round's own swap and delivered to one treasury address that was fixed when the pool was deployed. We call it a fee on every row of the ledger because that is what it is.

It is the only thing the pool gives the pond. It cannot be raised, because the rate is a constant in the source, and it cannot be redirected, because the treasury is immutable. A round whose target is $BLOB itself pays no fee at all.

Can the dev take it back?

No. There is no function that returns anything to the committer, in any state. Scheduled rounds execute. Executed rounds distribute or burn. Abandoned rounds burn. The word refund does not appear in the source, and neither does anything that behaves like one.

What if the publisher pays the wrong list?

Then anyone can prove it. The list is published as JSON beside a script that recomputes it from the chain, and the hash of the list is written on the chain by the last batch. Recompute, hash, compare. A mismatch is evidence, not an opinion.

That is why we call the list a reputation bond rather than a proof. The contract cannot check the list. The public can, and the publisher knows it.

Why does a wallet holding half the supply not get paid?

Because it is usually not a wallet. On a launchpad token the launchpad's own contract holds the curve, and after graduation the pool contract holds the liquidity. Either can hold more than any person, and both are contracts, so both are excluded along with the router, the committer, the dead address and anything else that has code.

The exclusions exist so the largest holders are people who chose to hold, not machinery that has to.

Is this yield?

No. A round happens only when somebody decides to commit one, and nobody has promised to commit any. If no dev ever uses the pool, nothing is ever pushed to anyone, and that would be a completely honest outcome.

Anyone describing Proof of Blob as passive income, a guaranteed return or a reason the price must go up is describing something else, and probably selling it.

Who can execute, and why would they?

For one day from the round's moment, only the publisher, using its own quotes as the swap floors. After that day, anyone at all, for the bounty the committer attached. That second door exists so a round can never be stuck by a dead engine.

Whoever executes has to hand the contract routes that say exactly what the round says, or the call reverts. A poor price on those swaps lands on the fee and the burn, never on the holders' pot.

What happens to the rounding dust and to wallets that refuse ether?

Both stay in the pot until the last batch, and the last batch burns whatever is left. A wallet that rejects an ether transfer simply is not paid, and its share joins the remainder. A token transfer that fails reverts the batch instead, so the publisher sees it and can leave that address out of the next attempt.

Is the pool audited?

No. Nothing with this toad's face on it is. The source is about four hundred lines, has no libraries and no proxies, and is linked in full above. If you would rather read Solidity than take a stranger's word, that is the correct instinct, and the file is right there.

Is any of this financial advice?

No. This is a page about a damp cartoon animal and a pool contract. Nothing here is a recommendation to buy, hold, commit, or sell anything. Crypto assets can lose all value very quickly, meme coins faster than most, and a round that pays you today promises nothing about tomorrow.

11 / keep going

That is the whole mechanism. Now read the rest of the pond.

06 · guide

Proof ofBlob.

One pool, one moment, no way back.

Four states, and no branch that goes home.

The commit is the proof

The execution is the receipt

The ledger is the record

If the publisher never finishes

Five roles, two of them trusted.

The committer

The publisher

The treasury

The holders

Anyone

Eleven parameters, one rule each.

The arithmetic, at the moment of commit

Constants chosen once, at deployment

Five ways out, and no sixth.

The half a contract cannot do.

Reading rounds

Tracking balances

Exclusions

Standing, live

The list at the snapshot

The publisher loop

The hash anyone can recompute

What that means for a holder

Every round, on the record.

Where you stand, right now.

Hand it over, on purpose.

Sorted by how often the toad gets asked.

That is the whole mechanism. Now read the rest of the pond.

Get Damp

The Toad

Swamp Lore

Feelings Index

Feelings Forge