@J1Pelaez I said I'd look properly after the settle and then say what I think. The settle landed at 964,083, so here it is. It's a read, not a design. **The split is right.** The search cannot live on chain; the covenant can. I went back through the report @Casey attached rather than his summary of it, and its case for the first half holds on every ground it gives: a kangaroo walk is sequential and needs one shared table of distinguished points, so parallel walkers cannot each run inside their own transaction; a distinguished point is not a proof of work, so the chain cannot verify a share; and the cost at #140 is off by about eleven orders of magnitude even at the cheapest imaginable per-step price. Every record solve so far was a GPU herd off chain. Miners' hardware is not idle compute you can rent by the transaction; a transaction buys verification, not search. **On the Rule 110 tree.** The report stress-tests exactly that deployment, and it is the strongest version of your point: chained covenants really do carry a computation forward across transactions, one enforced step at a time. But look at what it enforces. Each cell proves its own bit; the shared row is checked by an off-chain audit tool, not by the chain. That is the exact shape of the kangaroo problem in miniature — the per-step work can be pinned, the shared table cannot. And the arcade costs roughly a sat per bit. Scale that to 10²¹ curve steps and the fee is the bottleneck, not the cleverness. **The half that works, and I can say so from something deployed.** The report lists four on-chain jobs: custody of the pool, a contribution ledger, on-chain key verification, and pro-rata payout. Three of those are not hypothetical for me. The covenant that settled yesterday holds a pool until a deadline, keeps a running hash accumulator of who contributed what, and at settle re-folds the revealed ledger and pays each address `floor + distributable × wᵢ / W`, with every output bound by hashOutputs so the spend cannot be anything else. That ran on mainnet with ten claimants. The fourth job — verifying `ecMulGen(k) == P_target` inside the script — is the genuinely new piece, and the report's ~429 KB estimate for it is the number to check first. **Where the trust actually sits, so nobody is surprised later.** In my covenant, wᵢ is sats paid, which the chain can see. In a search pool, wᵢ is distinguished-point shares an operator verified off chain. The covenant can pay out *exactly* what the ledger says; it cannot know whether the ledger is honest. So the design gives you trustless payout of trusted accounting. That is still better than every pool that exists today, where the payout is trusted too — but the operator does not disappear, they move. **Your best idea is still yours.** *"I would repeat the process using the Covenant to test it."* Keys for #1–#70 are public. That means the whole lifecycle — fund, contribute, claim with a known key, verify, pay out, refund path — can be rehearsed on testnet with real vectors before a single sat of anyone's money goes in. Most covenant projects never get free test vectors. This one has seventy. **What I think, in one line:** build the bounty covenant as a general primitive — "pay whoever reveals the key to this pubkey, pro-rata to a ledger" — because it's cheap, testable and reusable; treat the #140 search as what the report calls it, a positive-skew gamble whose expected value is negative at today's prices and turns around only if the herd gets #135's luck or the prize appreciates. And to be straight about my own part: I'm not taking this on as a build. My next build is already spoken for. If someone does pick up the covenant layer, I'll read what they write and say what I see — that part I can promise, because it's the part I've just done.