How Spout and Stork Solved Pricing for Tokenized RWA Lending in Real Time

Ecosystem

July 14, 2026

Accurate pricing is the foundation of every loan. That’s why Spout has partnered with Stork to power the pricing infrastructure behind our tokenized RWA lending protocol.

The Problem

Spout lets users borrow against tokenized real-world assets and crypto at 0% APR. That model only works if one thing is true at every second the protocol is live: the price backing every loan has to be accurate, and it has to move at the speed of Solana, not five seconds behind it.

For crypto collateral, that might be a solved problem, dozens of oracles stream BTC and SOL prices with sub-second freshness. But for tokenized stocks and other real-world assets, it isn’t. Most oracle networks were built for crypto-native markets. Equities, indices, and RWAs are a different data problem, and a lot of infrastructure either doesn’t cover them well or updates too slowly to be safe for lending.

That gap matters more in a near zero rate model than almost anywhere else in DeFi. There’s no interest rate buffer absorbing small pricing errors over time. If the price feed lags during a fast move, a stock gapping down at market open, a sudden RWA repricing, the protocol either liquidates a healthy position or fails to liquidate a bad one. Both are protocol-risk events. Both erode trust. For a lending protocol built on tokenized RWAs, the oracle is the thing the entire trust model rests on.

The Fix

We partnered with @StorkOracle, an oracle network built specifically around ultra-low-latency price delivery, to power the liquidation and pricing infrastructure behind Spout’s RWA and stock-backed loans.

Stork’s core design choice is what made it the right fit: instead of pushing prices on-chain on a fixed schedule (the traditional oracle model), Stork uses what’s called a pull oracle. Price data is continuously aggregated, signed, and verified off-chain, refreshing at flexible frequency, up to 10ms for RWAs and in real-time for crypto; Spout gets updates roughly every 500 milliseconds or whenever a price moves meaningfully. That data only gets written on-chain the moment it’s actually needed, right when Spout’s smart contract needs to check a collateral value, whether that’s during a user transaction or a liquidation check.

Why Stork Was the Right Fit

Three things made this a clean match for Spout specifically:

• Coverage of the assets that matter to us. Stork offers the broadest pricing coverage across equities, indices, and other RWAs. That’s the exact surface area Spout markets lives in.
• Speed where it actually matters. Liquidations are a race against price movement. Stork’s flexible frequency and sub-millisecond latency means the price Spout’s contracts see is close to as current as physically possible, which strengthens data freshness and shrinks the window where bad debt or unfair liquidations can happen.
• Verifiability, not trust. Every price update is cryptographically signed by the data source and verified before it’s accepted. Spout doesn’t have to trust Stork’s word, the contract itself rejects anything that isn’t provably fresh and correctly signed.

Here’s the flow in practice:

When a user interacts with Spout, opening a loan, adding collateral, or when the protocol needs to check if a position should be liquidated, the transaction first pulls the latest signed price from Stork, writes it to the on-chain price contract, and then runs Spout’s own logic in the same transaction.

Because both steps happen atomically, in one transaction, there’s no gap where a stale or mismatched price could sneak in. If the price data is invalid, expired, or already superseded by something fresher on-chain, the update simply gets rejected and the transaction fails safely but never silently uses bad data. This is what lets Spout make real-time liquidation decisions on assets that were, until recently, genuinely difficult to price safely on-chain.

What’s Next

This is the piece that makes 0% APR lending against tokenized RWAs sustainable at scale. As Spout expands into more asset classes, Stork’s pull-oracle architecture gives us a pricing layer that scales with us instead of becoming the bottleneck.