Full nodes rarely ship
Self-hosted verification is the honest baseline, yet embedding it in mobile, web, or embedded products is rarely viable—so teams quietly trade verification away before the first feature ships.
Core verification infrastructure
Colibri Stateless Client
Trustless blockchain access. Without running a node.
Colibri is a stateless, fully verifying client for Ethereum and EVM-compatible chains. Applications access and validate blockchain data locally using cryptographic proofs — without trusted RPC providers or full nodes.
Why Colibri
Trustless chains. Leaky client paths.
Applications sit between two bad options. Run a full node and you get real verification—but the cost in bandwidth, storage, and ops is so high that almost no consumer app ships one. Default to public RPC instead, and reads, previews, and simulations all flow through infrastructure you cannot check: trust moves off-chain, and queries can expose sensitive context. Many flows still ask users to sign with little clarity about outcomes—blind signing—or they route simulation through the same remote service, which repeats the trust and privacy problem under the label of safety. Colibri is built to break that pattern.
RPC answers you cannot audit
Remote endpoints return state and traces without cryptographic receipts. You inherit provider trust, and every call can leak what users do and when—metadata becomes someone else's dataset.
Signing and simulation in the dark
Without verified local state, users approve transactions they cannot fully interpret—or apps outsource what happens if I sign to RPC, importing the same trust and disclosure surface into the preview step.
Colibri delivers proof-backed verification and simulation on the device: the chain's trust model—without asking every user or every app to run a full node or to rely on intermediaries.
Core principles
Built for verification, not trust
Three pillars
Trustless by default
All data is verified with cryptographic proofs. No reliance on external infrastructure.
Local verification
Proofs run inside your application. Nothing is delegated to third parties.
Privacy-aware (PAP)
Pragmatic Adaptive Privacy limits exposure and metadata leakage from reads.
Foundation
Stateless architecture
No chain state stored or synchronized. Only what you need is fetched and verified — the load-bearing base everything else stands on.
How it works
Two proof systems, one stack
Consensus proofs anchor chain correctness; execution proofs validate accounts and storage — so your app reads real state.
Layer 1
Consensus proofs (classical)
Verify that a block belongs to the canonical chain by replaying every sync committee transition since the last trusted checkpoint.
- Replays all validator committee transitions
- Full chain of trust from checkpoint to head
- No external consensus assumptions
Layer 2
Execution proofs
Merkle proofs for accounts and storage — balances, contract state, arbitrary contract reads.
- Validate balances and contract storage
- Arbitrary smart contract data
- Full read verification
ZK Alternative
Recursive ZK Consensus Proof
Instead of replaying every committee transition individually, a single recursive zero-knowledge proof compresses the entire chain of transitions into one succinct proof — verifiable in constant time, regardless of how many transitions occurred.
- All committee transitions in one recursive proof
- Constant-time verification
- Same security guarantees, minimal computation
What you unlock
- Verify blockchain state locally
- Simulate transactions on proven data
- Operate without trusting RPC providers
Transaction simulation
Know the outcome before you sign
Wallets and dApps often simulate transactions against RPC-returned state you cannot verify. Colibri grounds simulation in the same proven execution layer: balances, storage, and contract logic are backed by Merkle proofs, so previews match what a fully verifying client would compute.
- Run eth_call, gas estimates, and revert reasons against verified state — not a provider’s word.
- Combine consensus proofs with execution proofs so the pre-state for a simulation is cryptographically anchored.
- Reduce blind signing: users see effects that are consistent with locally checked data.
- Explain - human readable - what the transaction is going to do.
Privacy — PAP
Pragmatic Adaptive Privacy
Read operations leak intent, balances, and patterns. PAP reduces metadata leakage, adapts exposure to context, and keeps access functional without oversharing.
Less metadata leakage from read requests
Context-aware data exposure
Privacy-preserving access without breaking UX
What you can build
From wallets to agents
Wallets
- Verify balances locally
- Simulate before signing
- Remove RPC trust
dApps
- Operate on verified state
- Correctness for every read
IoT systems
- Constrained devices
- Intermittent connectivity
AI agents
- Verified inputs
- Deterministic actions
Swipe for more
Wallets
- Verify balances locally
- Simulate before signing
- Remove RPC trust
dApps
- Operate on verified state
- Correctness for every read
IoT systems
- Constrained devices
- Intermittent connectivity
AI agents
- Verified inputs
- Deterministic actions
Performance
Built for real deployments
- No full node required
- Low bandwidth
- Predictable verification overhead
- Optimized for mobile, web, and embedded
Colibri replaces network trust with local computation.
Integration
Drop into your stack
Lightweight client, APIs and bindings for real workflows. Optionally pair with vRPC for verifiable delivery — or run standalone for pure local verification.
Verifiable. Local. Controlled.
No trust in infrastructure is required — only in cryptography you run yourself.