A plain-language guide to the cryptographic fingerprints on your receipt.
When you fund a cleanup pool, you are trusting that your Bitcoin actually reached CleanProof, that CleanProof actually paid it out to real cleaners, and that the numbers on the receipt match reality.
A normal receipt from any organisation is just a document they wrote. You have to trust they did not make it up. CleanProof receipts go further -- they include runes, cryptographic fingerprints that let you independently verify the payment trail without trusting us.
In CleanProof, a rune is a mathematical fingerprint. You feed any data into a hash function and it produces a short fixed-length string of letters and numbers. We use SHA-256 -- the same function that secures the Bitcoin network -- which always produces exactly 64 characters.
Same input always produces the same output. Run the same data through SHA-256 twice and you get the identical 64-character rune, on any computer, in any country, forever.
Changing even one character changes the rune completely. If an amount was 2,530 sats and someone changed it to 2,531, the rune would look entirely different. There is no way to make a small change and get a similar-looking rune.
You cannot reverse it. Given a rune, you cannot recover the original data. But given the original data, anyone can verify the rune -- which is what makes them useful for auditing.
We chose the name runes deliberately. In Norse mythology, runes were not just letters -- each one was a seal of meaning, carved into something real to make it true and verifiable. That is exactly what these do.
Fehu -- the funding rune
Fehu is the rune of wealth flowing outward. It marks the moment resources are committed.
When you fund a pool over Lightning, your payment produces a payment hash and a preimage. The preimage is the secret that proves the invoice was paid: hashed with SHA-256 it equals the payment hash on your receipt. Your wallet holds the preimage; your receipt records the payment hash.
One catch that trips people up: the preimage is hex (64 characters). You must decode it to its 32 raw bytes before hashing -- do not hash it as text. In an online SHA-256 tool, set the input encoding to Hex (not UTF-8/Text); on a command line:
echo -n <preimage> | xxd -r -p | sha256sum
Hashing it as text produces a completely different value. That looks like a failed proof, but it only means the tool was set to text -- it does not mean the receipt is fake. Test the mechanic on this dummy preimage first (not a real one), so you know your tool is set up right before you touch your own:
preimage 0000000000000000000000000000000000000000000000000000000000000001
as bytes ec4916dd28fc4c10d78e287ca5d9cc51ee1ae73cbfde08c6b37324cbfaac8bc5 (correct)
as text c386d8e8d07342f2e39e189c8e6c57bb205bb373fe4e3a6f69404a8bb767b417 (wrong -- tool set to text)
The Fehu rune is the SHA-256 of one exact string -- the payment hash and total budget, written as JSON:
Fehu = SHA-256( {"payment_hash":"3e11d230...f918","total_budget":60000} )
The exact text matters -- SHA-256 changes completely if a single character does. The rule for every rune below: keys in the order shown, string values in double quotes, whole numbers with no quotes and no thousands separators, and no spaces anywhere. Your receipt and the exported JSON show the exact string for your pool, so you never have to guess the format -- copy it and hash it as-is.
To verify: take the exact string shown on your receipt, run it through SHA-256, and you get the same Fehu rune. If someone changed the amount in the CleanProof database, the string changes and the rune no longer matches.
Raido -- the cleanup rune
Raido is the rune of the journey, movement with purpose. It marks each completed trip.
For every cleanup, we compute a Raido rune -- a fingerprint of the cleanup record. The inputs are the submission ID, what the cleaner earned for it (base plus any bonuses), the two GPS coordinates (latitude and longitude as separate fields), when the review was finalised, and the average star rating -- serialized as JSON in this order:
Raido = SHA-256( {"submission_id":"abc123","reward_sats":500,"gps_lat":7.07,"gps_lng":125.6,"reviewed_at":"2026-09-15T04:00:00Z","avg_rating":4} )
Raido seals what the cleanup was, not whether the cleaner has been paid yet. The payment hash is deliberately NOT in it: it only exists once the cleaner withdraws, and a seal that moved when they got paid would not be a seal. The payment is proven separately, on each cleanup's proof page, where it appears only once it is real.
Recomputing a Raido rune shows the cleanup record has not been altered since it was sealed. There is one Raido rune per cleanup.
Ingwaz -- the pool rune
Ingwaz is the rune of the seed, everything gathered and made whole. It marks completion.
The Ingwaz rune is a single fingerprint representing all the cleanups in a pool. Take every Raido rune, sort them in ascending (alphabetical) order, join them into one string with nothing between them, and hash that. A pool with no cleanups yet hashes the literal word "empty".
Ingwaz = SHA-256( raido1 + raido2 + ... sorted, joined, no separator )
This borrows the same idea used in Bitcoin to summarise many transactions into one root value. The result: one number representing the entire payment history of the pool. If any single payment was altered -- the amount, the GPS, the rating -- the Ingwaz rune would change.
Dagaz -- the receipt rune
Dagaz is the rune of dawn, the moment clarity arrives. It marks the full picture.
The Dagaz rune ties everything together. It is the SHA-256 of a JSON string holding the Fehu and Ingwaz digests plus the three budget figures, in this order:
Dagaz = SHA-256( {"hashB":"<Fehu>","hashPP":"<Ingwaz>","cleaner_budget":54000,"remaining_budget":54000,"platform_allocation":6000} )
This one number is a fingerprint of the entire pool -- the source funds, all the payments, and the budget accounting. If any input was changed after the fact, the Dagaz rune would no longer match. It is the final seal: one value that either confirms the whole receipt is internally consistent, or tells you something is wrong.
Lightning deposit payment
Fehu (fingerprint of your deposit)
Each cleanup record
Raido (one per cleanup)
All Raido runes combined
Ingwaz (fingerprint of the whole pool)
Fehu, Ingwaz and the budget figures
Dagaz (the final receipt seal)
Alter anything in the chain and the Dagaz rune changes. The chain either holds end to end, or it does not.
You do not need to trust CleanProof's website. The export button on your receipt page downloads a JSON file containing all the inputs.
Check your deposit
Take the payment hash from the JSON. Decode your wallet's preimage from hex to its 32 raw bytes (set the tool to Hex, not text) and SHA-256 those bytes -- the result equals the payment hash, proving the payment is yours. Then confirm the Fehu rune: SHA-256 of the hashB_input string in the JSON (for newer pools that is your deposit invoice verbatim; for older ones it is the JSON of payment hash and budget). Hashing the preimage as text gives a wrong answer that only means the tool was set to text -- not that the receipt is fake.
Check a payment
Take any cleanup's Lightning payment hash from the JSON. The cleaner can verify this in their Lightning wallet -- their wallet received a payment with that exact hash. Entirely independent of CleanProof.
Recompute the Dagaz rune
The JSON gives you every input. Run them through SHA-256 in the same order and you will get the same Dagaz rune in the file. If someone tampered with the export, the runes would not be consistent.
Check the code
The JSON includes a GitHub commit hash linking to the exact code that ran when your cleanups were processed -- the reward formula, the 90/10 split, the two-reviewer rule. Under 200 lines total.
The runes prove money moved. They do not prove the cleanup was genuine.
The Raido runes confirm real Lightning payments happened. They do not confirm the videos were filmed at the stated location, that the area was dirty beforehand, or that the cleanup was real. That verification is done by the peer review system -- two independent reviewers watch both videos before any payout is approved.
A full audit of any cleanup requires watching the videos, not just checking the runes. The receipt links to every video on each cleanup page. The runes tell you the accounting is honest; the videos tell you the work was real.
The 90/10 split is enforced by code, not a smart contract.
The code is public and the commit hash on your receipt links to the exact version that ran. CleanProof could in principle deploy different code -- which is why we publish the formula openly, so anyone can audit what was actually running at the time of any receipt.
Most charitable receipts are just a PDF. You trust the organisation's word that the money went where they said. CleanProof receipts are different in a specific, limited, but real way: the payment trail is independently verifiable by the people who hold the payments, using cryptographic proofs CleanProof cannot forge or alter.
The Lightning Network recorded your deposit and each payout. The four runes -- Fehu, Raido, Ingwaz, Dagaz -- are the cryptographic thread connecting those payment facts to your specific receipt. Anyone who knows basic SHA-256 can pull that thread and confirm it holds.
Not a blockchain. Not smart contracts. Just mathematics applied carefully to public data, producing fingerprints anyone can recompute.