**Rome modularizes Solana — Deep Dive Report 2024**

19 min readNov 2, 2024

In this post, we will understand the architecture of the Rome Protocol and deeply explain how it revolutionizes blockchain interoperability.

I’m writing this for anyone curious enough to understand Rome Protocol as a concept and how it has modularized Solana into a set of enshrined services so L2s can be as fast and decentralized as Solana. I am keeping it simple for any newbie to understand this and get an overview of the Rome Protocols.

This is structured into-

Understanding Rome Protocol.
Rome Protocol architecture and how it facilitates atomic composability between Solana and Ethereum.
Rome Protocol Use Cases.
Rome’s modularization of Solana and How its works in blockchain ecosystem?

Ready? Here you go🚀

Rome Protocol

Rome is an instrumental but mystifying strength in the blockchain ecosystem. Liquidity doesn’t capture nearly as much spotlight as application developers or venture capital, yet Rome modularizes Solana consensus into a set of enshrined services so L2s can be as fast and decentralized as Solana. Rome Protocol is built for rollups, RaaS providers, app chains, searchers, bundlers, Ethereum developers, and Solana developers.

“Rome is crafted with code but fueled by a community where innovation meets collaboration to redefine what’s possible in decentralized infrastructure.”

Do you know that the Rome Protocol draws its strength from a network of decentralized builders? Traditional models may turn to corporate funding, but Rome flourishes through the contributions of its community, leveraging a foundation of collaboration and shared liquidity across rollups and app chains.

When you interact with Rome to seamlessly execute cross-chain transactions, have you ever wondered how the underlying architecture orchestrates the flow of assets between Solana and Ethereum and what guarantees the security and atomicity of these operations? 🤔

If not, then the answer lies in Rome’s innovative architecture: a protocol that enables seamless interaction between Solana and Ethereum through atomic cross-rollup and cross-chain transactions.

Here’s a diagram illustrating Rome’s architecture, where Solana’s consensus is modularized into specialized services. This structure provides outstanding speed and decentralization for Layer 2 chains. By converting Solana’s core functions into composable modules, Rome allows L2s to reach Solana-level efficiency, paving the way for scalable, secure blockchain ecosystems. This innovation enhances decentralized infrastructure, offering developers an optimal blend of speed and flexibility.

An Let’s jump into the main points🚀

Rome Architecture

The above process feels justifying, isn’t it☺? But there is more to know about Rome.

Rome EVM

Rome EVM acts as a powerful gateway for deploying Ethereum-compatible dApps on Solana, merging Solana’s speed and scalability with Ethereum’s extensive ecosystem. It includes the OP Geth client for connecting to Ethereum’s RPC, Rhea for accelerating transaction processing and ensuring rapid confirmations, and Hercules for efficiently advancing states using Solana’s ordered blocks. This architecture simplifies application development and enhances liquidity access across both ecosystems, creating a vibrant environment for innovation.

With Rome EVM, developers can go from idea to deployment in minutes, tapping into the combined strengths of Solana’s speed and Ethereum’s flexibility. This streamlined process opens up endless possibilities for decentralized applications, making the journey from concept to creation as fast and intuitive as ever.

The diagram above depicts Rome’s efficient transaction flow, where OP Geth, Rhea, and Hercules work together to facilitate Ethereum-compatible transactions on Solana. Rhea manages sequencing and confirmation, while Solana ensures effective ordering, and Hercules finalizes states. This architecture empowers developers to leverage cross-chain liquidity with speed, reliability, and decentralized integrity.

Looking at discussions on Telegram, Discord, and Twitter, it’s clear that many people still haven’t grasped the full potential of Rome EVM. You’ll often see questions like, “What does this even do?” or “Why not just stick with Ethereum?” or even “How does this benefit”me?” all signs that there’s more to discover.

Let’s get to know how to use Rome EVM.

How to use Rome EVM

Imagine bridging the power of Solana and Ethereum right in your MetaMask wallet. With just a few steps, you can set up Rome EVM in MetaMask, opening the door to lightning-fast transactions and cross-chain functionality. Ready to unlock new possibilities? Let’s get started😎.

So Here is the RPC Information

EVM RPC: https://romeevm.devnet.romeprotocol.xyz
Chain ID: 815817419
EVM Block Explorer: https://romeevm.devnet.romeprotocol.xyz:1000
Solana Block Explorer: https://explorer.solana.com
Solana RPC: https://sol.devnet.romeprotocol.xyz

Follow this step-by-step guide to deploy your first smart contract on the Rome EVM network using MetaMask and Remix IDE.

Prerequisites

MetaMask: Ensure the MetaMask browser extension is installed and configured.
Remix IDE: We’ll be utilizing Remix for deploying the smart contract directly
Foundational Knowledge: A basic understanding of smart contracts and Ethereum-compatible networks will be helpful to follow along.

So now, let’s get you connected! Here’s how to set up the Rome Network in MetaMask for seamless access to decentralized applications on Rome EVM.

Open MetaMask and click on the network dropdown at the top.
Select “Add Network” and then “Add Network Manually”.
Fill in the Rome network details:

Network Name: Rome Network
New RPC URL: https://romeevm.devnet.romeprotocol.xyz
Chain ID: 815817419
Currency Symbol: ROME
Block Explorer URL: https://romeevm.devnet.romeprotocol.xyz:1000

4. Click “Save” and switch to the Rome network.

And this is how it should look like👇

How to Obtain Rome Tokens Airdrop

Kickstart your journey on Rome EVM with a boost claim your airdrop of native tokens and fuel your first transactions with ease. It’s your gateway to exploring decentralized potential!

How it Works:📌

Airdrop tokens to your wallet by visiting: https://romeevm.devnet.romeprotocol.xyz/request_airdrop
Request devnet tokens for your MetaMask address.
Wait for the tokens to appear in your MetaMask wallet.Wait for the tokens to appear in your MetaMask wallet.

And Boom this is How it’s should show🔥.

Ready to do transactions 🚀🚀🚀

You are now ready to do any transactions and deploy any EVM contracts. You can use Remix, Hardhat, or any tool you are familiar with.

Deploying Smart Contracts with Remix IDE

Ready to dive into Rome EVM? Follow these steps to bring your smart contract to life in just a few clicks!

Open Remix IDE in your browser.
Create a new file or open an existing one with your smart contract code.
For this example, we’ll use a simple “Hello World” contract using Solidity.

// SPDX-License-Identifier: MIT
// compiler version must be greater than or equal to 0.8.26 and less than
0.9.0
pragma solidity ^0.8.26;
contract HelloWorld {
string public greet = "Hello World!";
}

4. Compile the smart contract.

5. In Remix IDE, go to the “Deploy & Run Transactions” tab.

6. In the “Environment” dropdown, select “Injected Provider MetaMask”. Ensure MetaMask is connected to the Rome network.

7. Click Deploy.

8. MetaMask will prompt you to confirm the transaction. Review the details and approve it. Wait for the transaction to be confirmed on the Rome network.

9. Once the transaction is confirmed, Remix will display the deployed contract address, somewhat like this.

Congratulations 🎉! You’ve successfully launched your first smart contract on the Rome EVM network!

Here’s a quick video guide to help you deploy a smart contract on the Rome EVM network!

Frame.io

A quick Video guide Here, to help you deploy a smart contract on the Rome Evm network!🔊

App.frame.io

Rome enhances the concept of liquidity in decentralized platforms by integrating cross-chain functionality and fast transactions, enabling smoother asset transfers between networks. In this framework, liquidity evolves from a basic feature into a dynamic resource, driven by Rome’s modular architecture, which unlocks the full potential of decentralized finance on Solana and beyond.

Ready to scale up? What if Setting up an L2 EVM on Rome is your gateway to high-speed, decentralized applications that leverage the power of both Solana and Ethereum. Let’s dive into the essentials to get your environment primed for success!

L2 EVM Setup

Ready to launch your L2 and unlock new possibilities? Then this is it.

L2 EVM setups are like a buffet for Rome modularization everyone rushes in for the instant rewards, but just as quickly, they’re off to find the next dessert table when something sweeter comes along!

Setup Infrastructure. Launch your AWS EC2 powerhouse:

c5a.8xlarge EC2, Ubuntu, 32 CPU, 64GB RAM, 64 bit x86, EBS volume 2 TB, ED25519 key pair

Add Docker’s official GPG key securely to guarantee trusted installations and updates using the code below

sudo apt-get update
sudo apt-get install ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

Add Docker’s repository to Apt sources to access the latest Docker packages.

echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update

Utilize permissions, for they are the gatekeepers to secure access and maintain order

sudo groupadd docker
sudo usermod -aG docker $USER
sudo chown root:docker /var/run/docker.sock
sudo chmod 660 /var/run/docker.sock
logout

install Solana and unlock the power:

sh -c "$(curl -sSfL https://release.solana.com/v1.18.18/install)"
export PATH="/home/ubuntu/.local/share/solana/install/active_release/bin:$PATH"

Install NPM

sudo apt install npm

Want to start a Solana node to run a private Solana network, follow the instructions below.

Setup Solana Node

r6a.8xlarge, Ubuntu x86

Install Solana

# https://docs.solana.com/cli/install-solana-cli-tools#use-solanas-install-tool
sh -c "$(curl -sSfL https://release.solana.com/v1.18.17/install)"
export PATH="/home/ubuntu/.local/share/solana/install/active_release/bin:$PATH"

solana-keygen new -o /home/ubuntu/.config/solana/id.json
# Wrote new keypair to /home/ubuntu/.config/solana/id.json
============================================================================
pubkey: GVN4w5v1nxPKy12ekaWiik9nhyCg3WTWZMJRtCx81qxp
============================================================================
Save this seed phrase and your BIP39 passphrase to recover your new keypair:
leopard need local item record floor cart someone island pulse lottery solve
============================================================================

# Sanity check solana node
solana balance -u localhost

Run Private Solana Node

git clone https://github.com/solana-labs/solana.git

cd /home/ubuntu/solana
rm -rf config/ledger

cd /home/ubuntu/solana/scripts
nohup ./run.sh > /dev/null 2>&1 &

To build and deploy seamlessly, start by downloading Docker and the necessary apps to streamline your development process.

Download Dockers & Apps

Download Rome Dockers.

docker pull romelabs/rollup-op-geth:v0.1.0
docker pull romelabs/rome-apps:v0.1.0
docker pull romelabs/rome-evm:v0.1.0

Alternatively, build Docker Images locally.

git clone https://github.com/rome-labs/rome-apps.git
git clone https://github.com/rome-labs/rome-sdk.git
docker buildx build -t romelabs/rome-apps:latest -f rome-apps/docker/Dockerfile .

git clone git@github.com:rome-labs/rome-rollup-clients.git
docker buildx build -t romelabs/rollup-op-geth:latest -f op-geth/Dockerfile .

Download Rome Apps

git clone git@github.com:rome-labs/rome-apps.git
cd rome-apps/docker

Before launching your project, take the time to prepare your configuration — it’s the foundation for a smooth and efficient deployment.

Prepare Configuration

Start with the Chain ID

915817419

Genesis Address

0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266

Suggested Genesis Balance: 1000000000000000000000000

1000000000000000000000000

Geth JWT Engine Secret:

openssl rand -hex 32

Solana Keypairs:

# See Set Configuration section

Solana RPC

https://sol.devnet.romeprotocol.xyz

Geth Host

l2evm.devnet.romeprotocol.xyz

Set Configuration

Terminal Commands

export CHAIN_ID=915817419
export GENESIS_ADDRESS=0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266
export GENESIS_BALANCE=1000000000000000000000000
export SOLANA_RPC=https://sol.devnet.romeprotocol.xyz
export GETH_HOST=l2evm.devnet.romeprotocol.xyz
export GENESIS_PRIVATE_KEY=ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80
export JWT_SECRET=841d7da44e0f25027c81943a10afcb0b80f7fd1ea53af69a525175ebae2087cf

export ROME_EVM_TAG=v0.1.0
export GETH_TAG=v0.1.0
export RHEA_TAG=v0.1.0
export PROXY_TAG=v0.1.0

solana config set -u https://sol.devnet.romeprotocol.xyz

Add keypairs in rome-apps/docker:

rm *.json
solana-keygen new -o rome-keypair.json --no-bip39-passphrase
solana-keygen new -o rome-evm-owner.json --no-bip39-passphrase
solana-keygen new -o rhea-sender.json --no-bip39-passphrase
solana-keygen new -o proxy-sender.json --no-bip39-passphrase

Airdrop SOL to three keypairs:

solana airdrop 10000 $(solana-keygen pubkey proxy-sender.json)
solana airdrop 10000 $(solana-keygen pubkey rhea-sender.json)
solana airdrop 10000 $(solana-keygen pubkey rome-evm-owner.json)

Update rhea-config.yml in rome-apps/docker to set chain_id, geth_engine_secret, and solana_url

chain_id: 915817419
solana_url: "https://sol.devnet.romeprotocol.xyz"
geth_engine_secret: "841d7da44e0f25027c81943a10afcb0b80f7fd1ea53af69a525175ebae2087cf"
program_id_keypair: "/opt/rome-keypair.json"
payer_keypair: "/opt/rhea-sender.json"
number_holders: 256
geth_http_addr: "http://geth:8545"
geth_engine_addr: "http://geth:8551"
geth_poll_interval_ms: 10oxy-config.yml in rome-apps/docker to set chain_id and solana_url

Setup certificate for use by Docker containers

Create Route 53 URL l2evm.devnet.romeprotocol.xyz to point to EC2 server IP
Open HTTP (80) and HTTPS (443) ports on EC2 server

sudo apt install -y nginx
sudo snap install --classic certbot
sudo ln -s /snap/bin/certbot /usr/bin/certbot
sudo certbot certonly --nginx -n -m rollup@rollup.xyz --agree-tos --domains l2evm.devnet.romeprotocol.xyz
sudo nginx -s stop

sudo ls /etc/letsencrypt/live/l2evm.devnet.romeprotocol.xyz
# Ensure that fullchain.pem and privkey.pem files are located here

Running the Rome Apps

Run docker containers sequentially in the following order:

Run Rome EVM then wait for deployment and initialization

cd rome-apps/docker
docker-compose up rome-evm # wait for container to complete and exit

Check the Solana slot

solana slot

Update start_slot in proxy-config.yml

Run Light Client

docker-compose up proxy -d
docker logs proxy -f # wait for proxy started

Run Geth

docker-compose up geth -d
docker logs geth -f # wait for server listening at http://localhost:3000

Run Rhea

docker-compose up rhea -d
docker logs rhea -f

Below is the list of Docker containers along with their purposes, available for your use:

Rome-Evm 1: Deploys and initializes EVM
Proxy 2: Rome Light Client App
Geth 3: OP Geth App
rhea 4: Rhea App

Alternatively, run all docker containers with one command:

Run Rollup Tests

Airdrop and check balance

Airdrop using https://l2evm.devnet.romeprotocol.xyz/request_airdrop

Alternatively, use cURL to airdrop tokens

curl --location 'https://l2evm.devnet.romeprotocol.xyz/airdrop' --header 'Content-Type: application/json' --data '{"recipientAddr": "0x9B51a9f13FeeF5E28aEEd5e5e8B09AD280C07bCd", "amount": "100"}'

Compare balance on Geth and Solana

Check balance on OP Geth

curl https://l2evm.devnet.romeprotocol.xyz -X POST -H "Content-Type: application/json" \
  --data '{"method":"eth_getBalance","params":["0x9B51a9f13FeeF5E28aEEd5e5e8B09AD280C07bCd", "latest"],"id":1,"jsonrpc":"2.0"}'

Check balance on Solana using Light Client

curl http://l2evm.devnet.romeprotocol.xyz:9090 -X POST -H "Content-Type: application/json" \
  --data '{"method":"eth_getBalance","params":["0x9B51a9f13FeeF5E28aEEd5e5e8B09AD280C07bCd", "latest"],"id":1,"jsonrpc":"2.0"}'

echo "ibase=16; $(echo 56bc75e2d63100000 | tr '[:lower:]' '[:upper:]')" | bc

Compare transaction on Geth and Solana

curl https://l2evm.devnet.romeprotocol.xyz -X POST -H "Content-Type: application/json" \
  --data '{"method":"eth_getTransactionByHash","params":["0x5e7681e585e905802462b602930ad71830714a844c480e22cbc53f03cc7c025b"],"id":1,"jsonrpc":"2.0"}'

Fetch transaction on Solana using Light Client

curl http://l2evm.devnet.romeprotocol.xyz:9090 -X POST -H "Content-Type: application/json" \
  --data '{"method":"eth_getTransactionByHash","params":["0x5e7681e585e905802462b602930ad71830714a844c480e22cbc53f03cc7c025b"],"id":1,"jsonrpc":"2.0"}'

Run Uniswap Tests

Airdrop to three wallets used for Uniswap tests

curl --location 'https://l2evm.devnet.romeprotocol.xyz/airdrop' --header 'Content-Type: application/json' --data '{"recipientAddr": "0xa3349dE31ECd7fd9413e1256b6472a68c920D186", "amount": "100"}'

curl --location 'https://l2evm.devnet.romeprotocol.xyz/airdrop' --header 'Content-Type: application/json' --data '{"recipientAddr": "0x6970d087e7e78a13ea562296edb05f4bb64d5c2e", "amount": "100"}'

curl --location 'https://l2evm.devnet.romeprotocol.xyz/airdrop' --header 'Content-Type: application/json' --data '{"recipientAddr": "0xaA4d6f4FF831181A2bBfD4d62260DabDeA964fF1", "amount": "100"}'

Test Uniswap with Light Client

docker run --network="docker_net" --name="uniswap" -e NETWORK='proxy' -e CHAIN_ID='915817419' romelabs/uniswap-v2-core:v0.1.0 yarn test

Test Uniswap with OP Geth

docker run --network="docker_net" --name="uniswap" -e NETWORK='op-geth' -e CHAIN_ID='915817419' romelabs/uniswap-v2-core:v0.1.0 yarn test

Run Open Zeppelin Tests

Test Open Zeppelin with Light Client

docker run --network="docker_net" --name="openzeppelin" romelabs/openzeppelin-contracts:v0.1.0 -env NETWORK_NAME='proxy'

Test Open Zeppelin with OP Geth

docker run --network="docker_net" --name="openzeppelin" romelabs/openzeppelin-contracts:v0.1.0 -env NETWORK_NAME='op_geth'

Start Block Explorers

Start Geth Block Explorer

Clone repo

git clone --branch production git@github.com:rome-labs/romescout.git

Navigate to docker-compose directory

cd romescout/docker-compose

Update configuration files to use your domain name

romescout/docker-compose/services/nginx.yml

romescout/docker-compose/envs/common-frontend.env

Update configuration to use your naming and branding

NEXT_PUBLIC_NETWORK_NAME=Rome
NEXT_PUBLIC_NETWORK_SHORT_NAME=Rome
NEXT_PUBLIC_NETWORK_ID=915817419
NEXT_PUBLIC_NETWORK_CURRENCY_NAME=Rome
NEXT_PUBLIC_NETWORK_CURRENCY_SYMBOL=ROME

NEXT_PUBLIC_NETWORK_LOGO=http://rome-public-assets.s3.us-east-1.amazonaws.com/rome-banner.png
NEXT_PUBLIC_NETWORK_ICON=http://rome-public-assets.s3.us-east-1.amazonaws.com/rome-logo.png
NEXT_PUBLIC_HOMEPAGE_PLATE_TEXT_COLOR=white
NEXT_PUBLIC_HOMEPAGE_PLATE_BACKGROUND=#5E0A60

Build docker image and run

# Remove old data if restarting block explorer, skip otherwise
sudo rm -rf services/blockscout-db-data
sudo rm -rf services/stats-db-data

# Build docker image locally
docker-compose up --build -d
# docker compose down

Access Rome Scout Explorer at https://l2evm.devnet.romeprotocol.xyz:1000

Access Solana Block Explorer

Explorer | Solana

Inspect transactions, accounts, blocks, and more on the Solana blockchain

explorer.solana.com

Open for external access

Open the EC2 Ports below

Geth: 8545, 8546, 80, 443
Blockscout: 1000

Shared Sequencer

Rollups interested in using Rome as their sequencer: get started here.

To understand the Rome rollup, let’s break it down: it consists of the rollup client, like OP Geth, Rhea acting as the shared sequencer, a dedicated smart contract on Solana, and Hercules. Together, these elements create a powerful framework that enhances scalability and efficiency.

Rhea collects rollup transactions, bundles them into Rome (Solana) transactions, and submits them to Solana for sequencing. As they say, ‘In the world of blockchain, efficiency is the key to unlocking innovation.’ Rhea embodies this principle by streamlining the transaction process for optimal performance.
Solana serves as the global state machine for all rollups, hosting them as smart contracts on its platform. Rollup transactions are executed on Solana first, updating the rollup’s state in real-time. With this, Solana determines the order of transactions, ensuring a seamless and efficient process. As the saying goes, ‘In a decentralized world, clarity and order pave the way for innovation.’ Solana embodies this ethos by providing a robust foundation for rollup functionality.
Hercules receives blocks from Solana and executes the block’s payload on the rollup, effectively advancing the rollup’s state. In the realm of blockchain, ‘progress is born from collaboration and execution.’ Hercules exemplifies this by bridging the gap between Solana and the rollup, driving innovation forward.
Data availability is ensured by posting data to Solana, Celestia, or Ethereum, depending on the rollup’s configuration. In the world of decentralized networks, ‘access to data is the lifeblood of innovation.’ This principle underscores the importance of robust data availability mechanisms in driving the success of rollups.
Settlement occurs by committing the state to Ethereum, ensuring that all transactions are securely recorded. As the saying goes, ‘In the realm of blockchain, trust is built on transparency and permanence.’ This highlights the critical role Ethereum plays in providing a trustworthy settlement layer for rollups.

Atomicity

Atomicity guarantees provided by Rome ensure that all transactions are processed as a single, indivisible operation, maintaining the integrity and reliability of the system.

Solana guarantees that every transaction within a Rome transaction executes atomically either all succeed, or none do. This removes the risk of one transaction in a bundle failing on one chain while others succeed, enabling trustless, non-custodial transactions for cross-rollup and cross-chain arbitrage, flash loans, and real-world asset (RWA) applications. In finance, trust.

Tl;dr — The future potential of Rome transactions is empowering developers to seamlessly integrate operations across multiple blockchain networks. Specifically

Rome Transactions

Different Types of Rome Transactions

Rome transactions are unique Solana transactions, each with its own distinct characteristics. Below is an overview of the various types and their specific features. As we explore these transactions, remember that innovation thrives in diversity; understanding each facet is key to unlocking their potential.

1. Rhea Transaction

The Rhea transaction encapsulates a single Ethereum-like rollup transaction within a Solana transaction. Developers can easily create this transaction using the Rome SDK function ComposeSimpleTxn(Rtxn). As we delve into these transactions, remember, 'The beauty of innovation lies in the simplicity of execution; the right tools can transform complex ideas into reality.

2.Remus Transaction

“Remus transactions consist of multiple Ethereum-like rollup transactions bundled together within a single Solana transaction. This powerful capability allows for greater efficiency and streamlined processing. As we explore these transactions, keep in mind that ‘collaboration often.

This structure enables cross-rollup transactions, allowing Remus transactions to bundle multiple Ethereum-like rollup transactions into one. Developers can create these transactions using the Rome SDK function ComposeCrossRollupAtomicTxn(RTxn1, Rtxn2, Rtxn3, ...). As we navigate this functionality, remember that 'the ability to connect and collaborate across different systems is the essence of true innovation.

Romulus Transaction

Romulus transactions integrate both multiple Ethereum-like rollup transactions and native Solana transactions, all bundled within a single Solana transaction. This innovative approach enhances flexibility and functionality in transaction processing. As we explore this capability, keep in mind that ‘the fusion of diverse elements often leads to the most powerful solutions.

This structure enables seamless cross-chain transactions, allowing Romulus transactions to integrate both Ethereum-like rollup and native Solana transactions into a single bundle. Developers can create these transactions using the Rome SDK function ComposeCrossChainAtomicTxn(Stxn1, Stxn2, ..., Rtxn1, Rtxn2, ...). Remember, 'true connectivity transcends boundaries, unlocking limitless possibilities for innovation.

Rhea

Fair Sequencing of Transactions

Rhea facilitates fair sequencing of rollup transactions, ensuring that all transactions are treated equally and processed on a first-come, first-served basis. This approach fosters transparency and trust within the network. As we explore this principle, keep in mind that ‘fairness is the foundation of trust in any ecosystem.

Transaction flow diagram for Rhea

The diagram below explains how Rhea manages transaction processing in the Rome ecosystem, ensuring fair treatment of all transactions and efficient execution on Solana.

Hercules

Final Confirmation for Ordered Transactions

Hercules receives blocks of ordered transactions from Solana and executes the block payload on the rollup, advancing the rollup’s state. This final confirmation solidifies the transaction’s integrity and consistency. As we reflect on this process, remember that ‘every successful transaction builds trust, paving the way for a more reliable ecosystem.

Rollup users enjoy instant confirmations directly from Solana, bypassing Hercules and speeding up transaction finality. Each confirmed transaction is securely ordered, and the Merkle root is submitted to Ethereum. In blockchain, it’s all about “speed and certainty” swift, secure transactions every time.

The diagram below explains how Hercules integrates with Solana and Ethereum within the Rome ecosystem. It highlights how rollup users receive rapid confirmations directly from Solana.

Transaction flow diagram for Hercules

The diagram below shows Hercules’ role in Rome’s transaction flow, illustrating how rollup transactions from Solana are processed and confirmed with deterministic finality. Hercules ensures transaction integrity and efficiency, enabling secure submissions to Ethereum.

Data Availability

Data availability for rollups is provided through Solana and Celestia, configured specifically at the rollup level. This setup ensures that data is accessible and secure, enhancing the overall functionality of the rollup. As we examine this configuration, remember that ‘robust data availability is the backbone of any decentralized system, enabling reliability and trust across networks.

To leverage Celestia for data availability, simply configure the necessary parameters. Hercules takes charge by crafting the data blob that gets posted to Celestia, highlighting the significance of adaptable data solutions in the blockchain landscape. Embracing innovations like Celestia opens doors to fresh strategies for data availability, boosting both scalability and efficiency.

The diagram below illustrates how Hercules leverages Celestia for data availability in the rollup ecosystem.

Settlement

Settlement for rollups occurs on Ethereum, where Hercules generates the state commitments that are then posted to the Ethereum blockchain. This process ensures that all state changes are securely recorded and verifiable. As we consider this step, remember that ‘settlement on a trusted layer like Ethereum reinforces the integrity of transactions, fostering confidence in decentralized systems.

The diagram you see below illustrates the settlement process for rollups on Ethereum, It depicts the flow of state changes as they are securely posted to the Ethereum blockchain, ensuring each transaction is recorded and verifiable.

Now, let’s delve into the exciting world of Rome Interoperability, where seamless connections between various blockchain ecosystems come to life.

Rome Interoperability

Rome Interoperability is built on three key components: the Rome SDK, the Rome Light Client, and the Fast Finality Layer.

Applications like Searchers and Bundlers use the Rome SDK to execute complex transactions within the blockchain ecosystem. They enable atomic cross-rollup transactions, called Remus transactions, which allow users to perform multiple operations across different rollups in a single action. This atomicity ensures that either all parts of the transaction succeed or none do, preventing inconsistencies from partial execution.

Let’s dive into the Rome SDK, a powerful toolkit that enables atomic transactions across both rollups and different blockchain networks.

Rome SDK

The Rome SDK empowers developers to facilitate atomic transactions across rollups and different blockchain networks. It comprises a comprehensive suite of methods that enable applications to harness the full potential of Rome’s functionality, allowing them to:

Construct atomic Rome transaction across rollups (Remus).
Construct atomic Rome transaction across rollups and Solana (Romulus).
Submit atomic Rome transaction to Solana.
Subscribe to rollup transaction mempool.
Compose Rome transaction from rollup transaction.
Retrieve transaction receipt to confirm result.

The Rome SDK is developed in Rust and can be conveniently accessed as a Cargo crate, allowing developers to easily integrate its features into their applications.

Remus: cross-rollup atomicity

Remus empowers developers to create atomic cross-rollup transactions, ensuring that multiple operations across different rollups are executed seamlessly as a single unit.

Applications skillfully gather transactions from different rollups, merging them into a single atomic Rome transaction. This unified transaction is then submitted to Solana, allowing for synchronous execution across all involved rollups. It’s a sophisticated process, akin to liquidity miners deftly maneuvering through the shifting terrain of rewards.

The diagram below depicts Remus, which enables the creation of atomic cross-rollup transactions. It allows applications to consolidate multiple transactions from different rollups into one atomic Rome transaction, submitted to Solana for synchronous execution across all referenced rollups.

Romulus: cross-chain atomicity

Romulus enables the creation of atomic cross-chain transactions, bridging the gap between Solana and various rollups. This functionality empowers applications to integrate operations across different blockchain networks seamlessly, ensuring that all actions within the transaction are executed together or not at all.

Applications can gather multiple transactions from diverse rollups alongside native Solana transactions, seamlessly composing them into a single atomic Rome transaction. This consolidated Rome transaction is then submitted to Solana, ensuring synchronous execution across both rollups and the Solana network.

The diagram below illustrates how Romulus facilitates atomic cross-chain transactions, highlighting its role in connecting Solana with various rollups. Through Romulus, applications can integrate multiple transactions, including those from different rollups and native Solana transactions, into a cohesive atomic Rome transaction.

One of the most compelling visions for the Rome Protocol is the creation of a seamless “internet of value.” To facilitate the transfer of value across different blockchain networks, Rome serves as a crucial infrastructure component.

Stay Connected with Rome Protocol

Docs: docs.rome.builders

Socials : Twitter/X | Discord | Telegram

Branding : Guidelines & Assets

Wrapping up🏌️‍♂️

In the early days of cross-chain transactions, achieving seamless interoperability across different blockchains was challenging, as traditional models struggled to synchronize operations across varied ecosystems. Rome Protocol introduced a transformative solution by allowing users to contribute liquidity and bridge assets across chains, eliminating the need for direct matches between chains. This innovation unlocked a new era for cross-chain, making seamless transactions and decentralized interoperability possible

Despite the challenges and perceived risks, the concerns and complexities surrounding Rome Protocol feel like hurdles that time and innovation will ultimately overcome. Metrics offer clear numbers and growth patterns, but innovation compounds in ways that are harder to measure. While the outcomes may be uncertain, the wave of projects building around Rome Protocol represents a meaningful step forward. This new era showcases how projects can creatively attract and incentivize deposits, drawing not only individual users but also DAOs into a system that’s paving the future of cross-chain interoperability and liquidity management.

The fun lies in knowing the story so far and not knowing how it will play out. I like the fun part 😉!

What about you?

That was all about Rome! If you found this useful, why not share it with a friend (yes, that friend you’re thinking of!). And if I missed something or you have any questions, feel free to reach out on Twitter @God_Did_Vel 😊

Cheers to Rome Protocol🥂

Until then…

A special thanks to Anie_udo and Jhame for their feedback and for proofreading the first draft.

Rome modularizes Solana — Deep Dive Report 2024