Introducing ReyaChain: Enabling "Internet Capital Markets"

This guest post is by Simon Jones, the founder of Reya

TLDR

• ReyaChain will be the world’s first trading-specific based rollup on Ethereum.
  

• This novel design delivers a ‘holy grail’ for the industry - for the first time creating a trading environment that’s as fast as TradFi, but as decentralized as Ethereum.
  

• Long term, this will enable ‘Internet Capital Markets’; a vision for the future where the $1,000tn Capital Markets today move into the internet age, becoming globally accessible, transparent and composable via trustless blockchain-based financial rails.
  

• Whilst this previous post outlined the products and distribution tactics to enable our Internet Capital Markets vision, this post specifically outlines the architecture and technical details of ReyaChain.
  

• The based-rollup design of ReyaChain has a set of novel architectural decisions:

  • Node Specialization: we create a number of different node types, to maximize performance of trading execution, whilst preserving decentralization by keeping barriers to entry low for participants to join the network. In particular we introduce ‘Execution Nodes’, highly performant nodes running ReyaNative and ReyaEVM. 

  • Based Sequencing via Delegation: the Reya ‘Execution Nodes’ operate as Ethereum L1 Gateways. In doing so, Ethereum L1 validators delegate block production to these nodes, meaning the Reya Execution Nodes can give millisecond level pre-confirmations that trades have been executed and will be included in the L1 block. This design is comparable to builder-proposer-seperation, and is inspired by this article from Gattaca. 

  • Dual Execution Environments: ReyaChain will run two execution environments:

    • ReyaNative: native rust code containing all the components required for trading. The orderbook will be fully onchain and verifiable via a ZK prover network. 

    • ReyaEVM: a customized version of Arbitrum Orbit, allowing smart contract deployments by teams building on ReyaChain. This will talk to ReyaNative via read precompiles and a system write contract, unlocking new product opportunities for builders.

  • Hybrid DA: orders and executions have different data structure requirements and different DA requirements. As a result we treat them differently and push the highly DA intensive order data to specialized DA whilst the account data goes to Ethereum L1.
    

• Rollout will be gradual. For those familiar with Reya today, we already have ReyaEVM running, meaning the next step is to launch the first components of the ReyaNative; specifically the orderbook. A full rollout plan is outlined at the end of this article.

The Opportunity 

Bitcoin proved the power of decentralizing the monetary base — a breakthrough worth trillions. But internet-native capital markets are an even bigger idea, with the potential to reshape a $1,000 trillion global system.

So far, crypto has fallen short. Every architecture has been forced into a compromise: performance at the cost of decentralization, or decentralization at the cost of performance. 

That tradeoff has restricted our ability to deliver on what is arguably one of the most important innovations of our lifetime. Sure, to begin with, anyone building an onchain trading environment is building ‘just a DEX’. But if we can credibly solve the decentralization vs. performance challenge, we actually have a shot at transforming global capital markets.

It’s this vision that we want to deliver on with ReyaChain. Yes, our feet are firmly on the ground — the product is a DEX to begin with — but longterm it unlocks much more. This previous post explained our product and distribution strategy to unify finance onchain. This post outlines the technical details of ReyaChain and how we will enable our Internet Capital Market vision.

Introducing ReyaChain

ReyaChain is the world’s first trading-specific based rollup on Ethereum. This delivers TradFi level trading speed (i.e. millisecond-level execution) whilst being as decentralized as Ethereum.

The architecture allows for this through 4 main concepts, each of which we go into detail in below:

• Node specialization

• Based sequencing via delegation

• Dual execution environments

• Hybrid DA for orders and execution

First, let’s understand the overall architecture. Then we’ll go into each core component in detail.

Node Specialization: introducing Network Participants

Conventional blockchain architectures require every node in the network to re-execute all transactions and reach consensus, which introduces fundamental scalability and decentralization challenges. As transaction throughput and performance requirements increase, so too must the computational capacity of every node — ultimately raising the barrier to participation and reducing the number of feasible nodes that can support network operations. Even with higher hardware requirements, there’s an inherent latency that will exist throughout any chain that bundles consensus and execution given the requirement for execution to take place across multiple nodes.

In order to address the above-mentioned limitation, ReyaChain supports heterogeneous node types with tailored hardware requirements and decoupled execution and consensus. The diagram below illustrates the key network actors within ReyaChain's architecture.

‘Sticky’ Execution Node

A ReyaChain Execution Node is a staked third-party entity responsible for issuing execution preconfirmations and sequencing based rollup transactions. It monitors and stores incoming transactions in a first-in-first-out (FIFO) queue. Block-building operations are executed inside a Trusted Execution Environment (TEE). This allows clients to verify compliance with FIFO ordering policy thus mitigating discretionary block ordering rules.

An Execution Node communicates via a fast, leader-aware peer-to-peer (p2p) gossip network, inspired by Solana Turbine block propagation. Clients can send transactions to the currently active Execution Node or to any full node which would then forward it via the p2p network.

It is worth noting that the leader Execution Node signs block fragments (frags) made up of a single transaction. This allows nodes to begin rebuilding the current rollup block immediately instead of waiting for the full block to be produced. This gives traders millisecond-level trade confirmation. Since the Execution Node fully executes the transaction before providing the pre-conf, it means the price of the trade is known and issues that could revert a trade (such as the trader not having enough margin) have been satisfied.

The Execution Nodes are described as ‘Sticky’ because they don’t rotate every block like validators on Ethereum L1. Instead, they are designed to maintain a leader over a prolonged period (e.g. 1 hour). Rotation to a new leader is known in advance, giving market makers and other latency sensitive actors the opportunity to migrate operations in advance and remain geographically close to the new node.

Full Node

ReyaChain Full Nodes are non-sequencing follower nodes that track the tip of the chain via the p2p gossip network. As Full Nodes receive rollup block fragments, they optimistically build a local temporary block and provide execution pre-confirmations to end users.

Full Nodes have to locally re-execute each rollup transaction in order to keep up with the current state of the chain, meaning they’ll need to have hardware requirements that are comparable to the requirements imposed on Execution Nodes. They are essential for power users such as bridge operators and market makers to achieve fast finality.

Light Node

Light Nodes keep up with the chain progress without actually needing to re-execute individual transactions. They need to simply apply state-diffs provided by the Execution Node and verify execution proofs generated by the prover network to ensure state transitions are valid. This means that they can run on commodity hardware and power services such as indexers, block explorers or archival nodes.

Prover Node

Reya Chain Prover Nodes validate blocks produced by the Execution Node asynchronously and out of order meaning all state transitions can be cryptographically proven to have been executed correctly. With the entire orderbook embedded into the Execution Node, both matching and clearing are verifiable. This contrasts with most existing approaches that implement matching offchain and only propagating executions onchain.

In order to facilitate this, Reya’s application logic is written in pure rust and cross compiled into ZK-circuits. These execution proofs can in turn be trustlessly verified by a trustless smart contract bridge on Ethereum L1 as well as the ReyaChain Light Nodes.

Based sequencing design using delegation

At the core of a rollup is a sequencer (we call it an Execution Node) — a vital component responsible for managing the transaction flow. Traditional rollup architectures employ a single centralized sequencer so they can achieve web2-like performance and latency while being relatively straightforward to bring into production given there’s no need to bootstrap consensus.

This simplicity does have a range of accompanying drawbacks. Namely, liveness and censorship resistance. A centralized sequencer is a single point of failure, meaning if something goes wrong (e.g. technical failure) then the entire chain will be fully down until the sequencer is back up again.

Additionally, a centralized sequencer has the ultimate power to decide which transactions it wants to include and in which order. This could be due for purely economic motivations, which would endanger fundamental principles of a decentralized, antifragile and permissionless network.

On the other hand, based sequencing allows a subset of Ethereum L1 proposers to take on the responsibility to sequence rollup transactions. Sophisticated Ethereum L1 proposers may choose to operate their own ReyaChain Execution Nodes while others can choose to delegate sequencing rights to third-party operators. This concept takes inspiration from the proposer-builder-separation framework popularized by mev-boost as illustrated in the diagram below.

Some of the key advantages of a based rollup over a traditional one are:

1. Stronger liveness guarantees

2. Stronger censorship resistance

3. Potential for synchronous interactions with the L1 (e.g. take a flash-loan on Ethereum, execute a trade on Reya and then pay the loan back on Ethereum)

The ‘lookahead’, which is 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 forward inside of a range of slots assigned to them by L1 proposers. In order to prevent frequent rotations of nodes, which would cause additional latency, a lower limit will be imposed on the number of consecutive slots a single Execution Node is allowed to sequence. In order to enforce the lookahead schedule, ReyaChain relies on an inbox contract that only accepts transaction batches from an Execution Node assigned to that slot.

Each transaction on ReyaChain has 3 confirmation levels:

1. Pre-confirmed: sequenced by the Execution Node and an execution receipt is available to the user

2. Included: the transaction is included in an L2 block

3. Finalised: the L2 block that contains the transaction has been batched and included in an L1 block

Ethereum L1 proposers and Execution Nodes can permissionlessly join ReyaChain and take on the responsibility of sequencing its blocks. In order to do that they must post collateral, $REYA, in an Ethereum L1 registry smart contract. L1 Proposers and Execution Nodes risk having their collateral slashed in case they start misbehaving.

Performant and programmable: dual execution environments

A ReyaChain Execution Node executes transactions as native rust code (without leveraging a general purpose virtual machine). This frees it from the interpreter overhead, state access latency, strict CU budgets and stack limits associated with the vanilla EVM. By doing so, ReyaChain achieves TradFi-like performance without compromising decentralization. ReyaChain also has native support for a range of oracle provider networks to pull in pricing data in order to support active perpetual futures markets.

It’s worth noting that this comes at the cost of composability with existing EVM smart contracts. Hence, in order to continue supporting the vast developer ecosystem built around the EVM, the Execution Node supports the EVM as an additional execution environment via the Arbitrum Orbit stack.

The ReyaEVM environment is able to communicate with ReyaNative rust primitives via read precompiles and a system contract for sending transactions. Read precompiles have methods for requesting information such as perp positions and oracle prices. In order to execute an action (e.g. limit order) in the native rust environment, the write system contract would emit an event that would in turn be picked up and executed asynchronously.

Interoperability between the ReyaEVM and ReyaNative environments is expected to give rise to a diverse set of novel financial primitives and structured products that were not possible before. This will be achieved by combining the performance of native rust components with the programmability and composability of the EVM as illustrated in the below diagram.

Data availability: orders vs. executions

Data availability (DA) provides guarantees that the complete set of data required to reconstruct the rollup state is accessible. This is a critical component of rollup security, as it enables full nodes and light nodes (+ prover nodes) to independently reconstruct state transitions.

Ethereum’s Dencun upgrade (EIP-4844) introduced blobs as a cheaper, transient data availability (DA) layer alongside calldata. Blobs reduce costs for rollups by expiring data after ~18 days, but their current throughput - around 64 KB/s (6 blobs × 128 KB per block) is insufficient for high-throughput systems like ReyaChain.

This constraint is especially relevant when considering order-level data. Reconstructing the full order book — including all updates, cancels and inserts, requires high-throughput DA and more specialized data structures than Ethereum currently supports. To meet these needs, ReyaChain leverages an external DA provider specifically for order-level data.

However, Ethereum blobs are well-suited for publishing data needed to reconstruct the account state including changes to account balances and positions as a result of executions (when two orders are matched on the orderbook). In essence, Ethereum will handle execution-level DA, while order-level DA must be offloaded to a more scalable external provider.

Progressive rollout

The ultimate goal of ReyaChain is to achieve a fully permissionless based sequencing setup while delivering the critical accompanying primitives outlined through this writeup. Before getting into the details of the rollout strategy, it’s worth taking a step back to have a snapshot of the current state of ReyaChain.

Today, Reya is a general purpose Arbitrum Orbit rollup, which leverages the EVM as its sole execution environment. ReyaDEX is made up of a set of solidity smart contracts that power matching (via a passive pool) and clearing of perpetual future contracts.

The full rollout of ReyaChain will take place in three phases:

1. Migrate trading logic to ReyaNative: this will involve moving trading logic from smart contract running in an EVM environment into native rust components. The first step will be the introduction of a highly performant orderbook

2. Deploy Execution Node: deploy a single Execution Node. This will initially function as a centralized sequencer alongside a hybrid DA setup (Ethereum blobs + specialized DA). This is also when $REYA staking goes live. 

3. Transition to Based: Once the critical steps above are complete, we will progressively transition ReyaChain to the outlined based-sequencing design. We take inspiration from this Gattaca post on how it will be phased, but look forward to working with the broader Ethereum community as we look to deliver the first ever application-specific based rollup. 

To wrap

Yes, no one cares about infrastructure. All people want is a trading environment that’s millisecond-level fast, accessible and always works. But that’s also the point - ReyaChain unlocks the ability to have millisecond-level trading execution, be globally accessible and have the liveness and censorship resistance guarantees of Ethereum.

In the short term Reya is ‘just a DEX’. But our goal is much bigger: a trustless global financial layer that anyone can tap into, build on, and trade within. This needs novel technology, which ReyaChain provides. It also needs a smart execution plan, to actually move global finance onchain. In doing so, we want to transform the $1,000 trillion global capital markets and bring them into the internet age.

Internet Capital Markets are happening. And they’re happening on Reya.

• Follow Simon Jones and Reya Network for all their updates!