> 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/pt-br/rome-academy/01-what-you-are-building.md).

# 1. O que você está construindo na Rome

Rome torna EVM e Solana em um único mercado. Como um contrato atende carteiras EVM e Solana, e o app que você constrói neste curso.

Rome transforma EVM e Solana em um único mercado. Você escreve em Solidity, faz o deploy com Hardhat ou Foundry, e o contrato passa a existir na Solana. Esta lição apresenta o panorama necessário para as outras doze. Você vai criar um cofre de USDC que aceita depósitos de carteiras EVM e Solana.

## O que você vai aprender

* O que é Rome e por que seu estado é o estado da Solana.
* As duas vias de carteiras: uma chave EVM e uma chave Solana, um único contrato.
* O que é um app de via dupla e o exemplo que você vai criar na lição 9.
* As duas redes que você vai usar: Hadrian para testes e Rubicon para produção.

## Antes de começar

Esta é a primeira lição. Leia o [mapa do curso](https://docs.rome.builders/pt-br/rome-academy/academy.md) para saber onde o curso termina. Não é preciso mais nada. Você ainda não precisa de uma carteira.

## A ideia

EVM e Solana são dois mercados. Rome os transforma em um só.

Rome executa cadeias EVM dentro da Solana, permitindo que qualquer protocolo EVM faça o deploy uma única vez e se abra para carteiras Solana. Um contrato Solidity na Rome chama programas da Solana diretamente, permitindo que usuários EVM acessem Kamino e DEXes da Solana. O Solgate conecta ativos da Solana a cadeias EVM da AggLayer nos dois sentidos, tanto na mainnet quanto na testnet. Na testnet, o registro de tokens SPL não exige permissão. O USDC usa CCTP.

Rome executa contratos Solidity incorporando um interpretador EVM em um programa da Solana. Quando você faz o deploy de um contrato, seu código e armazenamento se tornam contas da Solana. Quando alguém o chama, o interpretador é executado dentro do runtime da Solana. Uma chamada pode acessar qualquer programa da Solana na mesma transação e, se qualquer etapa falhar, toda a transação é revertida.

O estado é o estado da Solana. Dentro da Rome, o token SPL de uma carteira e seu wrapper ERC-20 leem a mesma conta de token, portanto, nada é emitido nem bloqueado entre eles.

Leia [Um mercado](https://docs.rome.builders/pt-br/primeiros-passos-1/one-market.md) para conhecer a ideia em quatro recursos e [O que é Rome?](https://docs.rome.builders/pt-br/primeiros-passos-1/what-is-rome.md) para ver a apresentação completa. Leia por alto [Por que Rome?](https://docs.rome.builders/pt-br/primeiros-passos-1/why-rome.md) se quiser comparar com outras abordagens.

## As duas vias

Dois tipos de usuário podem chamar o mesmo contrato.

|                              | Via EVM                                          | Via Solana                                                   |
| ---------------------------- | ------------------------------------------------ | ------------------------------------------------------------ |
| Carteira                     | MetaMask ou qualquer carteira EVM                | Uma carteira Solana                                          |
| Chave                        | Uma chave EVM                                    | Uma chave Solana                                             |
| Identidade no seu contrato   | O endereço habitual                              | Um endereço sintético derivado da chave Solana               |
| Como a chamada é transmitida | Transação EVM assinada, enviada ao proxy da Rome | Transação da Solana assinada pela carteira, enviada à Solana |

Nas duas vias `msg.sender` é um endereço comum, e o contrato é o mesmo. Um usuário Solana não precisa de uma chave EVM. Rome nunca vincula as duas identidades. Uma chave MetaMask e uma chave Solana são contas diferentes, assim como duas chaves MetaMask seriam.

[Como Solana e EVM se encontram na Rome](https://docs.rome.builders/pt-br/conceitos-principais/how-solana-and-evm-meet.md) explica o endereço sintético, quem assina e quem paga. Você voltará a esse assunto na lição 4. Por enquanto, leia as duas primeiras seções.

## O app que você vai criar

Um app de via dupla é um único contrato Solidity usado diretamente tanto por usuários EVM quanto por usuários Solana. O exemplo deste curso é um pequeno cofre. O usuário deposita USDC e depois o retira.

O contrato é um cofre ERC-20 comum. Ele transfere tokens usando `transferFrom` e os devolve usando `transfer`. Ele não contém nada específico da Rome. O USDC de um usuário Solana aparece no lado EVM como o wrapper ERC-20 desse token SPL, então as mesmas duas chamadas funcionam nas duas vias.

Você vai criá-lo na lição 9. O guia que serve de base é [Criar um app de via dupla](https://docs.rome.builders/pt-br/guias-do-desenvolvedor/dual-lane-app.md). As lições 3 a 8 apresentam cada um dos componentes necessários:

1. Implantação na Hadrian (lição 3).
2. Como a Rome executa uma chamada (lição 4).
3. Chamadas a programas da Solana (lição 5).
4. Tokens e wrappers (lição 6).
5. O fluxo de carteiras da Solana (lição 7).
6. A direção inversa: seu programa da Solana acessado por carteiras EVM (lição 8).

As lições 10 e 11 levam o app até usuários reais e dinheiro de verdade. A lição 12 é uma breve visão geral do próximo grande passo: sua própria blockchain Rome.

A próxima lição, [O que você pode criar](https://docs.rome.builders/pt-br/rome-academy/02-what-you-can-build.md), apresenta os casos de uso atendidos por esse padrão.

## As duas redes

* **Hadrian** é a testnet pública. Ela liquida transações na Solana Devnet, e seu USDC é de teste. Você começa construindo tudo aqui.
* **Rubicon** é a mainnet. Ela liquida transações na mainnet da Solana, e seu gas é pago com USDC real.

Ambas pagam o gas em USDC. A Rubicon executa a mesma EVM, então os mesmos artefatos de contrato podem ser implantados nas duas redes. Os IDs das redes, as URLs de RPC e os links dos exploradores estão em [Hadrian](https://docs.rome.builders/pt-br/redes/hadrian.md) e [Rubicon](https://docs.rome.builders/pt-br/redes/rubicon.md). As lições levam você até lá, em vez de repetir essas informações.

## Veja em funcionamento

Os apps da Rome mostram a ideia na prática. [Apps na Rome](https://docs.rome.builders/pt-br/apps-na-rome/apps.md) lista esses apps. Vale a pena abrir dois deles agora:

* Rome DEX, um pool com o qual carteiras EVM e Solana podem negociar.
* Aerarium, um mercado de empréstimos ao qual os dois tipos de usuário podem fornecer ativos e do qual podem tomar emprestado.

Abra um deles e veja a tela de conexão da carteira. Ela oferece suporte aos dois tipos de carteira.

## Teste seus conhecimentos

Responda sem consultar o material e, depois, confira as respostas.

1. Onde fica o código de um contrato depois que você o implanta na Rome?
2. Um usuário da Solana e um usuário da MetaMask chamam seu vault. O que o vault recebe como `msg.sender` para cada um deles?
3. Em qual rede você começa a desenvolver e por quê?

<details>

<summary>Respostas</summary>

1. Em contas da Solana, pertencentes ao programa EVM da Rome. O contrato é executado dentro do runtime da Solana.
2. Um endereço comum. Para o usuário da MetaMask, é o endereço EVM dele. Para o usuário da Solana, é um endereço sintético derivado da chave Solana dele.
3. Na Hadrian. Seu USDC é de teste, então os erros não custam nada. A Rubicon é de produção, e seu gas é pago com USDC real.

</details>

## Avançar

[2. O que você pode criar: os casos de uso que importam](https://docs.rome.builders/pt-br/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/pt-br/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.
