corpus.core

colibri.stateless - A stateless, proof-based ultra-light client that runs anywhere - mobile, IoT, browser - so wallets and apps never have to trust RPCs

[corpus.core @CorpusCoreHQ]

Last week we hosted a twitter space with @ChrJentzsch and @griffgreen to talk about the impact of TheDAO.

During the conversation, @simon_jentzsch explained how @thedaofund relates to our project and emphasized the importance of RPCs in Web3 security!

[corpus.core @CorpusCoreHQ]

The distinction between redundant trust and cryptographic verification is the central argument in our KelpDAO post-mortem.
One month on: the financial hole is being filled. The architectural hole is not.
https://t.co/0Q4ZiPiOBs
#DeFi #BridgeSecurity #Ethereum

[corpus.core @CorpusCoreHQ]

Chainalysis called it a "trust-layer failure."
Not a code failure. Not a governance failure. A failure in the layer that sits between the contracts and the data they read.
"At the transaction level, every step of the exploit was indistinguishable from normal bridge activity. The validator's signature was valid. The message format was valid. The release function behaved exactly as designed."
@chainalysis #KelpDAO #rsETH

[corpus.core @CorpusCoreHQ]

Chainalysis recommends cross-referencing RPC responses across multiple independent gateways and treating mismatches as attack signals.
That's the right operational instinct. But it still assumes the defense is redundant trust, more intermediaries whose responses you compare.
Cryptographic proof flips the model: instead of trusting multiple sources and hoping they agree, you verify the claim directly against the chain's own consensus. The proof checks out or it doesn't.

[corpus.core @CorpusCoreHQ]

We wrote the longer version of this argument — why all the proposed fixes leave the fundamental architecture intact, and what a structural solution would actually require.
https://t.co/0Q4ZiPiOBs
#DeFi #Web3Security #TrustlessVerification

[corpus.core @CorpusCoreHQ]

OpenZeppelin's postmortem on the KelpDAO exploit opens with a striking finding:
"The smart contracts were correct. The code was clean. The system failed operationally."
$292M stolen. Zero bugs. That sentence should end the debate about whether smart contract audits are sufficient for bridge security.
@openzeppelin #KelpDAO #BridgeSecurity

[corpus.core @CorpusCoreHQ]

OpenZeppelin draws a clean line between code risk and operational risk.
We'd extend that line one layer further: between trust-based architecture and cryptographic verification.
More DVNs reduce operational risk. They don't eliminate the structural assumption; that source-chain state can be established by trusted off-chain intermediaries at all.
As long as that assumption holds, the attack surface UNC4899 exploited on April 18 remains open for the next variation.

[jorkleo.eth @JorkLeonhardt]

The Code Was Fine. That's the Problem.
Read our Post-Mortem of the Kelp-DAO Incident.
https://t.co/nKWUeFVey5

[Simon Jentzsch @simon_jentzsch]

2/2 Normally, stateless verification forces you to run eth_createAccessList first to know what to prove. The problem? It leaks your entire call message to the RPC.

To fix this in privacy mode, I bypassed the access list entirely:

1. Run the local EVM blindly first and track SLOAD calls. 2. Serve from local cache, or dynamically fetch missing state via eth_getProof.
3. Once it clears the EVM, verify all proofs at the very end.
To close the last metadata leak, @oblivious_labs handles the eth_getProof request inside a TEE, building the proof via ORAM so access patterns stay hidden.
Full cryptographic security + absolute privacy without trusting a centralized node.

Check out the repository here: https://t.co/1IERDnePQ2
https://t.co/F0JYHi9DFZ

[Simon Jentzsch @simon_jentzsch]

As we see with the recent @gnosispay exploit how essential absolute security and instant verification are, we just made a giant leap forward on the privacy front.

Just managed to execute the first fully private and verifiably secure eth_call using colibri-stateless.(@CorpusCoreHQ)
no state leaked, zero-trust validation, and the RPC provider sees absolutely nothing but isolated cryptographic proofs.

Huge thanks to the @obliviouslabs for spinning up the TEE/ORAM test instance to make this happen.

[corpus.core @CorpusCoreHQ]

The PAP integration goes further: read privacy isn't a setting users configure — it's applied per read, based on context, automatically.
An ENS lookup reveals intent. Who you're resolving, when, how often. The Privacy Abstraction Layer handles that below the application level.
Privacy that ships as infrastructure rather than a feature. That's the goal.
https://t.co/Z8PHNsJKtT

[corpus.core @CorpusCoreHQ]

Freedom Browser just shipped an update — and it now uses Colibri as its reference implementation for ENS resolution.
That means domain lookups are stateless and proof-verified. No trusted RPC to resolve a name. No centralized gateway in the path. Just cryptographic confirmation against the chain.
Decentralized content via Swarm and IPFS. Trustless name resolution via Colibri. The stack gets more complete.
@heckerhut

[corpus.core @CorpusCoreHQ]

This is the right frame.
Trust dependencies are often invisible by design, not maliciously, but because convenience defaults toward "just works" rather than "explicitly disclosed."
A nutrition label makes them legible. But legibility is the beginning, not the end.
The more interesting question is which dependencies can be eliminated entirely, replaced by math rather than disclosed as actors. The RPC layer is an obvious candidate: most applications carry an undisclosed runtime dependency on a centralized provider whose behavior they cannot verify.
Proof-based access removes that dependency from the list rather than labeling it. The trust surface doesn't just become visible. It shrinks.
Both matter. Labeling is how you see what needs fixing. Elimination is the fix.

[Florian Glatz @heckerhut]

Update re freedom browser

Recently we switched from multi RPC quorum for ENS resolution to Colibri, a fully stateless, proof-verified method. it’s super fast and makes resolving ENS names (forward and reverse) a breeze. Can wholly recommend it!

More news dropping soon! 📱

[corpus.core @CorpusCoreHQ]

Circuit breakers and timelocks are good engineering. No argument there.
But they're code-level governance. The KelpDAO exploit was infrastructure-level trust. Compromised RPC nodes feeding false state to a verification layer that had no way to challenge it. By the time a security council could react, $292M was gone.
"Gated" doesn't help if the gate's sensors are compromised.
The missing layer isn't access control on participants. It's verification of data. A system that cryptographically confirms what it's reading (rather than trusting the infrastructure delivering it) catches the attack before the contract logic ever runs.
Training wheels make sense. But they need to be on the right wheel.

[corpus.core @CorpusCoreHQ]

A nutrition label tells you what trust you're accepting.
The deeper goal is infrastructure where that list gets shorter, where math replaces actors, and proofs replace assumptions.
Stateless verification is one step toward that: instead of trusting an RPC provider to tell you the truth, your application verifies it cryptographically. The trust dependency doesn't get labeled, rather it gets eliminated.
Labels are valuable. But the endgame is a shorter ingredient list.

[corpus.core @CorpusCoreHQ]

The question isn't "who gets access." It's "can the system verify what it's reading."
Permissioned systems narrow the participant set. They don't eliminate compromised infrastructure, state manipulation, or forged cross-chain messages. Lazarus wouldn't have been stopped at a KYC gate — they were already inside the infrastructure layer.
The answer to "DeFi has trust problems" is not "add more trusted gatekeepers." It's "reduce the surface where trust is required."
That's what proof-based verification does.

[corpus.core @CorpusCoreHQ]

Permissioned DeFi is the wrong answer to the right observation.
Yes, the last weeks exposed real failures. But KelpDAO wasn't compromised because it was permissionless. It was compromised because its verification infrastructure had a single point of trust — one compromised RPC node feeding false state, and no independent proof-check to catch it.
Gatekeeping participants doesn't solve that. A compromised data source looks the same whether the attacker passed KYC or not.

[corpus.core @CorpusCoreHQ]

Under the hood: Freedom Browser uses Colibri.stateless for trustless data access and applies PAP's T1/T2 transport and C1 content mechanisms automatically — below the application layer.
Developers building on Freedom Browser get read privacy without writing a single line of privacy logic. That's the Privacy Abstraction Layer working as designed.
https://t.co/Z8PHNsJKtT

[corpus.core @CorpusCoreHQ]

Freedom Browser is live — and it ships with Colibri as its reference implementation, including full PAP support.
What that means in practice: every blockchain read the browser makes is stateless, proof-verified, and privacy-adaptive by default. No trusted RPC. No observable intent. No state to maintain.
This is what it looks like when pragmatic privacy becomes infrastructure rather than a feature.
Welcome to the ecosystem, FreedomBrowser.eth, 🤝
@heckerhut , @meinharrd