The Primitive
What zkde.fi actually is
zkde.fi is a proof-gated execution system on Starknet — live on mainnet today with two production surfaces, and a full proof pipeline on Sepolia preparing for broader launch.
What's on mainnet now:
- /portfolio — AI-driven portfolio rebalancing across Ekubo, Vesu, and staking protocols. Real capital, real transactions, real receipts. Currently tracking ~$75M across Starknet DeFi.
- /passport — Portable reputation passport. Your on-chain activity compiled into a verifiable reputation profile with tier progression, gate unlocks, and FICO-pack proofs.
What's on Sepolia (coming to mainnet): Capital OS and Trade Desk — the full-feature version of the app with zkML circuit verification, privacy rails, selective disclosure, and five-lane proof settlement. Same product, deeper proving, not yet mainnet.
The parent infrastructure is StarkForge by Obsqra Labs. zkde.fi is one application built on top of it.
The gap this closes
On-chain execution is trustless — smart contracts enforce rules deterministically. But off-chain computation is not trustless at all. When an AI model says "this pool is safe" or "allocate 40% here," you're taking its word for it. There's no cryptographic guarantee that the model ran correctly, that the inputs were real, or that the output wasn't manipulated between inference and execution.
This is the gap: the trust boundary between off-chain reasoning and on-chain action.
Most projects paper over this with reputation ("trust us, our model is good") or transparency ("here's the model weights on GitHub"). Neither gives you a mathematical guarantee. zkde.fi closes the gap with proofs: off-chain computation produces on-chain-verifiable proof before capital moves. Not after. Before.
The architecture: SNARK-in-STARK dual lane
Instead of picking one proving system and hoping it covers everything, zkde.fi runs two independent proof lanes in parallel:
SNARK lane (Garaga/Groth16) — Handles zkML verification. EZKL converts ML model inference into Groth16 proofs. These get verified on-chain via Garaga's BN254 pairing check, implemented natively in Cairo. When you see "the model output was correct," this lane proved it.
STARK lane (Stone) — The same STARK prover infrastructure that generates validity proofs for Starknet blocks. Here it handles execution integrity — proving that the full computation (policy checks, gate evaluation, settlement routing) executed correctly. Think of it as "the recipe was followed faithfully."
When both lanes are active (FULL_DUAL_PROVER mode), a single action produces two independent cryptographic guarantees: the AI output is correct (SNARK), and the execution that consumed it was faithful (STARK). Two different proof systems, two different trust assumptions, one atomic action.
flowchart LR SIG[Signal / intent] --> EZKL[EZKL inference] EZKL --> G16[Groth16 proof] G16 --> GAR[Garaga KZG check in Cairo] GAR --> STONE[Stone STARK envelope] STONE --> GATE[Policy gate] GATE --> SETTLE[Settlement + receipt] SETTLE --> REG[Fact registry]
The mainnet deployment runs a streamlined version of this pipeline optimized for the rebalancer flow. The Sepolia deployment exercises the full five-lane proving stack with all circuit types.
What the system can actually prove
These aren't aspirational capabilities — they're implemented and verifiable at zkde.fi/test:
Input provenance — the data fed to a model came from a verified source (oracle, on-chain state, committed private input). You can't slip in fake data.
Model integrity — the ML model that produced a recommendation is the same model whose weights were committed on-chain via KZG. Not a different version, not a fine-tuned variant. The exact model.
Execution constraints — the transaction that resulted from the recommendation respected slippage bounds, allocation limits, and policy gates. The proof covers the constraints, not just the recommendation.
Policy compliance — the user's trust posture (reputation tier, collateral ratio, proof history) met the minimum threshold for the action at the time it was taken.
Settlement finality — the proof was registered in the fact registry and is independently verifiable via block explorer. Not a centralized database. An actual on-chain fact.
What's deployed
Starknet mainnet
The production deployment. The backend reads your mainnet chain state (positions, balances, activity) via RPC. Swaps route through mainnet Ekubo directly through your wallet.
Our mainnet contracts:
| Contract | Purpose |
|---|---|
| ReceiptRegistry | Immutable receipt attestations — every portfolio operation and passport export gets a receipt written here |
| ReceiptOS Archive | Permanent archive for receipt metadata and attestation history |
| SelectiveDisclosure | Prove properties about your data without revealing it — used by the compliance panel |
Third-party mainnet protocols we route through:
| Protocol | What we use it for |
|---|---|
| Ekubo DEX | Swap execution + LP positions |
| Vesu Lending | Position scanning, lending routes |
| StarkGate Bridge | Bridge activity scanning for reputation |
| MIST Chamber | Privacy wrapping/unwrapping |
Full addresses: Contracts
Starknet Sepolia
The full proof-gated execution pipeline. This is the infrastructure being brought to mainnet as PMF demand grows.
| What | Examples |
|---|---|
| Vault system | VaultController (v3), EkuboLpAdapter, LendingAdapter, StakingAdapter |
| Agent system | ReputationRegistry, AllocationRouter, AgentIdentity, BatchVerifier, TieredAgentController |
| 5 FICO-pack verifiers | Solvency, risk tier, performance, strategy integrity, execution integrity |
| ZkmlVerifier + GaragaVerifier | zkML and Groth16 verification in Cairo |
| Privacy pools | FullyShieldedPool, FullPrivacyPoolV2 |
| Governance | DAOConstraintManager, ObsqraFactRegistry |
| 31 Circom circuits | Compiled to WASM + zkey |
| 2 EZKL ML models | Yield forecast, anomaly detector |
Ethereum Sepolia
| Contract | Purpose |
|---|---|
| Halo2Verifier (EZKL KZG) | On Etherscan |
| L1 Bridge Sender | Cross-chain proof messaging |
By the numbers:
- 31 Circom circuits compiled to WASM + zkey
- 2 EZKL ML models with Halo2/KZG proofs
- 136+ on-chain trust receipts
- 5 verified proof lanes: Groth16 (Garaga), STARK (Stone), Noir HONK, Native KZG, hash-only fallback
- ~$75M tracked across Starknet DeFi protocols
Live verification: zkde.fi/test
Where to go next
Using the app now? Go to /portfolio or /passport on mainnet.
If you want to understand the building blocks, read Core Concepts. For proof system internals, go to Proof Pipeline. To try the full Sepolia experience, Quick Start covers wallet connect to first execution.