> 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/04-how-rome-runs-your-code.md).

# 4. Como a Rome executa seu código

Como uma transação Rome se torna transações da Solana, por que a maioria das chamadas é executada atomicamente e o que muda quando uma chamada é grande demais.

Seu Solidity roda sem alterações. O que muda é onde ele roda: dentro de um programa Solana, sob os limites da Solana. Esta lição oferece a visão de que você precisa para prever quanto uma chamada vai custar e quando ela vai falhar.

## O que você vai aprender

* O caminho que uma transação percorre da sua carteira até um validador Solana e de volta a um recibo da EVM.
* A diferença entre execução atômica e iterativa, e por que você quer a execução atômica.
* Quais limites da Solana afetam seu Solidity: computação, tamanho, quantidade de contas, bloqueios.
* Como medir o que uma chamada realmente custa.

## Antes de começar

* Concluir [3. Seu primeiro contrato no Hadrian](https://docs.rome.builders/pt-br/rome-academy/03-first-contract-on-hadrian.md). Você precisa de um contrato implantado e de uma transação que você tenha enviado a ele.
* Mantenha esse hash da transação à mão. Você vai abri-lo no explorador no final desta lição.

## O caminho de uma transação

Você assina uma transação EVM comum e a envia ao proxy da Rome com `eth_sendRawTransaction`. O proxy ainda não a encaminha. Primeiro ele executa a chamada off-chain em um emulador que executa a mesma lógica da EVM que o programa on-chain. A emulação informa três coisas: quanto gas a chamada precisa, quais contas da Solana a chamada toca e se a chamada cabe em uma única transação Solana.

Em seguida, o proxy empacota sua chamada como instruções Solana e as envia. O programa EVM da Rome, que é um programa Solana comum, interpreta seu bytecode. As mudanças de estado vão parar em contas Solana. Um indexador lê o resultado e produz o bloco e o recibo da EVM que suas ferramentas esperam.

Cada endereço EVM mapeia para uma conta Solana pertencente ao programa Rome. O saldo, o nonce, o código e o armazenamento do seu contrato são todos contas Solana. É por isso que o proxy precisa saber a lista de contas antes de enviar: a Solana exige que cada conta seja nomeada previamente.

Leia o ciclo de vida completo em [Modelo de execução](https://docs.rome.builders/pt-br/conceitos-principais/execution-model.md).

## Atômico primeiro

A maioria das chamadas roda em uma única transação Solana. A Rome chama isso de execução atômica (VmAt). É tudo ou nada: se qualquer etapa falhar, a chamada inteira é revertida. Uma transferência, um swap e a maioria das chamadas DeFi cabem. Algumas não: um empréstimo da Aave no Hadrian precisou de mais de uma transação Solana.

Uma chamada atômica tem um orçamento de cerca de 1,4 milhão de unidades de computação. Esses limites moldam cada chamada:

| Limite              | O que isso significa para você                                                                                                                        |
| ------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
| Computação          | Cerca de 1,4 milhão de CU compartilhadas pelo trabalho da EVM e por todo programa que você chamar                                                     |
| Contas              | 64 endereços, contando as próprias contas da Rome e tudo o que seus CPIs tocam                                                                        |
| Tamanho             | 4 KB por transação Solana; payloads EVM maiores, como grandes implantações, são preparados por meio de uma conta holder e o SDK cuida disso para você |
| Tamanho do contrato | 24 KB, como na Ethereum                                                                                                                               |

A lista completa, com os valores, está em [Restrições](https://docs.rome.builders/pt-br/conceitos-principais/constraints.md).

## Iterativa quando uma chamada é grande demais

Se o emulador descobrir que uma chamada não cabe, a Rome a executa de forma iterativa (VmIt). A chamada é dividida em etapas. Cada etapa é sua própria transação Solana e executa tantos opcodes quanto seu orçamento de computação permitir. Entre as etapas, o estado da VM é salvo em uma conta holder e a próxima etapa o retoma.

A execução iterativa funciona, mas tem um custo:

* Uma sessão termina após 160 etapas. Depois disso, ela libera seus bloqueios e não confirma nada.
* A sessão bloqueia suas contas de saldo e armazenamento por alguns segundos, renovando a cada etapa. Uma gravação atômica em uma conta bloqueada é recusada com `AccountLocked`, e o cliente reenviará.
* Chamadas que fazem CPIs da Solana no caminho legado (as `CpiProgram` e `HelperProgram` chamadas da lição 5) não podem ser executadas de forma iterativa de jeito nenhum. Elas precisam caber na forma atômica.
* Na via da Solana, uma carteira que assina suas próprias etapas solicita ao usuário uma vez por etapa.

A regra de projeto é esta: molde cada ação do usuário para caber em uma única transação atômica. Se um fluxo for maior, divida-o em duas ações do usuário em vez de depender do modo iterativo. A lição 5 volta a isso quando você chamar programas da Solana.

## O que você paga

A Rome contabiliza o custo de uma chamada em lamports da Solana: taxas de assinatura, um pedágio fixo, aluguel para qualquer conta que a chamada crie. Uma unidade de gas representa um lamport de custo. O preço do gas converte isso para o token de gas da rede, que é USDC no Hadrian e no Rubicon.

O aluguel é a parte que surpreende as pessoas. A primeira transferência para um endereço que nunca foi usado cria contas, então custa muito mais do que uma transferência repetida. Espere gas alto no primeiro acesso e gas normal depois. Os números detalhados estão em [Como a Solana e a EVM se encontram na Rome](https://docs.rome.builders/pt-br/conceitos-principais/how-solana-and-evm-meet.md#gas-and-rent).

## Meça, não chute

EVM `gasUsed` não é um substituto fiel para a computação da Solana. Na Rome, uma unidade de gas é um lamport de custo, então `eth_estimateGas` dimensiona seu limite de gas, mas não diz nada sobre unidades de computação. Leia a computação pelo lado da Solana. Via links a transação Solana a partir da linha "Settled in", e o explorador da Solana mostra suas unidades de computação. No código, obtenha as assinaturas da Solana por trás de um hash da EVM com `rome_solanaTxForEvmTx`, busque cada uma com o `getTransaction` e `maxSupportedTransactionVersion: 1`, e leia `computeUnitsConsumed`. Uma chamada iterativa tem uma transação por etapa. [Orçamento de computação](https://docs.rome.builders/pt-br/conceitos-principais/compute-budget.md) tem custos típicos por operação e os hábitos baratos que os reduzem: constantes para IDs de programa, derivações de PDA em cache, menos contas.

Dois comportamentos diferem da Ethereum e vale a pena conhecê-los agora:

* A Rome não tem medidor de gas por opcode. O gas que você passa para um `CALL` não é aplicado e não existe estipêndio de 2300 gas. Proteja-se explicitamente contra reentrância.
* `block.number` é o slot da Solana e `block.timestamp` é o relógio da Solana.

## Teste seus conhecimentos

Abra sua transação da lição 3 no explorador do Hadrian. Encontre o link da rede em [Hadrian](https://docs.rome.builders/pt-br/redes/hadrian.md) e as notas do explorador em [Via explorador](https://docs.rome.builders/pt-br/apps-na-rome/via.md).

Observe duas coisas:

1. A transação Solana que liquidou sua chamada, na linha "Settled in".
2. As unidades de computação que ela consumiu, no explorador da Solana.

Compare esse número com o orçamento de 1,4 milhão. Uma chamada simples usa uma pequena parte dele.

Depois responda:

<details>

<summary>1. Por que o proxy emula uma chamada antes de enviá-la?</summary>

A Solana precisa que cada conta seja nomeada com antecedência, e o proxy precisa saber se a chamada cabe em uma transação. A emulação encontra as contas tocadas, estima o gas e decide entre atômica ou iterativa.

</details>

<details>

<summary>2. Uma chamada faz uma CPI no caminho legado (as chamadas `CpiProgram` e `HelperProgram` da lição 5) e precisa de mais de 1,4 milhão de CU. O que acontece?</summary>

Ela não pode ser executada. CPIs do caminho legado são recusadas dentro de uma transação iterativa, então a chamada precisa caber em uma única transação atômica. Divida o trabalho em ações menores do usuário.

</details>

<details>

<summary>3. Por que a primeira transferência para um novo endereço é cara?</summary>

A Rome cria contas Solana para isso, e o aluguel dessas contas é cobrado do remetente como gas.

</details>

## Próximo

[5. Chame a Solana a partir do Solidity](https://docs.rome.builders/pt-br/rome-academy/05-call-solana-from-solidity.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/04-how-rome-runs-your-code.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.
