How Based Rollups Transform Global Capital Markets

• 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.

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.

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 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.

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 this approach, achieving market-leading liquidity depth across all markets while maintaining gas-free trading and avoiding harmful MEV through FIFO execution.

Phase 2 introduces additional gateways operating under strict SLAs. This creates real redundancy—if one gateway fails, another takes over within seconds. The slashing mechanisms activate, creating economic incentives for reliability. Market makers can start co-locating with multiple gateways, testing failover procedures.

Phase 3 enables permissionless participation. Any entity meeting the technical requirements can become a gateway. Ethereum validators choose their delegates based on performance metrics. Poor performers get slashed and lose delegations. The market determines the optimal number of gateways through natural competition.

Here's what changes when rollups become based: they can interact atomically with Ethereum L1. Imagine taking a flash loan from Aave on Ethereum, using those funds to execute a complex arbitrage on Reya's perpetual markets, and repaying the loan—all within a single Ethereum block. No bridges, no waiting, no additional trust assumptions. The entire operation either succeeds completely or fails completely.

Consider a lending protocol that needs to liquidate positions during market volatility. Today, that requires complex off-chain infrastructure coordinating between L1 lending markets and L2 trading venues. With based rollups, it's a single atomic transaction. The liquidation either completely succeeds or completely fails—no partial states, no race conditions, no toxic MEV extraction.

The technical enabler is shared sequencing. When Ethereum validators sequence both L1 and L2 transactions, they can guarantee ordering across both layers. The gateway model preserves this property while adding the performance layer needed for real-world applications.

The 'lookahead'—a mapping from Ethereum L1 slots to execution node identities—serves as a leader schedule. Execution nodes have exclusive rights to advance the ReyaChain state during their assigned slots. The inbox contract enforces this schedule by only accepting transaction batches from the designated gateway leader for each slot.

Node Architecture

ReyaChain introduces four types of specialized nodes, each optimized for specific functions:

Execution Nodes: These "sticky" nodes are staked third-party entities responsible for issuing execution preconfirmations and sequencing transactions. They communicate via a fast, leader-aware P2P gossip network inspired by Solana's Turbine, and sign block fragments containing single transactions. Unlike typical validators that rotate every block, execution nodes maintain leadership for extended periods (e.g., 1 hour), allowing market makers to co-locate effectively.

Full Nodes: Non-sequencing followers that track the chain tip via the gossip network. As they receive fragments, they optimistically build temporary blocks and provide execution preconfirmations to users. These nodes must re-execute each transaction to maintain current state, requiring hardware comparable to execution nodes. They're essential for bridge operators and market makers needing fast finality.

Light Nodes: These run on commodity hardware by simply applying state-diffs from execution nodes and verifying proofs from the prover network. They don't need to re-execute transactions, making them ideal for powering indexers, block explorers, and archival services.

Prover Nodes: Operating asynchronously, these nodes validate blocks produced by execution nodes, creating ZK proofs that verify all state transitions—including orderbook matching and clearing—were executed correctly. These proofs can be trustlessly verified on Ethereum L1.

Transaction Flow

On Reya, transaction submission changes completely. Instead of sending to a single RPC endpoint and hoping, you connect directly to the gateway network. You receive an execution confirmation in milliseconds, and because of this, your dependent transactions process immediately thereafter.

Nodes maintain three state views: optimistic (based on fragments), pending (awaiting L1 inclusion), and finalized (confirmed on Ethereum). Smart contracts can query different state views depending on their security requirements.

Each transaction on ReyaChain progresses through three distinct confirmation levels: Preconfirmed (sequenced by the execution node with an execution receipt available to the user), Included (the transaction is included in an L2 block), and Finalized (the L2 block containing the transaction has been batched and included in an L1 block).

Because of this, MEV dynamics change. With sub-10ms execution and verifiable ordering, the spam-based MEV extraction plaguing current L2s becomes obsolete. Applications can implement custom MEV recapture mechanisms. Reya's orderbook internalizes arbitrage profits rather than leaking them to external searchers.

As expected, infrastructure requirements escalate. Gateways do need serious hardware, but high-frequency trading firms already operate a similar paradigm. Regular nodes can choose their performance tier. Light nodes just apply state diffs without re-execution. Because of this, the architecture accommodates everyone from HFT firms to hobbyist node operators.

Supporting based rollups requires more than just running nodes. The gateway infrastructure needs robust networking layers. The Arbitrum Orbit components require customization. The migration between phases demands careful orchestration.

At Gelato, we’ve spent years perfecting high-performance rollup infrastructure, how to handle streaming execution and how to customize execution environments. With Reya, we're applying this experience to support ultra-performance based rollup implementations.

Reya targets sub-10ms execution—that's 20x faster than Hyperliquid. Based sequencing architecture demonstrates 300,000 TPS on consumer hardware. The combined system delivers millions of gas per second while maintaining Ethereum's security guarantees.

But raw performance isn't the only metric. Based rollups eliminate the centralization risk premium. They enable atomic L1-L2 composability. They create competitive markets for sequencing services. They align incentives between applications, users, and infrastructure providers.

Why is this crucial? Because everything comes down to capital formation. Reya’s vision is to transform the way capital flows around the world and accelerate GDP growth for everyone.

Based rollups are a reimagining of how blockchains achieve performance without sacrificing decentralization. Reya proves the implementation. Gelato powers the infrastructure. Together, we're building the foundation for internet-native capital markets.

When you can execute trades in <10ms with Ethereum's security, when you can compose atomically across layers, when you can build applications impossible on traditional infrastructure, you don't just improve existing markets. You create entirely new ones.

The revolution isn't coming. It's here. And it's based.

Contact the Gelato team to learn more about how we can support your project's journey.