Raiku: The Deterministic Execution Layer for Perp DEXs

Perpetual futures decentralized exchanges (perp DEXs) have emerged as a major force in crypto markets this year. In September 2025, monthly trading volumes surpassed $1.4 trillion, setting a new all-time high.

Venture funds that once chased memecoins and prediction markets are now pivoting toward perps, drawn by rising volumes, clear fee revenue, and a more mature on-chain derivatives stack. Haun Ventures recently backed Lighter, while Robot Ventures co-led Bulk’s $8 million seed round, underscoring the intensity of deal flow. As Anirudh Pai, partner at Robot Ventures, put it, “the pot of gold at the end of the perp DEX rainbow is larger than most VCs realized.”

Why CLOBs are Central to Modern Markets

Despite this momentum, on-chain perp DEXs still process only around 9% of the volume handled by centralized exchanges (CEX). That gap exists because global markets run on Central Limit Order Books (CLOBs), the structure that underpins modern trading, and leading on-chain perps such as dYdX, Hyperliquid, Vertex, Drift, Aevo, and more are now adopting the same model to close this execution gap.

A CLOB is a single shared order book where all buy and sell orders are collected, ranked, and matched according to two simple rules:

1, Better price goes first (a higher bid or lower ask takes priority), and

2. If prices are the same, earlier orders go first.

This is called price–time priority. CLOB system is the backbone of every major exchange, from Nasdaq to Binance,  because it delivers three advantages no other model can match at scale: precise price discovery, predictable execution, and deep liquidity driven by competitive market makers.

Traditional exchanges have had decades to perfect this infrastructure. Blockchains are now catching up. High-performance chains like Solana have made on-chain CLOBs technically possible, with fast slot times and high throughput, but technical possibility is not the same as operational certainty.

Perps Add a Timing Layer that Blockchains Struggle With

Perps adds a continuous, high-frequency timing layer that’s hard to pull off on-chain. Perp DEXs depend on CLOBs, and CLOBs demand absolute precision.

- Funding payments occur at fixed intervals (e.g., every 8 hours). If a perpetual trades above spot, longs pay shorts; if below, shorts pay longs. These must credit exactly on schedule.

- Margin requirements define minimum collateral ratios. If collateral falls below the maintenance threshold, liquidation is triggered automatically.

- Liquidation engines continuously monitor positions and force-close under-collateralized accounts to prevent bad debt.

Each of these depends on transactions landing at the right time and in the correct order. A funding update that arrives even a couple of seconds late can trigger false liquidations, while a margin calculation based on stale oracle data can either miss a risky position or liquidate a healthy one, both of which can snowball into bad debt and exponential losses.

High-Frequency Compounding

These execution uncertainties compound exponentially as trading frequency increases. A retail trader opening one position per day can maintain conservative margin buffers and manually monitor positions. A market maker running automated strategies might manage 50 simultaneous positions, each adjusted 20+ times per sec based on changing market conditions.

For that market maker, execution determinism is existential. Consider their workflow:

1. Oracle updates price

2. Strategy recalculates optimal hedge ratios

3. Orders cancel previous quotes

4. New orders post updated quotes

5. Fills execute

6. Risk system confirms position within limits

7. Funding payment processes

This sequence happens continuously, multiple times per second during active trading. If step 3 (cancellations) arrives after step 5 (fills), the market maker gets executed on stale quotes they meant to cancel, a classic "adverse selection" scenario that guarantees losses. If step 1 (oracle update) lags behind step 6 (risk check), the system calculates risk on stale prices, either blocking legitimate trades or allowing dangerous ones.

This is why professional market makers, who provide 80%+ of liquidity in traditional markets, haven't fully committed capital to on-chain perpetual swaps.

Deterministic Execution for Institutional-Grade Perps

Raiku introduces a fundamentally new way to interact with Solana. Instead of submitting a transaction and hoping it lands, you receive a cryptographic guarantee before the slot even arrives that your transaction will execute exactly when and where you specify.

Raiku sits between applications and validators, managing blockspace like a resource that can be scheduled, reserved, and guaranteed.

Two Ways to Get Guaranteed Execution

Raiku offers two transaction types, each designed for different scenarios perpetual DEXs face:

Ahead-of-Time (AOT): Schedule With Precision

AOT is designed for operations that must happen at fixed times, down to the exact slot. Think of funding payments every eight hours, oracle pushes at fixed intervals, or batched margin checks before a market event.

Instead of relying on probabilistic inclusion, protocols tell Raiku: “Execute this transaction in slot 245,831” (let's say this is roughly 15 seconds in the future). Raiku books that space in advance, locks the ordering, and issues a pre-confirmation, a signed guarantee that the transaction will execute in that slot, with the specified priority.

This deterministic scheduling allows protocols to sequence dependent operations with certainty:

- Funding payments always credit exactly on time, preventing manipulation across exchange venues.

- Oracle updates arrive on a fixed cadence, ensuring liquidation engines always work with fresh data.

- Margin checks can be precisely offset relative to oracle pushes, e.g. oracle in slot N, margin check in N+1, guaranteeing logical ordering every time.

With AOT, protocols can build slot-level operational pipelines — oracle → margin → funding, without racing the network or overpaying in priority fees to “hope” for timing alignment. It converts Solana’s fast but probabilistic base layer into a predictable, clock-like infrastructure for scheduled tasks.

Just-in-Time (JIT): Execute Instantly When Needed

Markets don’t always give 15 seconds of notice. When positions approach liquidation thresholds, quotes need to be canceled, or hedges must adjust within a single block, protocols require immediate, guaranteed inclusion in the next slot.

JIT is built for these urgent scenarios. When a transaction is submitted via JIT, Raiku reserves top-of-block capacity in the very next leader slot. The transaction bypasses Solana’s public QUIC networking layer — a frequent source of drops and throttling, and is injected directly into the validator’s block production pipeline.

This ensures critical operations land within the next 400 ms, not “whenever the network clears.” For perpetual DEXs, this is decisive:

- Liquidations fire instantly, containing losses before bad debt builds up.

- Quote cancellations reliably land before new quotes, protecting market makers from being executed on stale orders.

- Hedging trades execute immediately as positions drift, instead of being stuck behind spam or fee spikes.

JIT transactions are prioritized through a first-price auction: the highest bidder gets top-of-block space, with a floor set just above Solana’s priority fee to keep markets fair and efficient.

Architecture That Makes Guarantees Real

Understanding how Raiku actually enforces these guarantees clarifies why this solves problems current infrastructure can't.

The Ackermann Node: Coordination Layer

The Ackermann Node sits between applications and Solana validators as the coordination brain. When a perpetual DEX needs to execute a liquidation:

1. Node receives the intent: "Liquidate position X in the next slot"

2. Determines the slot: JIT = next available slot, AOT = specific future slot

3. Runs the auction (for JIT) or validates the booking (for AOT)

4. Issues a pre-confirmation: Cryptographic proof stating "this transaction will execute in slot N"

5. Routes to the validator who will lead that slot

The pre-confirmation happens before the slot arrives. The perpetual DEX knows with certainty the liquidation is scheduled and will execute.

The Node monitors validator health continuously. If the scheduled validator goes offline, it reroutes the transaction to another validator without breaking the guarantee. The transaction still lands in the correct slot, just through a different validator.

The Ackermann Sidecar: Enforcement Layer

The Sidecar runs directly alongside Solana validators, enforcing the guarantees the Node makes. Execution flow:

1. Node assigns transaction to slot N, led by validator V

2. Sidecar on validator V receives and holds the transaction locally

3. When slot N arrives, Sidecar injects the transaction directly into the validator's block production pipeline

This injection bypasses Solana's QUIC networking layer, where most transaction drops happen during congestion. The transaction isn't competing with thousands of others flooding in. It's already inside the validator, waiting for the exact moment to execute.

The Sidecar enforces strict ordering rules:

- JIT transactions go to the top of the block (highest bidder first)

- AOT transactions execute at their scheduled position

- Bandwidth follows allocation rules that prevent gaming

Validators can't cheat without getting caught. The Sidecar creates auditable records of every scheduled transaction and whether it executed as promised. Validators who drop scheduled transactions face economic penalties and lose access to Raiku's fee revenue streams.

Extensions: Purpose-Built Execution Environments

For perpetual DEXs that need extremely high performance, Raiku enables a new architectural pattern called Extensions.An Extension is a specialized execution environment that runs alongside Solana, handles high-frequency trading locally, and then settles results back to Solana. It combines the speed of a custom engine with Solana’s security and Raiku’s deterministic scheduling.

Solana’s base layer is fast, but not fast enough for the microsecond-level matching engines used by top institutional traders — like Nasdaq’s X-Stream INET, which averages <40 µs round-trip latency, or CME Globex, which operates in the 3–10 µs range in optimized setups. Extensions solve this by moving the matching logic and order book management off-chain, into a dedicated environment optimized for a single purpose, like perps trading.

Within an Extension, trades are matched at microsecond latency and the entire state (orders, positions, collateral) lives in optimized local databases. Instead of writing every tiny update to Solana, the Extension periodically generates a cryptographic proof of all changes (e.g., once every second) and submits this proof to Solana for final settlement.

Raiku’s scheduling guarantees that this proof is included exactly when expected, bridging the Extension and Solana with deterministic timing. In short:

- Extension = speed (local matching, microsecond updates)

- Raiku = guaranteed settlement bridge

- Solana = security and finality layer

Global Account Module

To keep the Extension and Solana in sync, Raiku uses a Global Account Module, a shared account structure recognized by both environments. This ensures that collateral and positions are never stuck in limbo. A trade processed locally only becomes final if the proof lands on Solana, guaranteeing atomic state updates across both layers.

Proof Streaming

Some settlement proofs are large, often several megabytes. Raiku’s Proof Streaming splits these into smaller chunks, reserves a sequence of slots using AOT, and streams them to Solana in order. If any chunk fails, the entire proof fails, preserving atomicity.

This setup lets DEXs handle tens of thousands of trades per second with institutional-grade speed, while maintaining Solana’s security and verifiability.

Conclusion

The $4.7 trillion in perpetual DEX volume this year proves demand exists—the question was never if markets would move on-chain, but when infrastructure could match the reliability traders expect. Hyperliquid showed that when UX reaches CEX parity—instant confirmations, no failed transactions, familiar interfaces—users commit serious capital.

However, building custom L1s for every use case fragments liquidity and limits composability.

Raiku solves this by bringing deterministic execution to Solana, combining the highest-performance general-purpose blockchain with cryptographic guarantees for transaction inclusion.

Perpetual DEXs on Solana and Raiku can finally deliver what neither isolated L1s nor centralized exchanges offer: CEX-like responsiveness, institutional-grade reliability, and native DeFi composability.

‍