Rome Protocol: Blockchain Interoperability with Modularized Solana

20 min readNov 1, 2024

Ethereum is the leading blockchain for smart contracts, but its transaction speed and high costs can limit the efficiency and scalability of dApps. In contrast, Solana is a highly advanced blockchain known for its low gas fees and high transaction throughput, made possible by its cutting-edge technology.

Solana’s low fees and high speeds make it a powerful choice for developers. But when it comes to ecosystem size, Ethereum holds the crown as the largest platform for dApps and DeFi.

With Ethereum, developers gain access to a large network, strong development tools, and a booming community. However, according to Switchere, the network’s processing rate is approximately 15 transactions per second. As a result, sending USDT on Ethereum can incur network fees that range from $1.50 to $30, depending on demand and the specific cryptocurrency exchange being used.

Each blockchain has its strengths and weaknesses: Ethereum has scale and developer resources but struggles with costs and speed. Solana excels in performance and affordability but lacks Ethereum’s extensive network effect.

It can be challenging for developers to decide on one option. But what if you didn’t have to choose at all?

Rome Protocol is an approach that combines the best of both blockchains. It leverages Solana’s infrastructure to empower Ethereum’s dApps and Layer 2 chains with Solana’s speed and low fees. By creating a bridge, it helps with cross-chain transactions.

Before diving into the Rome Protocol, let’s first explore layers and important differences between Solana and Ethereum to better understand the innovations that Rome Protocol brings.

Behind the Blockchain

Blockchain Functional Layers

Layer 0: The foundational infrastructure layer of blockchain, allowing various blockchains (like Bitcoin and Ethereum) to communicate. Think of it as the basic road network connecting different blockchain “cities.”

Layer 1: This layer maintains the blockchain network’s core functions but with limited scalability. It’s also known as the implementation layer.

Layer 2: A solution to Layer 1’s scalability limitations, Layer 2 enhances transaction speed and efficiency without burdening the primary network. Similar to an overpass, it reduces congestion by handling transactions off the main chain.

Layer 3: Known as the “application layer,” this layer hosts dApps and protocols, supporting cross-chain interoperability for real-world applications and enhancing user interaction.

Key Difference between Solana and Ethereum

Understanding the Problem

Ethereum has been struggling with one fundamental roadblock, the blockchain trilemma. The tradeoff between security, decentralization, and scalability forces developers to consider two at the cost of the third.

Liquidity fragmentation has been a major criticism of Ethereum’s rollup-centric approach, alongside issues like weakest-link security and limited interoperability.

Liquidity refers to how easily and quickly you can buy or sell an asset without causing big changes in its price.

This fragmentation occurs because each rollup has its own sequencer where transactions are submitted, making them isolated from each other. Without visibility across rollups, transactions and liquidity on one cannot easily interact with those on another.

Let’s say a user wants to move funds between Optimism and Arbitrum. However, because the sequencers for each rollup operate independently and don’t have visibility of each other, there’s no direct way to transfer liquidity across them. The user might have to go through additional steps, such as transferring funds back to the Ethereum mainnet (L1) and then moving them to the other rollup, which costs extra fees and delays.

This isolation of sequencers limits interoperability between the rollups, preventing a more unified liquidity pool across them and complicating user experience.

Understanding the Solution

A shared sequencer allows rollups to launch faster, ensures atomic composability for transactions across rollups, and maintains decentralization. This shared network is crucial for creating secure, decentralized, and scalable blockchain ecosystems.

Shared sequencers also create economies of scale and improve MEV efficiency by reducing latency across multiple sequencers, allowing for more streamlined MEV opportunities.

Current shared sequencers enhances interoperability for optimistic rollups by supporting cross-rollup atomic transactions, but stronger cross-rollup transaction guarantees are still needed for bridging, arbitrage, and liquidity trades. This can be achieved through atomic conditional transaction execution enabled by shared sequencers.

Rome Protocol makes this possible by using Solana as a shared sequencer.

Introduction to Rome Protocol

Rome Protocol is solving and modularizing Solana’s infrastructure to enable cross-chain functionality without compromising speed or decentralization. This protocol serves as a foundational framework, allowing Layer 2 solutions and EVM dApps to operate on Solana.

Rome EVM allows Ethereum-based dApps to harness Solana’s consensus, enabling unparalleled speed while retaining access to Ethereum’s liquidity.

The shared sequencing framework enables Solana to serve as a secure, scalable backbone, ensuring optimized performance for Ethereum rollups and Layer 2 applications.

In other words, Rome makes it possible for other chains to “borrow” Solana’s speed and security, without needing to build their own systems from scratch.

What does Rome Protocol do?

Rome Protocol allows Solana to organize and process transactions from L2 chains in a fair, fast, and decentralized way.

Solana becomes the “organizer” for L2 transactions, arranging them in the right order without any bias. This setup is fair and secure for users on these L2 chains.

Rome makes it possible to send transactions directly between Solana and these L2 chains without needing any middleman. Users can send assets and data between chains easily.

By using Solana’s large network of validators (computers that confirm transactions), Rome Protocol ensures that every transaction is secure and decentralized.

Why is Rome Protocol needed?

Rome Protocol is important because it makes different blockchains more useful together than separately. Right now, blockchains like Solana and Ethereum work independently, which limits what developers and users can do across chains.

Rome Protocol changes that by:

L2 chains can rely on Solana’s fast and low-cost transactions.
L2 users and developers have full control over their transactions while still benefiting from Solana’s robust security.
It opens up ways for Ethereum-based apps to interact with Solana, bringing more flexibility and features for developers and users across both ecosystems.

In short, Rome Protocol connects and strengthens blockchains, letting them work together efficiently while making it easier for users to transact across chains safely and fairly.

Why Solana?

Solana’s high-speed throughput and parallelization capabilities have been the go-to tech to build on.

Solana’s PoH consensus and Sealevel runtime enable near-zero-cost, high-throughput transactions, surpassing the efficiency of EVM-based rollups.
Neon EVM allows Ethereum smart contracts to run on Solana, so Rome Protocol can leverage this existing infrastructure.
With 2000+ TPS and capacity for growth, Solana can handle Rome’s high transaction demands across integrated rollups.
Rome benefits from Solana’s strong security, decentralization, and reorg resistance, backed by $1.4 billion in staked SOL.

How L2 Chain benefit from Solana?

Each L2 blockchain can fully control its transaction ordering (MEV), so Solana cannot alter or profit from transaction sequencing.
L2 chains share a synchronized state with Solana, making them interconnected.
Transactions between Solana and L2 chains can happen in a single, secure step.
All Solana validators work on L2 transactions, securing the system with Solana’s full decentralization and stake.
Users can transact without needing a trusted third party, supporting uninterrupted connections between Solana and Ethereum L2s.
L2 users can even set up their own nodes to manage transactions on Solana directly, ensuring total control and fairness.

How Solana benefit from Rome Protocol?

Solana is known for handling thousands of transactions per second with low fees. By supporting L2s, Solana puts its high capacity to good use without overwhelming the network. In fact, Solana is designed to manage large transaction loads, so adding L2 transactions fits well within its capabilities.
More transactions through L2s mean more activity and fees for Solana’s validators. This incentivizes validators to continue supporting the network and keeps Solana economically strong, which benefits the entire ecosystem.
By working as a shared sequencer for L2s, Solana essentially “connects” with other blockchain ecosystems like Ethereum. This makes Solana more versatile and valuable as a hub for cross-chain applications, bringing in more developers, users, and activity.
With more L2s using Solana’s infrastructure, the network becomes more widely used and secure. Rome Protocol ensures that L2 chains use Solana’s validators without relying on a few powerful ones, keeping the network decentralized.

In short, Solana can take on the added L2 transactions effectively, and Rome Protocol makes sure this workload is handled efficiently. Instead of burdening Solana, it strengthens the network by expanding its role and bringing in more use cases and participants.

Rome’s architecture

Rome Protocol organizes Solana’s ecosystem into independent, reusable components, enabling developers to build scalable applications.

Its architecture supports atomic composability, allowing smart contracts on Solana and Ethereum to interact instantly and securely.

All this is possible because of its major architecture.

Rome’s Stack includes Rome EVM, Shared Sequencer, Rome Interop, and Rome DA.

Rome EVM

Rome EVM enables deploying any EVM Dapp on Solana with SPL and ERC20 token interoperability.

Rome EVM offers significantly lower latency and high throughput.

It provides users with the ability to do EVM transactions on Solana and offers a familiar, easy-to-use execution environment using OP Geth.

Rome EVM is composed of OP Geth client, Rhea, Rollup smart contract on Solana, and Hercules.

OP Geth client enables users and applications to use an Ethereum RPC
Rhea processes OP Geth transactions and provides fast confirmation to users
Hercules takes ordered blocks from Solana and executes the payload on OP Geth to advance state

Key Features of Rome EVM

1. Run any EVM-compatible application directly on Solana, benefiting from its lightning-fast, low-cost infrastructure.

2. Rome EVM enables smooth integration between Solana’s SPL tokens and Ethereum’s ERC-20 assets, allowing easy cross-chain asset transfers and unified dApp experiences.

3. Optimized for Ethereum developers, Rome EVM offers a familiar interface, enabling you to start building right away with any standard Ethereum client, without needing to learn new tools.

4. Rome EVM stands out by allowing developers to deploy any EVM implementation, including options with features like EIP-1559, for a fully customizable environment.

The complete guide to deploying your EVM dApp on Rome is here.

Before we jump into the Rome Shared Sequencer, it is important to familiarize ourselves with some fundamental yet essential terms.

Rollup

In the Ethereum modular roadmap, executions are offloaded to rollups. Rollups record transactions that take place on their platforms and once these are confirmed, the transaction record is confirmed on the Layer 1 blockchain. For anyone monitoring the system, the data availability layer ensures that anyone can verify the inputs and outputs of these transactions to ensure they were conducted correctly.

Imagine two users, Alice and Bob, each receiving $50 from the Ethereum main layer. They both want to perform transactions within the ecosystem, but instead of interacting directly with the main Ethereum chain, they use a rollup. Alice choose to send $20 to Bob within the rollup environment, while Bob use some of his funds to buy an asset.

Since they are using the rollup, all of their transactions are processed off-chain, which is much faster and cheaper than direct Layer 1 transactions. Once their transactions are completed, the rollup gathers them into a batch, processes the net effect, and records a single, optimized proof of these transactions on the main Ethereum chain.

Rollups consist of several components. While each of them is slightly different, each of them shares key components, such as the:

Sequencer: Picks up transactions from the L2 mempool, decides whether to execute or discard them, and broadcasts this information to other nodes.
Layer 1 Rollup Contract: A smart contract living on Ethereum, that receives batches of transaction data that occurred on L2. It also receives proofs (either fault proofs for optimistic rollups, or ZK proofs for ZK rollups) to verify batches.

The above diagram is a simplified version of a rollup’s architecture. At a high level, it’s how rollups operate; arguably the most important component of the entire system is the sequencer, because of its two critical responsibilities:

Read transactions from the mempool and execute or discard them. Without the sequencer, none of the rollup’s transactions would be handled at all.
Batch transactions up together, and ship them to Ethereum. Without the sequencer, there would be no “rolling up”; it is responsible for sending all of the transaction data that occurred on L2 to Ethereum.

Shared Sequencer

It is a single rollup-agnostic network of sequencers that will support several different rollups. The various rollups will submit transactions to the sequencing network, which will organize them into shared bundles for inclusion in the Layer 1 blockchain’s digital ledger.

A shared sequencing network is rollup-agnostic. This means that it can support multiple types of rollups, including both Optimistic and ZK-Rollups.

In the current system, having just one Sequencer creates a vulnerability. If it goes down or behaves unfairly, it can affect the entire rollup. Shared Sequencers solve this problem by electing a new leader for each round of sequencing. This way, no single entity has full control, reducing the risk of failures or censorship. Thus, rollups can easily join or leave these Shared Sequencing networks, promoting healthy competition among them. If one Shared Sequencing network isn’t treating users well or is charging too much, rollup projects can switch to other networks that offer better services.

In addition, Shared Sequencers can facilitate interoperability between different rollups by pooling transactions across them. This enables smooth communication and interaction between rollup networks.

Rome Shared Sequencer.

Rome allows layer 2 solutions and applications to utilize Solana as their shared sequencer.

Solana ensures rapid transaction confirmation, high throughput, and immutable transaction ordering, supported by the entire Solana state.

Rome offers Rollup as a Service, enabling rollups and applications to get started easily. You can request your Rome rollup here.

Shared Sequencer Architecture

Rhea

The Rhea API allows Solana to function as a shared sequencer that processes rollup transactions, maintains the state, and publishes transactions. By utilizing the Rhea API, transactions that are pending in the rollup's OP Geth mempool are processed, packaged for Solana, and submitted to the Solana network. The corresponding rollup program on Solana then executes these transactions. After execution, a block is created, and the rollup state is updated accordingly.

Transactions are taken from rollups on a first-come, first-served basis and submitted to Solana. The execution and state on Solana determine the order of transactions, ultimately set by the Solana leader node.

Remus

Cross-rollup atomicity ensures that transactions across multiple rollups (e.g., Optimism, Arbitrum on Ethereum) either fully complete or fully fail, preventing partial transactions and keeping states consistent.

Remus provides this capability by allowing applications to combine transactions from different rollups into a single atomic Rome transaction. Submitted to Solana, this transaction executes synchronously across all specified rollups, ensuring consistent updates.

The Remus API supports atomic transaction execution across rollups, enabling searchers and bundlers to create bundles of transactions that maintain synchronized states across rollups through Solana.

The diagram below illustrates how bundlers utilize Remus to assemble and submit these atomic transactions to Solana.

Cross-rollup atomic transactions support use cases such as atomic arbitrage, bridging, liquidity aggregation, and RWAs. Their low latency, high throughput, and quick confirmations are particularly beneficial for users like hedge fund traders.

Rhea facilitates fair and blind sequencing of rollup transactions; all transactions are treated equally and processed on a first-come, first-served basis.

Remus offers a premium transaction service for cross-rollup atomic composability, enabling the growth of ecosystem services. The table below outlines the differences between the two.

Romulus

Cross-chain atomicity exists between different blockchains (e.g., between Ethereum and Solana). It ensures that a transaction spanning multiple blockchains completes only if every part of the transaction can be confirmed across all involved chains.

Imagine a user who wants to perform a trade that requires moving tokens from Ethereum to Solana. Cross-chain atomicity ensures that this entire operation is executed only if each step across both chains succeeds; if not, all operations are rolled back, maintaining consistency across chains.

Romulus provides the ability to create atomic cross-chain (Solana + rollups) transactions. Applications can create or take multiple transactions from different rollups, as well as native Solana transactions, and compose them into a single atomic Rome transaction.

Hercules

Hercules processes ordered transaction blocks received from Solana, executing them on the rollup to update its state.

Users benefit from fast confirmation directly on Solana, rather than waiting for Hercules to complete, as it may take longer while Solana finalizes the transactions.

This setup provides deterministic finality, a guaranteed and unchangeable transaction order. Along with the final order, a Merkle root (a summary of all transactions in a block) is sent to Ethereum to establish an unalterable record.

Let’s understand Interoperability and Atomic Composability before understanding Rome Interop.

Interoperability

Interoperability means the ability of different blockchains or protocols to communicate, share data, and work together. It allows assets and information to move freely across various blockchain networks, and form an interconnected and efficient ecosystem.

A user could move assets from Ethereum to Solana without needing to convert them through an intermediary.

Users don’t have to be limited to a single blockchain ecosystem. They can access dApps and services across multiple chains. Liquidity is better distributed, reducing the fragmentation of assets across isolated chains. This can help stabilize prices and lower transaction fees.

For Example, A DeFi application could allow users to lend assets on Ethereum and borrow on another blockchain like Avalanche. Thanks to interoperability, these transactions are treated as a single, smooth experience for the user.

Interoperability ultimately promotes collaboration, increases blockchain functionality, and pushes forward the development of a more interconnected Web3 ecosystem.

Rome Interoperability consists of Rome SDK, Rome Light Client, and Fast Finality Layer.

Applications such as Searchers and Bundlers can use the Rome SDK to execute atomic cross-rollup (Remus) transactions and atomic cross-chain (Romulus) transactions across Solana and rollups.

Atomic Composability

Atomicity

Atomicity ensures that a transaction involving multiple actions, like token transfers or calls to DeFi applications, is treated as a single, unified process. For the transaction to succeed, each individual action within it must be valid and executable. If any part fails, the entire transaction will revert.

This feature is essential for executing complex, safe DeFi transactions instantly, such as exchanging two tokens between individuals or using multiple DeFi apps in a single operation.

Composability

Composability in DeFi is the ability for dApps to work together, transaction by transaction. Often called “Money Legos” each DeFi app serves as a modular “brick” representing a financial product or service. These bricks can be combined in new ways, allowing developers to create sophisticated, customizable financial solutions by connecting various DeFi services to meet specific user needs. Unlike traditional finance, these connections are made dynamically with each transaction, supporting an unprecedented level of flexibility and innovation.

Atomic Composability

Atomic Composability combines atomicity and composability, enabling multiple applications to interact within a single, unified transaction. All actions within this transaction must either succeed together or fail together.

Atomic Composability is fundamental to unlocking DeFi’s potential, as it allows various DeFi services to work together in complex and innovative ways. A notable example of atomic composability in action is the flash loan” where a user can borrow and repay an asset within the same transaction, enabling highly efficient arbitrage without credit risk.

Rome Interop

Rome Interop bridges Solana and Ethereum, enabling atomic composability between Layer 2 solutions on Ethereum and Solana. With its SDK and Finality Layer, Rome Interop allows any transaction from Ethereum to be combined with one from Solana, enabling seamless multi-chain dApp experiences.

The Rome SDK simplifies building cross-chain applications by providing tools for developers to create dApps that use both Ethereum’s DeFi ecosystem and Solana’s fast-processing environment.

The Rome Finality Layer uses light-client technology (a lightweight protocol that verifies transactions without needing the full blockchain data) to ensure transaction finality.

This means transactions are confirmed and cannot be reversed across Ethereum and Solana without sacrificing speed.

Acting as an AVS (Actively Validated Service), it guarantees that transaction confirmations are synchronized across both blockchains.

This makes cross-chain transactions both secure and efficient, ensuring they execute together or not at all.

Rome Interop enables developers to create powerful, cross-chain applications that utilize Ethereum’s and Solana’s strengths, allowing for complex DeFi strategies, cross-chain arbitrage, and liquidity pooling. This streamlined interoperability supports innovative, multi-chain dApp experiences.

Rome Data Availability

Data availability refers to guarantees that the data needed to verify a block in the blockchain is available to all network participants.

This concept is fundamental to the proper functioning of blockchains, as it allows for full validation of the blockchain’s history and current state by any participant, thereby maintaining the decentralized and trustless nature of the network.

Without guaranteed data availability, participants could not independently verify the legitimacy of transactions and blocks, which could lead to issues like fraud or censorship within the network.

Importance of data availability

Data availability enables network participants to independently verify the blockchain’s dataset.

Equal access to the complete ledger data prevents centralization of control, ensuring no single entity can dominate the network.

Since blockchain data is readily available, the network of nodes can detect and rectify inconsistent records.

Moreover, data availability can turn into a scalability bottleneck as the network and data volume grow.

Scaling solutions like rollups resolve this issue by off-loading processing overhead from the mainnet, which again underscores the importance of data availability.

Data availability in rollups

Rollup scaling solutions such as Optimistic and ZK-rollups reduce the transaction burden from Ethereum by processing them off-chain and publishing them in batches of multiple transactions on the mainnet.

This increases Ethereum throughput and reduces gas, but it necessitates rollups to guarantee data availability for the correctness of off-chain processing.

Optimistic rollups ensure data availability by posting compressed transaction data — CALLDATA on the Ethereum mainnet. Verifiers use this data to validate or challenge transactions through fraud-proof during the challenge window period.

On the other hand, Zero-knowledge rollups use cryptographic zero-knowledge validity proofs to guarantee the correctness of state transactions. While the proof ensures the validity of state updates, zk-rollups does not publish all transaction data. Thus, it still needs to guarantee the availability of data.

Rome Protocol has partnered with Celestia, a blockchain dedicated to scaling data availability.

To use Celestia as DA, set the parameters to Celestia.

Hercules creates the blob of data that is posted to Celestia.

Source: Rome Docs

Real-World Use Cases for Rome Protocol

The architecture of the Rome Protocol opens the door to many high-impact applications.

Arbitrage Opportunities
The Rome Protocol enhances arbitrage and searcher activities by enabling cross-chain atomic transactions, allowing traders to buy assets at lower prices on one chain and sell them at higher prices on another in a single, risk-free transaction. This unified environment increases efficiency by minimizing latency and providing quick access to liquidity from both Solana and Ethereum, resulting in lower transaction costs.

The fast processing speed on Solana allows searchers to react to market changes in real-time, maximizing profits by capitalizing on price discrepancies with minimal slippage.

Cross-Chain NFT Marketplaces
With Rome, NFTs minted on Ethereum can be traded or used on Solana, opening new possibilities for cross-chain asset utilization and interoperability within NFT marketplaces.

DeFi Platforms
Through atomic composability, DeFi platforms can now pool liquidity from both Solana and Ethereum, creating larger, more resilient liquidity pools and offering optimized yields for users.

Decentralized Exchanges
DEXs built with Rome’s architecture can facilitate cross-chain token swaps with minimized latency, allowing assets from multiple chains to be traded effortlessly.

Cross-Chain Lending and Borrowing
With Rome’s interoperability, lending protocols can provide cross-chain collateral options, allowing users to borrow on one chain while using assets from another as collateral. This unlocks broader liquidity access and lowers capital requirements for users.

Cross-Chain Identity Verification and Compliance
Identity verification platforms can leverage the Rome Protocol to securely manage identity data across chains, aiding DeFi apps in meeting KYC/AML standards without data silos.

Let’s take an example, Olivia wants to invest in a new DeFi platform but doesn’t want to repeatedly verify her identity on each new platform due to security and privacy concerns. Rome enables her to complete one KYC verification and use it across multiple dApps on different blockchains, saving time and securing her information.

Modular Blockchain Architecture

The idea of a modular blockchain is that it can specialize in a couple of functions instead of trying to do everything. A more scalable and customizable system can be created by combining multiple specialized blockchains.

The framework behind modular blockchains lies in the principle of modular design. A design is modular if it divides a system into smaller parts that can be exchanged or replaced.

The functions that modular blockchains can specialize in are:

Execution: Process transactions.
Settlement: Dispute resolution and bridge (optional).
Consensus: Order transactions.
Data availability: Ensure data is available.

Importance of modular blockchains

1. Scalability

Modular blockchains help blockchains offload their headaches to dedicated chains, freeing up nodes on settlement layers like Ethereum. This enables developers to use the expensive L1 only for critical consensus and ordering functions instead of archiving.

dApps can reduce their storage costs significantly, while also lowering fees for users.

2. Security

With modular blockchains, developers can leverage existing sets of validator nodes to deploy a new chain rather than bootstrapping. Thereby, the upfront cost of maintaining and running nodes is reduced for the developers, and further saves time for them during the development process.

3. Flexibility

Modular blockchains allow developers to plug-n-play around modules to experiment and build customized networks optimized for performance, security, and cost. This composability offers greater flexibility for developers, which wouldn’t be possible with monolithic chains.

Conclusion

The Rome Protocol marks a major step forward in blockchain by modularizing Solana’s consensus, which breaks it down into manageable parts, and boosts its interoperability with Ethereum. This results in faster transactions and improved scalability, which are essential for growing areas like DeFi.

For developers, Rome provides the flexibility to select tools that best match their project needs, encouraging innovation and creativity. It also strengthens security by ensuring consistent handling of cross-chain transactions.

In our exploration, we outlined Rome Protocol’s main purpose and features, focusing on its role in creating a more interconnected blockchain environment. We studied how Rome’s architecture enables efficient and reliable transactions between Solana and Ethereum and discussed how its modular setup enhances the ecosystem.

Watch my detailed explanation of the Rome Protocol. It will provide valuable insights and enhance your understanding.

If you made it so far, thank you for reading it here. It would mean the world to me if you could share it, and justify the effort that went into this one because Just like Rome, this article wasn’t made in a day.

If you have any queries, feel free to reach out to me on Twitter / X— @0xVivek88

To become a part of Rome Protocol, please join the Discord server: