How Based Rollups Transform Global Capital Markets

TL;DR

• Reya is building the world's first trading-specific based rollup, achieving sub-10ms execution (20x faster than Hyperliquid) while maintaining Ethereum's security guarantees.

• Based sequencing eliminates the speed vs. decentralization tradeoff by separating execution (fast gateways) from consensus (Ethereum validators).

• Enables synchronous L1 composability — atomic transactions across Ethereum and Reya.

• Architecture features specialized nodes: TEE-secured Execution Nodes, Full Nodes for traders, Light Nodes for indexers, and ZK Prover Nodes for verification.

• Three-phase roadmap: Phase 1 (current) single gateway; Phase 2 introduces multiple gateways with $REYA staking; Phase 3 enables fully permissionless participation.

• Gelato serves as official design and infrastructure partner, providing the networking layers, Arbitrum Orbit customization, and orchestration needed for based rollups.

When Reya founder Simon Jones describes capital markets as a $270 trillion opportunity, he's not pitching another DEX improvement. He's describing what unlocks when you restructure how global finance operates. In fact, some sources cite global capital markets as exceeding $1 quadrillion.

Reya is currently in Phase 1 of its ambitious roadmap, having launched a proof of concept on a forked Arbitrum Orbit that's already processing 200,000 trades weekly across 60 markets with 100ms block times.

Phase 2 will embed advanced financial logic directly into ReyaChain's nodes while building connecting rails to other trading venues. The ultimate vision—Phase 3—integrates TradFi products while enabling projects to leverage Reya's embedded liquidity and capital efficiency to create entirely new categories of onchain innovation.

Turning Reya's three pillars—performance, liquidity, and capital efficiency—into this transformational product requires entirely new architecture. That's why Reya chose to work with Gelato as its official design and infrastructure partner to build the world's first trading-specific based rollup.

The Challenge with Decentralized Infrastructure

Here's what actually happens when you try to build a high-performance DEX today: You hit a wall at 200 milliseconds.

Many DEXs claim to offer orderbooks, but they're centralized—running off-chain servers that merely post results onchain. They achieved speed by completely sacrificing decentralization. Hyperliquid took the opposite approach, bringing everything onchain with their own L1, but even with hand-picked validators, they're stuck at 200 millisecond execution times. Traditional finance, meanwhile, operates in microseconds.

The math is unforgiving. State root computation—essential for blockchain security—takes upward of 50 milliseconds and grows worse as state increases. If you want 10ms blocks but state roots alone take 50ms, you've already failed. Add network propagation, disk I/O, and consensus overhead, and you understand why every fast blockchain today sacrifices decentralization.

How to Crack the Code

The breakthrough comes by eliminating consensus from the execution path entirely. By separating what needs to be fast (execution) from what needs to be decentralized (consensus), based sequencing unlocks both properties.

Specialized execution nodes (gateways) handle transaction processing. These aren't your typical validators—they're high-performance machines optimized for speed. But instead of trusting them blindly, Ethereum validators supervise their operation through delegation and slashing mechanisms.

The magic happens through fragments, which are transaction batches that stream from gateways. Unlike traditional blocks that must be complete before propagation, fragments flow immediately. Nodes receive these fragments, execute them optimistically, and provide users with confirmations in milliseconds. The expensive operations—state root computation, consensus, final ordering—happen asynchronously on Ethereum L1.

Reya's Architecture

Reya's architecture insists on three pillars:

Performance: Sub-10ms execution through gateway-based sequencing and fragment streaming. The dual execution environment runs ReyaNative (Rust-based components for the orderbook and liquidations) alongside ReyaEVM (Arbitrum Orbit for smart contracts), optimizing each component without compromise.

The execution nodes run block-building operations inside Trusted Execution Environments (TEEs), allowing clients to verify compliance with FIFO ordering policy while mitigating discretionary block ordering rules. The entire orderbook is embedded into the execution node, making both matching and clearing fully onchain and verifiable via a ZK prover network—contrasting with most existing approaches that implement matching offchain and only propagate executions onchain.

Liquidity: By embedding the orderbook and matching engine into the execution layer, Reya enables liquidity that's both deep and immediately accessible. Market makers can co-locate with gateways for microsecond-level access, while the based architecture ensures this liquidity remains available even if individual gateways fail.

Capital Efficiency: Preconfirmations transform how capital moves in decentralized infrastructure. When a trader submits an order, the gateway fully executes the transaction, checks margin requirements, determines the execution price, and returns a cryptographically signed confirmation—all in under 10 milliseconds. This isn't just an inclusion preconfirmation (promising your transaction will be included) but an execution preconfirmation (guaranteeing the exact outcome). This way, traders know their exact fill price and can immediately act on that information. Preconfirmations enable capital to move at the speed of traditional finance.

The Three Phase Roadmap

You can't flip a switch from centralized to ultra-high performance decentralized overnight.

Phase 1 deploys the fragment propagation infrastructure with a single gateway. While this might sound like today's centralized sequencer, the underlying architecture is different. The gossip network enables nodes to receive and propagate fragments peer-to-peer. The fragment format allows for streaming execution where transactions are batched and sent continuously rather than waiting for complete blocks. The delegation mechanics are built in from day one, ready for activation in later phases. Reya starts here, proving the architecture works at scale before adding complexity.

Reya has already validated thi