LeverUp now runs on Pyth Pro — the institutional tier of the Pyth oracle network. Measured across 370 parallel samples on Monad mainnet, price staleness dropped from 1.676 seconds (Pyth Core) to 0.086 seconds (Pyth Pro). That's a 19.5× improvement in feed freshness.
On a perp platform where every trade settles directly against the oracle price, that gap is the gap between trading the market a second ago and trading the market right now.
Why Oracle Quality Is the Whole Game
On LeverUp, the oracle is the price. Every open, every close, every mark-to-market, every liquidation trigger reads directly from the feed. There's no separate matching layer that can absorb or smooth out a late price.
Whatever the oracle says at the moment your trade settles is what you transact against.
If that feed is 1.6 seconds behind the market, every trade in that window settles against a snapshot of reality that's already moved. On a calm market, that's annoying. On a volatile move — exactly when most liquidations happen — it means your position is marked against a price that didn't exist at the time it was used.
This lag is what traders loosely call "slippage." It usually hides inside the fill. The execution was worse than expected, the liquidation hit at a price that didn't quite make sense, the PnL drifted in a direction that was hard to explain. On high leverage, oracle staleness is often the largest hidden cost most traders never measure.
Pyth Core vs. Pyth Pro: The Two Tiers
Pyth offers two service levels.
Pyth Core is the original public price feed — widely used across DeFi, sufficient for most applications. It publishes frequently enough for the majority of on-chain use cases.
Pyth Pro is the institutional tier: lower latency, higher publish frequency, tighter timing guarantees from the same first-party publishers. Same underlying market, same source network, different service grade.
For a perp venue operating at high leverage, the gap between these two tiers is the difference between adequate and accurate.
The Data
We ran 370 parallel samples of Pyth Pro and Pyth Core on BTC/USD and ETH/USD, side by side on Monad mainnet. Same pairs, same window, same chain. The only variable was the oracle tier.
| Metric | Pyth Core | Pyth Pro |
|---|---|---|
| Average staleness | 1.676 seconds | 0.086 seconds |
| Improvement | — | 19.5× |
| % samples with zero staleness | — | 91.4% |
91.4% of Pyth Pro samples had zero staleness. The price the chain read was the price the market was making, at that moment. Core was late by a second or two on essentially every sample.
Consistency Across the Window
One good average doesn't mean much if it breaks down at the edges. Oracles tend to fail when they're needed most — volatile moves, sudden spikes, heavy publisher load. We split the sampling window into 20 segments and checked whether Pro's lead held up across all of them.
It held. Pro stayed flat near zero across all 20 segments. Core oscillated between 1.5 and 2 seconds throughout and never closed the gap.
This is the important finding. Liquidations don't happen in calm windows. They happen when the market is moving fast — exactly when a 2-second lag in price data causes the most damage.
Pro Isn't Showing a Different Price
A reasonable concern: if Pro shows different numbers than Core, is it more accurate or just biased in one direction?
We checked. The average absolute divergence between Pro and Core prices is 1.35 basis points. 59.2% of samples are within 1 bps of each other. And the directional split is essentially 50/50 — Pro prints higher 50.8% of the time, lower 47.0% of the time.
Pro isn't systematically higher or lower. It's tracking the same market Core tracks, sampled with tighter timing. The improvement comes from less lag, not different prices.
What Changes for Traders
Opens and closes execute closer to the live market. Because every trade on LeverUp settles directly against the oracle price, a 19× improvement in feed freshness flows straight through to your fill. There's no middle layer absorbing the benefit.
Liquidations reference the real market. The "I got liquidated on a wick that wasn't really there" problem comes from stale feeds triggering against prices the market never actually printed at that moment. With Pro, the trigger reads current state.
Tighter effective execution. On orderbook venues, the bid-ask spread is where market makers price in the risk of operating on imperfect data. LeverUp's design works differently: trades settle directly against the oracle, with no spread between the price you see and the price you get. When oracle quality improves, the benefit doesn't get absorbed by a spread — it flows straight through to your fill.
A large part of what traders experience as slippage on oracle-settled platforms is simply oracle lag. Compressing staleness by 19× removes most of that drag.
Why Monad Makes This Work End-to-End
A fast oracle feeding a slow chain is wasted capacity.
If Pyth Pro publishes a new price every 100ms but block confirmation takes 2 seconds, the freshness is lost before it reaches settlement. You'd be paying for Pro-grade data and getting Core-grade execution.
Monad's throughput and block times are fast enough to consume Pro's feeds at something close to their native cadence. The chain keeps up with the oracle. That's why the end-to-end trading experience actually reflects what Pro is doing, rather than being diluted by execution latency downstream.
Pyth Pro supplies the data. Monad supplies the execution. LeverUp is the venue that runs on both.
The Methodology
370 parallel samples across BTC/USD and ETH/USD. 17-minute live window on Monad mainnet. Staleness measured as time between price publish and on-chain observation. Divergence measured in basis points against Pyth Core. Monitoring is ongoing.
Trade on LeverUp: app.leverup.xyz
