> For the complete documentation index, see [llms.txt](https://docs.rome.builders/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.rome.builders/rome-academy/01-what-you-are-building.md).

# 1. What you're building on Rome

Rome makes EVM and Solana one market. How one contract serves EVM and Solana wallets, and the app you build in this course.

Rome makes EVM and Solana one market. You write Solidity, deploy it with Hardhat or Foundry, and the contract lives on Solana. This lesson gives you the picture you need for the other twelve. You will build a USDC vault that accepts deposits from EVM and Solana wallets.

## What you'll learn

* What Rome is, and why its state is Solana state.
* The two wallet lanes: an EVM key and a Solana key, one contract.
* What a dual-lane app is, and the example you build in lesson 9.
* The two networks you use: Hadrian for testing and Rubicon for production.

## Before you start

This is the first lesson. Read the [course map](https://docs.rome.builders/rome-academy/academy.md) so you know where the course ends. Nothing else is needed. You do not need a wallet yet.

## The idea

EVM and Solana are two markets. Rome makes them one.

Rome runs EVM chains inside Solana, so any EVM protocol can deploy once and open itself to Solana wallets. A Solidity contract on Rome calls Solana programs directly, so EVM users reach Kamino and Solana DEXes. Solgate connects Solana assets to AggLayer EVM chains in both directions, on mainnet and testnet. On testnet, SPL token registration is permissionless. USDC uses CCTP.

Rome runs Solidity contracts by embedding an EVM interpreter in a Solana program. When you deploy a contract, its code and storage become Solana accounts. When someone calls it, the interpreter runs inside the Solana runtime. A call can reach any Solana program in the same transaction, and if any step fails, the whole transaction reverts.

The state is Solana state. Inside Rome, a wallet's SPL token and its ERC-20 wrapper read the same token account, so nothing is minted or locked between them.

Read [One market](https://docs.rome.builders/getting-started-1/one-market.md) for the idea in four capabilities and [What is Rome?](https://docs.rome.builders/getting-started-1/what-is-rome.md) for the full overview. Skim [Why Rome?](https://docs.rome.builders/getting-started-1/why-rome.md) if you want the comparison with other approaches.

## The two lanes

Two kinds of user can call the same contract.

|                           | EVM lane                                       | Solana lane                                         |
| ------------------------- | ---------------------------------------------- | --------------------------------------------------- |
| Wallet                    | MetaMask, or any EVM wallet                    | A Solana wallet                                     |
| Key                       | An EVM key                                     | A Solana key                                        |
| Identity in your contract | The usual address                              | A synthetic address derived from the Solana key     |
| How the call travels      | Signed EVM transaction, sent to the Rome proxy | Solana transaction the wallet signs, sent to Solana |

In both lanes `msg.sender` is an ordinary address and the contract is the same one. A Solana user does not need an EVM key. Rome never links the two identities. A MetaMask key and a Solana key are two different accounts, as two MetaMask keys would be.

[How Solana and the EVM meet on Rome](https://docs.rome.builders/core-concepts/how-solana-and-evm-meet.md) explains the synthetic address, who signs, and who pays. You come back to it in lesson 4. For now, read its first two sections.

## The app you build

A dual-lane app is one Solidity contract that EVM users and Solana users both use directly. The example in this course is a small vault. A user deposits USDC and later withdraws it.

The contract is a normal ERC-20 vault. It pulls tokens with `transferFrom` and returns them with `transfer`. It holds nothing Rome-specific. A Solana user's USDC shows up on the EVM side as the ERC-20 wrapper of that SPL token, so the same two calls work for both lanes.

You build it in lesson 9. The guide behind it is [Build a dual-lane app](https://docs.rome.builders/developer-guides/dual-lane-app.md). Lessons 3 to 8 give you each piece it needs:

1. Deploying to Hadrian (lesson 3).
2. How Rome executes a call (lesson 4).
3. Calling Solana programs (lesson 5).
4. Tokens and wrappers (lesson 6).
5. The Solana wallet lane (lesson 7).
6. The other direction, your Solana program reached from EVM wallets (lesson 8).

Lessons 10 and 11 take the app to real users and real money. Lesson 12 is a short overview of the bigger step, your own Rome chain.

The next lesson, [What you can build](https://docs.rome.builders/rome-academy/02-what-you-can-build.md), shows the use cases this pattern serves.

## The two networks

* **Hadrian** is the public testnet. It settles on Solana Devnet, and its USDC is test USDC. You build everything here first.
* **Rubicon** is the mainnet. It settles on Solana mainnet, and its gas is real USDC.

Both pay gas in USDC. Rubicon runs the same EVM, so the same contract artifacts deploy to both. Chain ids, RPC URLs and the explorer links are on [Hadrian](https://docs.rome.builders/networks/hadrian.md) and [Rubicon](https://docs.rome.builders/networks/rubicon.md). The lessons send you there instead of repeating them.

## See it running

Rome's apps show the idea at work. [Apps on Rome](https://docs.rome.builders/apps-on-rome/apps.md) lists them. Two are worth opening now:

* Rome DEX, one pool that EVM and Solana wallets both trade against.
* Aerarium, a lending market that both kinds of user supply to and borrow from.

Open one and look at its wallet connect screen. It offers both wallet types.

## Check yourself

Answer these without looking, then open the answers.

1. Where does a contract's code live after you deploy it on Rome?
2. A Solana user and a MetaMask user call your vault. What does the vault get as `msg.sender` for each of them?
3. Which network do you build on first, and why?

<details>

<summary>Answers</summary>

1. In Solana accounts, owned by the Rome EVM program. The contract runs inside the Solana runtime.
2. An ordinary address. For the MetaMask user it is their EVM address. For the Solana user it is a synthetic address derived from their Solana key.
3. Hadrian. Its USDC is test USDC, so mistakes cost nothing. Rubicon is production and its gas is real USDC.

</details>

## Next

[2. What you can build: the use cases that matter](https://docs.rome.builders/rome-academy/02-what-you-can-build.md)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.rome.builders/rome-academy/01-what-you-are-building.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
