01 — The Write Lock Problem
An order book is a sorted list. Every new order inserts into that list, every fill removes from it, every cancel modifies it. On a centralized exchange, this is a single-threaded data structure in memory. Fast. On a blockchain, this list is an on-chain account, and Solana enforces a rule: only one transaction can write to a given account per slot. Everything else queues.
At low volume, this is fine. At high volume, the order book account becomes a bottleneck. Market makers submit hundreds of updates per second. If they all target the same account, most transactions fail with write-lock contention. The matching engine might be correct, but it can't process the load.
Ethereum's approach was to give up. Gas costs made frequent order updates economically unviable anyway. A single order placement on Uniswap costs $2-50 in gas depending on congestion. Market makers who need to update quotes every few hundred milliseconds would go bankrupt. The industry pivoted to AMMs, which only require liquidity providers to deposit once and let a mathematical formula handle price discovery. The trade-off: permanent impermanent loss, no limit orders, and MEV extraction baked into the design.
Solana changes the economics. A new block every 400ms. Transaction fees measured in fractions of a cent. But it doesn't change the write-lock constraint. The engineering challenge isn't cost. It's concurrency.
02 — Phoenix: Inline Matching
Serum was Solana's first CLOB. Its architecture separated order submission from order matching. Orders entered a request queue (an on-chain account). A separate program called the "crank" periodically read the queue, matched orders against the book, and wrote the results back. The crank was an off-chain process that someone had to run and pay for. If the crank operator went down, the order book froze. Orders would sit in the queue, unmatched.
Phoenix eliminated this dependency by moving matching inline. When you submit an order, the transaction itself checks the book, finds counterparties, executes fills, and updates balances. One transaction, one atomic operation. No queue, no crank, no external process.
The constraint that makes this hard: Solana caps compute per transaction at 1.4 million compute units (CU). The default allocation is 200K CU. A Phoenix market order that walks through multiple price levels, matching against several resting orders, executing partial fills, and updating maker/taker balances, has to fit inside this budget. The matching engine is written to minimize every unnecessary memory access and computation. Each order node in the book is a fixed-size struct laid out for sequential reads.
Phoenix uses a FIFO (First In, First Out) matching priority. At the same price level, the order that arrived first gets filled first. This is the same model as CME and most traditional exchanges. It rewards speed: if you can get your order on-chain first, you have priority. For market makers, this means the game becomes about transaction landing latency, not just pricing.
03 — Manifest: Zero Fees, Permissionless Markets
Manifest takes a different position in the design space. Where Phoenix prioritizes execution quality and tight spreads for a curated set of markets, Manifest prioritizes accessibility.
| Phoenix | Manifest | |
|---|---|---|
| Market creation cost | ~3 SOL (~$500) | <0.01 SOL (~$1.50) |
| Trading fees | Configurable per market | Zero, permanently |
| Matching priority | FIFO | FIFO |
| Cross-market capital | No (siloed per market) | Yes (Global Orders) |
The fee structure matters. Zero fees means there's no protocol revenue, which means no protocol-level incentive to direct flow to specific markets. This is a deliberate design: the protocol is infrastructure, not a business. Market makers set their own spreads; the protocol takes nothing on top.
04 — Global Orders: Cross-Margin Without Leverage
This is Manifest's most consequential design decision and the part worth understanding in detail.
Standard CLOB capital flow: you deposit USDC into a specific market's vault account. Those funds are locked. You can place orders, cancel orders, but the capital stays in that market until you withdraw. If you market-make on five pairs, you need five separate deposits. Capital is fragmented.
Manifest Global Orders change the settlement model. Your funds stay in your own global account. When you place a Global Order on SOL/USDC, no USDC moves. The order sits on the book as a claim against your global balance. When a taker fills your order, the settlement happens at fill time: your USDC leaves the global account and goes to the taker, the SOL comes to you. This is JIT (Just In Time) settlement.
The capital efficiency gain is multiplicative. With $100K in a global account, you can quote across ten markets simultaneously. Each market sees $100K of available liquidity on your orders. Same capital, 10x the on-book depth. This is the same logic as cross-margin on a centralized exchange, except there's no leverage and no liquidation risk. Every order is fully backed at the moment of placement. The risk is only that multiple orders fill simultaneously.
The order book itself isn't the hard part. The hard part is getting capital efficiency and settlement guarantees right at the same time.
RISK: SIMULTANEOUS FILLS ACROSS MARKETS
You have $100K in your global account. You place $80K buy orders across eight markets. Under normal conditions, only one or two fill at any given time. The math works.
During a market-wide crash, multiple pairs dump simultaneously. Three markets try to fill your orders in the same slot. Manifest processes them first-come-first-served within the block: fill one, deduct $80K, balance is $20K. Fill two fails. Fill three fails. Your orders were on the book, but they were phantom liquidity at the exact moment the market needed them most.
This isn't a bug. It's the design trade-off. Capital efficiency and settlement guarantees are in tension. Market makers who use Global Orders need to model their worst-case simultaneous fill scenario and size accordingly. The naive approach of quoting full balance everywhere creates a false picture of depth.
05 — Aggregator Routing: Who Fills Your Orders
A CLOB can have perfect matching logic and still see zero volume if nobody sends orders to it. This is the aggregator problem: how does trade flow reach the book?
Jupiter is Solana's dominant aggregator, routing through AMMs (Orca, Raydium) and CLOBs (Phoenix, Manifest) simultaneously. When a user swaps SOL for USDC on Jupiter, the router compares prices across all integrated venues, splits the order if needed, and executes against whichever combination gives the best output. The CLOB competes on price with every AMM pool.
0x comes from Ethereum, where they built a Request-for-Quote (RFQ) system. Professional market makers respond to quote requests in real time, competing to fill each order. On Solana, 0x's Swap API aggregates across venues the same way Jupiter does. For market makers, being integrated into both aggregators means more flow. The question is what kind of flow.
Aggregator flow skews retail. A user swapping $500 of SOL on a frontend doesn't watch the order book or time their execution. They accept the best price the aggregator finds. This flow is less toxic than direct DEX trading, where sophisticated actors monitor the book and pick off stale quotes. For market makers, retail aggregator flow is the good flow. You quote a spread, the fill arrives, and the price hasn't moved against you by the time you hedge.
The downside: aggregator integration is binary. If your price is the best, you get the fill. If it's not, you get nothing. There's no loyalty, no relationship, no "you filled me last time so I'll route to you again." Pure price competition, every single order.
06 — Cancel Latency: The Market Maker's Real Problem
For a market maker on a centralized exchange, canceling an order is instantaneous — a message over a WebSocket, acknowledged in microseconds. No fee, no queue, no race. On a Solana CLOB, a cancel is a transaction. It must be submitted, propagated, included in a block, and confirmed. At Solana's baseline, that's 400ms per slot — an eternity when prices are moving.
This asymmetry is the defining constraint of on-chain market making. Posting a quote is a commitment that can't be undone instantly. Every resting order is a liability: a promise to trade at a fixed price, regardless of what the market does before the cancel lands. When a large order hits the mempool and moves price, the window between "price moved" and "cancel confirmed" is where market makers bleed. Sophisticated actors — termed "snipers" — exist specifically to fill stale quotes in that window before the cancel arrives.
Cancel Latency in Practice
~400ms
Solana slot time — baseline cancel window
50–200ms
Practical landing time with priority fee
<1ms
CEX cancel acknowledgment (WebSocket)
~80%
Solana validators running Jito software (2024)
The cancel problem cascades into quoting strategy. A market maker who quotes tight spreads on many price levels is most exposed: more resting orders means more potential fills at stale prices during a move. The rational response is to either quote wider (reducing sniper profitability but also reducing competitiveness) or to invest heavily in cancel infrastructure — colocation with validators, low-latency RPC nodes, priority fee tuning. This is why professional on-chain market making is expensive. The edge is not in the pricing model; it's in the infrastructure that gets cancels on-chain faster than competitors.
06b — Jito: Block Auctions, Bundles, and the Private Mempool
Jito is not a single tool — it is a layered MEV infrastructure that runs across most of Solana's validator set. Understanding it requires separating four distinct components.
Block Engine. Jito operates a block engine — a service that validators (running Jito-patched software) connect to. The block engine receives bundles and individual transactions, simulates them, and assembles the most profitable ordering for the validator. As of 2024, approximately 80% of Solana validators run Jito software, which means most blocks are built through the Jito block engine. A transaction sent only to standard RPC has no path into a Jito block unless it is also forwarded.
Bundles. A bundle is an ordered sequence of up to five transactions submitted atomically. All five execute in sequence, or none do. The canonical MM use case: [cancel stale bid] → [cancel stale ask] → [place new bid] → [place new ask]. No bot can insert a transaction between the cancel and the requote because the entire sequence lands as one unit. Bundles can also include a fill: [fill incoming order] → [hedge on another venue], ensuring the hedge lands in the same slot as the fill.
Tips. Every bundle includes a tip — a direct SOL payment to the validator (via a Jito tip account). This is separate from the base transaction fee. The tip is the auction price for block ordering priority. Median tips are a fraction of a cent during quiet markets. During high-volatility events (token launches, major liquidations), tips spike: competitive bundles have been observed paying 1–5 SOL (~$150–750 at $150/SOL) for a single bundle to ensure first-in-block execution. The tip market is a second-price auction dynamic — you need to outbid the next competitor, not maximize your payment.
ShredStream. Shreds are the raw data fragments Solana validators broadcast as they build blocks — before the block is complete or confirmed. Jito's ShredStream service lets subscribers receive shreds directly from validators in real time, giving them the earliest possible view of what is landing on-chain. For market makers, this is the cancel signal: when ShredStream shows a large order approaching their resting quotes, they have ~50–100ms to submit a cancel bundle before the order lands. Without ShredStream, you are reacting to confirmed state — already too late.
The difference between regular trading and Jito-mediated trading is architectural. A standard transaction goes to a public RPC node, propagates through gossip, and competes for inclusion based on base fee alone. It is visible to anyone watching the mempool. A Jito bundle goes through a private channel directly to the block engine, is simulated off-chain, and is only revealed to the network when it lands in a confirmed block. No front-running window. No public visibility. The bundle either executes as written or is dropped silently.
| Standard tx | Jito bundle | |
|---|---|---|
| Visibility before landing | Public mempool — anyone can see | Private — only block engine sees |
| Atomicity | Single tx — can be reordered around | Up to 5 txs — all land in order or none do |
| Priority mechanism | Priority fee (lamports/CU) | Tip (flat SOL) + priority fee |
| Failure mode | Tx included but reverts — fee still paid | Bundle dropped if simulation fails — no fee |
| Front-run risk | High — visible in gossip | None — private until confirmed |
| Typical cost | ~0.000005 SOL base fee | 0.0001–5 SOL tip (market-rate dependent) |
The spread you see on a Solana CLOB encodes all of this. It is not the market maker's profit margin. It is the sum of: expected adverse selection from fills before cancels land, Jito tip cost amortized across expected fill volume, infrastructure costs (ShredStream, colocation, low-latency RPC), and the actual profit target — likely the smallest component of the four during volatile periods. A 5 bps spread on a liquid pair on Phoenix may represent 1 bps of actual profit and 4 bps of operational overhead that does not exist on a centralized exchange.
07 — The Mechanism Landscape: AMM, RFQ, Intent, CLOB
A CLOB is one answer to the price discovery problem. Three others coexist on-chain, each making different trade-offs.
| Mechanism | Examples | Price discovery | Who takes risk |
|---|---|---|---|
| AMM (x·y=k) | Uniswap, Orca, Raydium | Formula — price moves with each swap | LPs (impermanent loss) |
| RFQ | 0x, Hashflow | Market makers quote on request, off-chain | Market maker |
| Intent-based | UniswapX, Across, CoW Protocol | Solver competition — best fill wins | Solver (short window) |
| On-chain CLOB | Phoenix, Manifest | Transparent book — FIFO matching | Market maker |
AMMs trade execution simplicity for capital efficiency. Liquidity providers deposit once; the formula handles everything. But the formula is predictable — every large order is sandwichable, LPs absorb adverse selection by design, and there are no limit orders. AMMs work for passive liquidity. They fail for tight spreads.
RFQ flips the model: no public book, no formula. A user requests a quote, market makers compete to respond, the best bid wins. Zero MEV exposure — the price is agreed before the tx broadcasts. But it requires market makers to be online, responsive, and willing to quote every token. Long-tail assets get no coverage.
Intent-based routing (UniswapX, CoW Protocol) abstracts the venue entirely. The user signs an intent: "give me at least X for Y." Solvers — bots competing to fill — find the optimal path across AMMs, CLOBs, private inventory. The user gets best execution. The solver captures the surplus. MEV is redirected from extractors to solvers and partially returned to users. The risk: solver centralization. A handful of solvers handle the majority of flow.
On-chain CLOBs are the only model where price is transparent before the trade and limit orders are native. Every resting order is a public commitment. Market makers compete on spread. Takers see the full depth. The cost: write-lock contention, compute constraints, MEV exposure on every cancel-requote cycle.
08 — Derivative Markets: Hyperliquid, dYdX, GMX
Spot CLOBs solve one problem: matching buyers and sellers of existing assets. Derivatives add a second layer — synthetic exposure, leverage, funding rates, liquidation engines, oracle pricing. Each solved it differently.
GMX / GLP model. No order book. Liquidity providers deposit a basket of assets into a pool (GLP). Traders open long or short positions against the pool as counterparty. Prices come from Chainlink oracles — no book depth, no spread. The pool earns fees when traders lose; it bleeds when traders win. Capital efficient for LPs when traders are net unprofitable. Structurally fragile when they are not.
dYdX v4 (Cosmos app-chain). Off-chain order book, on-chain settlement. Validators run the matching engine off-chain in their local state; only fills hit the Cosmos chain. Sub-second latency. The trade-off: validators must be trusted to match orders honestly. Censorship is possible at the validator level. dYdX chose performance over full on-chain transparency.
Hyperliquid. Purpose-built L1 (HyperBFT consensus, Tendermint-derived). The entire matching engine runs on-chain on their own chain — no shared congestion with other applications. Order acknowledgment under 1ms. The validator set is small (~20 initially), which is the central trust assumption. HIP-1 defines the native token standard for deploying assets directly on Hyperliquid's L1. HIP-2 provides automatic liquidity seeding for new HIP-1 spot markets — the protocol bootstraps initial order book depth at the auction clearing price, preventing empty-book cold-start failure. The HLP (Hyperliquidity Provider) vault acts as the native market maker, absorbing flow the external maker ecosystem doesn't cover.
The structural difference between Phoenix and Hyperliquid comes down to one question: who controls the sequencer? On Solana, Solana's decentralized validator set sequences your transactions. On Hyperliquid, Hyperliquid's validator set does. You get 400x the speed in exchange for trusting a smaller committee. Whether that trade-off is acceptable depends on what you're trading and how much you're putting at risk.
| Phoenix | Hyperliquid | dYdX v4 | GMX | |
|---|---|---|---|---|
| Chain | Solana | Own L1 (HyperBFT) | Own L1 (Cosmos) | Arbitrum / Avalanche |
| Matching | On-chain, inline | On-chain, own chain | Off-chain (validators) | Oracle — no book |
| Latency | ~400ms | <1ms ack, ~2s finality | ~500ms | Oracle refresh rate |
| Validator trust | 1,800+ Solana validators | ~20 (semi-centralised) | dYdX validator set | Chainlink oracle network |
| Derivatives | Spot only | Perps + spot | Perps | Perps (synthetic) |
| MEV exposure | High (Solana mempool) | Low (own mempool) | Low (off-chain matching) | Oracle latency arb |
09 — Scalability: Where Each Model Breaks
Every trading architecture has a ceiling. The question is where it cracks under load — and whether that ceiling is infrastructure, economics, or trust.
AMMs scale until MEV does. Each swap is O(1) — no book to traverse, no matching logic. Solana AMMs handle millions of swaps. But as TVL grows, so does the size of sandwichable trades. MEV extraction scales with liquidity. Concentrated liquidity (Orca Whirlpools) improves capital efficiency but narrows the range that earns fees, concentrating IL risk. The model doesn't break; it just becomes more extractive at scale.
On-chain CLOBs (Solana) hit write-lock ceilings. Phoenix and Manifest are bottlenecked by Solana's account write-lock rule: one writer per account per slot. At low volume, fine. At high volume, the order book account becomes a serial resource. Multiple market makers targeting the same account in the same slot means most of them fail. The practical throughput for a single Phoenix market under contested conditions is far below Solana's theoretical 65,000 TPS. Compute limits per transaction add a second ceiling: deep order walks that touch many price levels hit the 1.4M CU cap.
Own-chain CLOBs (Hyperliquid, dYdX) remove the shared congestion problem. No other applications compete for the same write locks. The matching engine has the full validator throughput. Hyperliquid processes 100,000+ orders per second in their own benchmarks. But the ceiling shifts: it's now the validator set size and the trust model. Fewer validators means faster BFT consensus but a smaller security set. A cartel of validators could front-run orders or censor cancels. This is a governance and decentralization problem, not an infrastructure one — and it gets harder to solve as the platform grows more valuable.
RFQ scales with market maker capital, not infrastructure. There's no order book to contend for, no write-lock bottleneck. Throughput is limited by how many quote requests market makers can respond to per second. For liquid pairs, this is effectively unlimited. For long-tail assets, market makers simply don't show up. The model scales horizontally — add more market makers — but fails vertically: there's no native price discovery, so takers depend entirely on the market maker being honest and competitive.
Intent-based routing scales with solver infrastructure. Solvers run off-chain, spin up as needed, and compete on every order independently. The on-chain footprint is a single settlement tx per fill. This is the most scalable model from a pure throughput perspective. The risk is solver centralization: if three solvers handle 90% of flow, the "competitive solver auction" becomes oligopolistic pricing in practice. The user sees best execution today; whether that holds as solver market structure consolidates is the open question.
No model wins cleanly. AMMs win on simplicity and passive liquidity. RFQ wins on MEV protection for liquid pairs. Intent-based wins on user execution quality. On-chain CLOBs win on transparency and limit order support. Own-chain CLOBs win on raw throughput — at the cost of the decentralization properties that make on-chain trading meaningful in the first place.
10 — Where This Goes
The technical stack for on-chain CLOBs on Solana is production-ready. Phoenix and Manifest both work. Orders match, settlements clear, the matching engines survive real load. The solved problem is the matching engine.
The unsolved problems are all economic. Capital efficiency vs. settlement guarantees (Global Orders). Spread compression vs. MEV exposure (Jito costs). Aggregator integration vs. adverse selection (flow quality). These are the same problems centralized exchanges have spent decades optimizing. The difference is that on-chain, every parameter is visible, every trade-off is measurable, and every design decision plays out in public.
The interesting question isn't whether on-chain order books can work. They can. The interesting question is whether the economic equilibrium they converge to is better than AMMs for the median user — and whether own-chain CLOBs like Hyperliquid can maintain their speed advantage without sacrificing the decentralization that makes the whole model trustworthy. That answer depends on how many sophisticated market makers show up, how much capital they deploy, how much MEV they're willing to absorb, and whether the validator sets running these systems stay honest as the stakes grow. The matching engine was the prerequisite. Now the game is about who plays it, on which chain, under which rules.
The matching engine was the prerequisite.
Capital flow, aggregator routing, MEV economics. Three separate games, all running simultaneously, all deciding whether the book survives.
— AILEENA MACHINA / 2026
References
- Phoenix Protocol — On-Chain CLOB Architecture
- Manifest — Permissionless CLOB & Global Orders
- Jito Labs — Block Engine & Bundle Documentation
- Jito ShredStream — Real-Time Validator Data
- Jito MEV Dashboard — On-Chain Tip & Bundle Data
- Jupiter Aggregator — Routing Across Solana Venues
- Solana Transaction Compute Budget
- Solana Validator Economics & Jito Adoption (Helius)
- Hyperliquid — HIP-1 & HIP-2 Specification
- Hyperliquid — HLP Vault & Liquidity Design
- dYdX v4 — Cosmos App-Chain Architecture
- GMX — GLP Pool and Oracle Pricing Model
- CoW Protocol — Intent-Based Settlement
- UniswapX — Solver Auction Design
- Flashbots — MEV Research & Bundle Auction Theory