Compute Oracles: Bridging On-Chain and Off-Chain
By DEOS Team
Smart contracts have a problem: they're expensive.
Every operation costs gas. Every byte of storage costs gas. Complex computation? Prohibitively expensive. And that's by design—every node has to execute every transaction.
So we moved computation off-chain. But we lost something critical: trustlessness.
The Oracle Problem
Traditional oracles fetch external data and feed it to smart contracts. Price feeds, sports scores, weather data. But here's the issue: you're trusting the oracle operator to provide accurate data.
Compute oracles take this further. They don't just fetch data—they perform computation. Run an ML model. Execute complex logic. Process large datasets. Then return the result on-chain.
The trust problem compounds. Now you're not just trusting data accuracy—you're trusting that computation happened correctly.
Current Approaches
Optimistic verification. Assume the computation is correct, allow challenges within a window. Works for some cases, but the challenge window creates latency. And by the time fraud is detected, damage may be done.
Multi-party computation. Distribute the computation across multiple parties. If they collude, you're still vulnerable. And the overhead is significant.
TEEs (Trusted Execution Environments). Run computation in hardware-isolated enclaves. But TEEs have been compromised repeatedly. And you're still trusting the hardware manufacturer.
ZK proofs for specific computations. Mathematically prove correctness. Powerful, but currently limited to specific computation types that can be efficiently expressed in circuits.
None of these fully solve the problem.
The Complete Solution
What if you could:
- Run arbitrary computation off-chain
- Capture every operation deterministically
- Generate a cryptographic proof of exactly what happened
- Verify on-chain with a single proof
This is what verifiable compute oracles enable:
Any computation. Not limited to circuit-friendly operations. Run real programs.
Complete audit trail. Every syscall, every decision, cryptographically sealed.
Fraud-proof by construction. If the operator lies about the result, the proof won't verify.
On-chain verification. A single ZK proof verifies the entire off-chain computation.
The Architecture
Input → DEOS Runtime → Deterministic Execution → Proof Generation → On-chain Verification
The DEOS runtime captures everything needed to reproduce execution. The proof generation creates a succinct, verifiable commitment. On-chain verification confirms the computation happened correctly.
Off-chain compute. On-chain trust.
What This Enables
Complex DeFi. Risk models, portfolio optimization, ML-based trading—all with cryptographic proof.
Verifiable AI. Run AI models off-chain, prove the inference happened correctly.
Data processing. Process large datasets off-chain, commit results on-chain.
Cross-chain computation. Execute logic that depends on multiple chains, with unified proof.
The blockchain scalability problem isn't about making on-chain computation faster. It's about making off-chain computation verifiable.
This is the architecture we're building at DEOS. Follow for updates on our progress.