Something has bothered me for a while, and I finally built the thing that fixes it.
In security work, "we fixed it" is almost always an assertion.
A bug gets found. A patch gets written. Someone reviews the diff, nods, and says it looks right. Maybe a re-audit happens. Then everyone moves on and the fix becomes a line in a report.
But notice what usually does not happen: nobody takes the original exploit, runs it again against the patched code, and proves the specific thing it did no longer happens.
We reason about fixes. We rarely re-run them.
That gap has consequences. A patch can look correct and miss the actual path. A patch can close the hole and quietly break legitimate use at the same time. A patch can work for the wrong reason. All three happen, and a diff review catches none of them reliably, because reading code is not the same as executing it.
So I built ExploitLens.
You give it three things: a real exploit, the commit it worked against, and the commit meant to stop it. It replays the exploit against both commits under identical frozen inputs, using real Foundry execution, not a simulation of execution, the real thing. Then it aligns the two call trees semantically and finds the first causal divergence: the exact call where the two runs stop agreeing, which is where the prohibited effect stops being reachable.
It also runs a third phase that I think matters more than people expect. It checks that legitimate use still works at the patched commit. A patch that stops the exploit by breaking the contract is not a fix, and if you only test the exploit you will never notice.
The output is a Fix Receipt: a schema validated evidence bundle with a hash over its own contents. Rederive the hash offline and a single altered byte fails the check. You do not have to trust me, or the tool, or a dashboard.
Here is the part I care about most.
ExploitLens will not tell you a contract is secure.
No replay can establish that. It cannot tell you no other vulnerability exists, because it never went looking. It will not give you a verdict without a reproduction, and when a gate fails, the failure stays in the committed bundle rather than getting smoothed into something more comfortable.
What it will tell you is narrow and provable: this exploit, against this patch, under these inputs, no longer produces this effect and here is exactly where it stopped.
I would rather ship a small true claim than a large vague one. The security industry has enough green badges.
for now it'll carry two cases you can click through yourself. One is a controlled reentrancy fixture. The other is a real 2022 DeFi incident TempleDAO/STAX replayed and verified end to end.
Code: https://t.co/IohMqw0zZK
Over the next couple of weeks I am taking it further: wiring it into @Telegraphprotoc so it can buy verified on chain facts about the real incident, instead of assuming its local reproduction matches what actually happened. A local proof is only as good as its connection to reality, and that connection has to be bought, not assumed.
I will be posting the build as it happens including the parts that break. If you do security work, or you have opinions about what a fix should have to prove before anyone calls it fixed, I want to hear them.
A man in London sends cash home to his mother in Kano. A bag of rice.
He hopes it gets there. He hopes it doesn't get spent on something else. He hopes a middleman doesn't skim it. He hopes the "payment successful" screenshot the vendor just received isn't one of the fakes now sold by subscription to 61,000+ people on Telegram.
Hope is not a payment rail.
What if the money itself could wait, held by the network, until the rice is actually in her hands?
What if the vendor couldn't take it early, and the platform couldn't either?
What if nobody delivered, and the money just came back on its own?
That's Yazo.
Yazo locks a dollar-priced payment on Bitcoin Lightning until the person receiving the goods shows a one-time delivery code. Then it releases. In seconds. To the vendor. No bank alert to fake. No screenshot to forge. No middleman to skim.
If the code never comes, the hold expires and the payer is refunded automatically. Nobody asks. Nobody approves. Nobody intervenes. The network does it.
How it actually works:
The payer orders $40. Yazo issues a Lightning hold invoice for that exact sum. The network holds it, not Yazo. The recipient gets a QR code, shown once the goods are in hand. That code unlocks a preimage that settles the invoice.
The server stores only a salt and a payment hash. Never the secret. Never the preimage. So even someone who steals the entire database cannot release the money. Only the person holding the secret can. This is tested directly: test/attack.test.js hands an attacker everything the server stores and proves it still cannot settle.
Four steps, each enforced by the network itself, not by a dashboard button, not by an admin:
1 Order it
2 Pay it
3 Show the code
4 It's released
Delivered? Vendor paid in seconds. Undelivered? Payer refunded. Every time.
Built on Node.js with node:https, node:sqlite, node:test. Zero runtime dependencies. 165 tests passing. LND authenticated via invoice.macaroon only, which can create and settle invoices and nothing else. It cannot send funds. It cannot even call getinfo.
Live on testnet with Lightning mechanics, hold invoices andHTLC enforcements.
Try it: https://t.co/Lc0lIhgg2i
Code: https://t.co/Y9UyKrQgbZ
demo: https://t.co/bP2anNwCHL
Send the goods, not the cash.
A man in London sends cash home to his mother in Kano. A bag of rice.
He hopes it gets there. He hopes it doesn't get spent on something else. He hopes a middleman doesn't skim it. He hopes the "payment successful" screenshot the vendor just received isn't one of the fakes now sold by subscription to 61,000+ people on Telegram.
Hope is not a payment rail.
What if the money itself could wait, held by the network, until the rice is actually in her hands?
What if the vendor couldn't take it early, and the platform couldn't either?
What if nobody delivered, and the money just came back on its own?
That's Yazo.
Yazo locks a dollar-priced payment on Bitcoin Lightning until the person receiving the goods shows a one-time delivery code. Then it releases. In seconds. To the vendor. No bank alert to fake. No screenshot to forge. No middleman to skim.
If the code never comes, the hold expires and the payer is refunded automatically. Nobody asks. Nobody approves. Nobody intervenes. The network does it.
How it actually works:
The payer orders $40. Yazo issues a Lightning hold invoice for that exact sum. The network holds it, not Yazo. The recipient gets a QR code, shown once the goods are in hand. That code unlocks a preimage that settles the invoice.
The server stores only a salt and a payment hash. Never the secret. Never the preimage. So even someone who steals the entire database cannot release the money. Only the person holding the secret can. This is tested directly: test/attack.test.js hands an attacker everything the server stores and proves it still cannot settle.
Four steps, each enforced by the network itself, not by a dashboard button, not by an admin:
1 Order it
2 Pay it
3 Show the code
4 It's released
Delivered? Vendor paid in seconds. Undelivered? Payer refunded. Every time.
Built on Node.js with node:https, node:sqlite, node:test. Zero runtime dependencies. 165 tests passing. LND authenticated via invoice.macaroon only, which can create and settle invoices and nothing else. It cannot send funds. It cannot even call getinfo.
Live on testnet with Lightning mechanics, hold invoices andHTLC enforcements.
Try it: https://t.co/Lc0lIhgg2i
Code: https://t.co/Y9UyKrQgbZ
demo: https://t.co/bP2anNwCHL
Send the goods, not the cash.