AERE verifies zk proofs natively, SP1 + RISC Zero live on chain 2800

AERE Network now natively verifies zero-knowledge proofs from the two leading EVM-targeting proving systems: SP1 v6.1.0 (Succinct Labs) and RISC Zero zkVM. The first real proof, a canonical SP1 Groth16 proof of a Fibonacci computation, was verified end-to-end at block 2,151,318 on chain 2800.

The stack we deployed

We followed the canonical pattern Succinct Labs and RISC Zero recommend for production deployments: concrete verifier contracts behind a gateway/router, with downstream apps integrating against the stable gateway address. When a future SP1 v7 or RISC Zero v2 ships, the gateway operator calls addRoute() to register the new verifier, every integrating app keeps working unchanged.

Update, 2026-08-01, measured. The first RiscZeroGroth16Verifier in the table was deployed with a non-canonical control root, so it computes the wrong selector and cannot verify a genuine RISC Zero receipt at all. It is deprecated and it is listed here only so that the address is recognisable as the wrong one. The corrected verifier is 0xb6fD00D8…89Ab5B9D, and the route is live: calling getVerifier(0xef6cb709) on the router 0x3f7015BC…296a249C returns exactly that address, and AereProofRegistry.risc0Router() returns that router. So canonical RISC Zero recording is wired, not pending. Honest scale, from the same reading: the registry has programCount() = 1 and proofCount() = 1. The plumbing works end to end and it has been used once.

The contracts are the canonical sources from the upstream succinctlabs/sp1-contracts and risc0/risc0-ethereum repositories, compiled with Solidity 0.8.23 and the standard 200-run optimizer. No AERE-specific modifications to the math, the only edits were import-path tweaks to match our OpenZeppelin v4.9 layout, and a constructor adapter to bridge OZ v4's Ownable() to upstream's v5-style Ownable(initialOwner) signature.

End-to-end verification, observed live

We registered the canonical Fibonacci program (vkey 0x004a55ed…3090) on AereProofRegistry and submitted SP1's official v6.0.0 Fibonacci Groth16 fixture proof. The flow:

1. AereProofRegistry.submitSP1Proof() verifies the program is registered + enabled
2. Routes the call to SP1VerifierGateway.verifyProof()
3. Gateway reads the first 4 bytes of the proof (selector 0x0e78f4db)
4. Routes to the v6.0.0 concrete verifier
5. Real Groth16 pairing math executes on the BN254 precompiles (≈230k gas)
6. Returns success → registry emits ProofVerified event with the program key indexed

Transaction: 0x8b5f36c4…1cfef3 in block 2,151,318. Gas used: 562,415 (verification + storage). The verified proof is permanently on-chain; off-chain consumers can subscribe to ProofVerified events filtered by their program of interest and use the attestation as input to their own logic.

Live event feed

See verified proofs as they land at aere.network/zk-proofs, a live event feed reading ProofVerified directly from the registry on chain 2800.

What you can build with this

• Privacy-preserving credentials: "I proved my credit score is above N without revealing my balance"
• Verifiable off-chain compute: "I proved this market-making strategy executed at fair price across N venues"
• Light-client bridges: "I proved Ethereum block N's state root, on AERE"
• Cross-chain state proofs: "I proved I own asset X on chain Y, redeem here"
• Compliance attestations: "I proved this transaction passed a regulatory check, without exposing the check's internals"

What we explicitly did NOT do

We did not deploy a placeholder verifier with stub math. We did not pin a release-candidate version and call it production. We did not build a fee-extracting middleware in front of free verification. Every contract on the list above is the canonical upstream source, deployed as-is, and the first proof verified is a real cryptographic proof from SP1's own test suite that any independent observer can re-run on the exact same data.