Unlocking Sophisticated Onchain Finance with ZK-Proven Data
DeFi protocols run on a very narrow data model. Smart contracts can enforce rules and react to the current state of the chain, but they have no understanding of history: how users behaved, how positions evolved, how risk accumulated over time. This limitation shapes what DeFi can and can’t do.
The data DeFi can’t see
Smart contracts can only access what exists inside their execution environment:
• Current balances
• Protocol state already stored onchain
• Current prices (via oracles)
What they can’t do is query history or compute over time. A smart contract can’t ask:
• How has this position behaved over the last 30 days?
• How volatile has this asset been over a given window?
• How often has this wallet been liquidated in the past?
Anything that requires aggregation, time-based analysis, or historical computation falls outside the EVM’s execution model. As a result, DeFi protocols face a hard dichotomy: either they avoid using historical or behavioral data in execution logic, and accept simpler, less data-driven designs, or they compute that data offchain and introduce some form of trusted infrastructure to feed it back onchain.
Most mature protocols choose the first path for core logic, using offchain analytics for dashboards, monitoring, and human decision-making, but not for contract execution itself. The second path enables more sophisticated designs, but comes with trust and centralization tradeoffs.
What this tradeoff looks like in practice
The limitations around historical data shape what kinds of financial products are even feasible onchain today.
Example: Lending
Most DeFi lending protocols rely on static or near-static parameters: overcollateralization ratios, liquidation thresholds, and interest rate curves that respond to current utilization, not borrower behavior over time.
In traditional finance, lending decisions incorporate history:
• How volatile has the collateral been over multiple regimes?
• How has this borrower behaved across market cycles?
• How often has this position approached liquidation thresholds?
Onchain, those questions are unanswerable inside execution. The result is conservative designs that assume the worst-case borrower and the worst-case market, leading to capital inefficiency and blunt risk models.
Example: Derivatives
Modern derivatives pricing depends on time-series data: volatility surfaces, historical correlations, rolling windows, and stress scenarios. These are not optional inputs; they are the product.
Because smart contracts can’t natively compute over historical data, most onchain derivatives are structurally simplified:
• Perpetuals instead of true options
• Funding rates instead of volatility modeling
• Hard-coded parameters instead of adaptive risk
Fully featured options markets require historical analysis that today lives offchain, making it difficult to bring into trustless settlement.
Example: Risk management and portfolio construction
In traditional finance, portfolio risk is managed holistically, not asset by asset. Exposure limits, margin requirements, and capital allocation are driven by historical correlations, drawdowns, and stress scenarios across entire portfolios.
Onchain, most protocols can only reason about positions in isolation and at a single point in time.
A smart contract generally can’t ask:
• How correlated are these assets during periods of stress?
• How has this portfolio behaved during past drawdowns?
• What is the historical worst-case loss over a rolling window?
Without access to historical and cross-asset data at execution time, protocols default to simplified assumptions: fixed risk weights, static haircuts, and per-asset parameters that ignore how assets behave together, which leads to familiar outcomes:
• Conservative margin requirements
• Poor capital efficiency for diversified portfolios
• Risk models that fail abruptly rather than adapt gradually
The irony is that DeFi offers perfect transparency and composability at the state level, but much weaker tooling at the historical level. That imbalance makes it difficult to build systems that manage risk dynamically, even when all the raw data is technically public.
The missing primitive: Making historical data usable onchain
The constraint of onchain finance isn’t a lack of data. Blockchains are already rich with history. The problem is that smart contracts can’t compute over that history in a trustless way.
Space and Time changes that by making historical data, and more importantly, computation over that data, verifiable.
Instead of asking a smart contract to store or iterate over months of data, protocols can define the computation in Space and Time, execute it over historical blockchain data, and return a result accompanied by a ZK proof.
That proof lets the contract verify, at execution time, that the correct data was used, the full historical window was included and the computation was performed exactly as specified without trusting the party that ran the query.
This unlocks an entirely new design space for DeFi. Lending protocols can adjust parameters based on a position’s historical behavior, not just its current state. Derivatives can reference realized volatility or historical distributions instead of relying on proxies. Risk engines can evaluate portfolios using time-based metrics rather than static assumptions.
Crucially, this doesn’t require moving data offchain or weakening security guarantees. Historical analysis happens in Space and Time. Verification happens on the EVM. That pipeline is what allows sophisticated, data-driven financial logic to exist without reintroducing centralized trust.
In short, Space and Time doesn’t just provide more data. It makes history actionable inside smart contracts.
