> 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/conceitos-principais/execution-model.md).

# Modelo de execução

Como a Rome EVM processa transações Ethereum na Solana — emulação por proxy, modos atômico (VmAt) vs. iterativo (VmIt) e o ciclo de vida completo da transação.

Rome EVM executa bytecode Solidity dentro de um programa on-chain da Solana. Esta página explica como as transações EVM são processadas.

## Ciclo de Vida da Transação

```
1. Usuário assina a transação EVM (MetaMask / ethers.js)
                    ↓
2. O Rome Proxy recebe via eth_sendRawTransaction
                    ↓
3. O Proxy emula a transação off-chain (emulador Mollusk SVM)
   → Estima o gas, verifica atomicidade, identifica as contas necessárias
                    ↓
4. O Proxy envolve a tx EVM como instrução(ões) da Solana
   → Se a tx couber em uma única tx da Solana → Atômica (VmAt)
   → Se a tx exceder o orçamento de CU → Iterativa (VmIt)
                    ↓
5. O validador da Solana executa a(s) instrução(ões)
   → O programa Rome EVM interpreta o bytecode EVM
   → Chamadas CPI para outros programas da Solana (se houver)
                    ↓
6. As mudanças de estado são confirmadas nas contas da Solana
                    ↓
7. Hercules indexa o evento → produz o bloco EVM
```

## Execução Atômica (VmAt)

O modo padrão. A transação EVM inteira é executada dentro de uma única transação da Solana.

**Máquina de estados:** `Bloquear → Inicializar → Executar → Confirmar → TransferirGas → Sair`

**Propriedades:**

* Execução tudo ou nada — se qualquer etapa falhar, toda a transação é revertida
* \~1,4 milhão de unidades de computação disponíveis por transação da Solana
* Adequado para transferências, chamadas simples de contrato, swaps e a maioria das operações DeFi
* Finalidade em menos de um segundo (tempo de bloco da Solana)

**Quando usado:** Selecionado automaticamente quando o emulador determina que a transação cabe no orçamento de computação de uma única transação da Solana.

## Execução Iterativa (VmIt)

Para operações intensivas em computação que excedem o orçamento de uma única transação. A execução EVM é dividida em várias transações da Solana.

**Como funciona:**

1. Cada etapa (uma transação da Solana) executa **tantos opcodes EVM quanto couberem em seu orçamento de computação** — um tamanho de etapa adaptativo, não uma contagem fixa
2. Após cada etapa, o estado da VM é serializado (formato Borsh) em uma `StateHolder` conta
3. A próxima etapa desserializa o estado e continua a execução
4. As contas envolvidas ficam travadas por TTL por **3–4 segundos** durante a execução em várias etapas; uma sessão tem limite de **160 etapas**; depois disso, a próxima etapa libera os bloqueios da sessão e a encerra sem confirmar nada

**Máquina de estados:** `FromStateHolder → Bloquear → Inicializar → Executar → Serializar → PróximaIteração → ... → Concluído`

**Bloqueio de contas:**

* Um **bloqueio exclusivo** por conta gerenciada (contas de saldo e armazenamento) — apenas uma sessão iterativa pode manter uma conta por vez; uma transação atômica que grave em uma conta bloqueada é recusada com `AccountLocked` até que o bloqueio expire, e o cliente reenviará
* **TTL:** 3 segundos, renovados a cada etapa (4 segundos quando a sessão acessa mais de 28 contas)
* **CPIs do tipo legacy-track são recusadas** dentro de uma transação iterativa (`CpiProhibitedInIterativeTx`); os efeitos do cached-track são preparados e confirmados no final

**Quando usado:** grandes implantações de contratos, pilhas de chamadas profundas, qualquer operação que exceda \~1,4 milhão de CU. Uma verificação de pareamento BN254 por si só não precisa disso; veja [Orçamento de Computação](https://docs.rome.builders/pt-br/conceitos-principais/compute-budget.md).

## Emulação

Antes de enviar uma transação para a Solana, o Proxy a emula off-chain usando o **emulador Mollusk SVM**. Isso:

1. Estima o consumo de gas
2. Determina se o modo atômico ou iterativo é necessário
3. Identifica todas as contas da Solana que a transação tocará
4. Valida que a transação não falhará on-chain

O emulador executa a mesma lógica EVM do programa on-chain — o `entrypoint!` macro garante tabelas de despacho idênticas tanto no programa quanto na base de código do emulador.

**Mollusk SVM** também pode executar programas BPF arbitrários da Solana durante a emulação, o que significa `eth_call` e `eth_estimateGas` que ele lida corretamente com chamadas CPI para SPL Token, Jupiter, Kamino etc.

## Mapeamento de Contas

Cada endereço Ethereum mapeia para um PDA da Solana:

```
Endereço Ethereum (H160, 20 bytes)
    ↓
PDA = findProgramAddress(
    [chain_id, "ACCOUN_SEED", H160, bump],
    ROME_EVM_PROGRAM_ID
)
    ↓
Conta da Solana (Pubkey, 32 bytes)
```

**Tipos de conta armazenados on-chain:**

| Tipo          | Seeds                                        | Finalidade                                      |
| ------------- | -------------------------------------------- | ----------------------------------------------- |
| Saldo         | `[chain, "ACCOUN_SEED", H160, bump]`         | Nonce, saldo, código do contrato                |
| Armazenamento | `[chain, "STORAGE", H160, slot_index, bump]` | Armazenamento do contrato (256 slots por conta) |
| TxHolder      | `[signer, "TX_HOLDER_SEED", index, bump]`    | Dados de transação em preparação (máx. 80 KB)   |
| StateHolder   | `[signer, "STATE_HOLDER_SEED", index, bump]` | Estado serializado da VM entre iterações        |

## Contas Holder

Rome envia transações **v1 da Solana**, que são limitadas a 4 KB (4.096 bytes) e 64 endereços. Transações EVM — especialmente implantações de contratos — podem ser muito maiores.

**Mecanismo de divisão:**

1. O SDK divide a transação codificada em RLP em partes
2. Cada parte é gravada em uma `TxHolder` conta via `TransmitTx` instruções
3. Quando todas as partes são preparadas, uma `DoTxHolder` instrução monta e executa a transação completa
4. Tamanho máximo do holder: **80 KB** por TxHolder

Isso é completamente transparente para o desenvolvedor — o SDK Rome cuida automaticamente da divisão e da remontagem.

## Tipos de Transação Suportados

| Tipo                  | EIP       | Descrição                                                                                                                                                                                                                                                                |
| --------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Legado                | —         | Transações tradicionais do Ethereum                                                                                                                                                                                                                                      |
| Lista de Acesso       | EIP-2930  | Padrões otimizados de acesso ao estado                                                                                                                                                                                                                                   |
| Taxa Dinâmica         | EIP-1559  | Taxa base + taxa de prioridade                                                                                                                                                                                                                                           |
| EIP-1559 não assinado | —         | Um `0x02`— corpo tipado sem assinatura secp256k1, autorizado em vez disso por uma assinatura Ed25519 de uma carteira Solana (o caminho da Solana; veja [Chamar EVM a partir da Solana](https://docs.rome.builders/pt-br/guias-do-desenvolvedor/call-evm-from-solana.md)) |
| Depósito              | Tipo 0x7E | Transações de depósito, por exemplo, liquidação de entrada de bridge                                                                                                                                                                                                     |

## Estado com Diário

O Rome EVM usa um modelo de estado com diário para gerenciar as mudanças de estado durante a execução:

* Todas as mudanças (nonce, saldo, armazenamento, código) são rastreadas em um `Diário`
* Operações aninhadas CALL/CREATE empilham frames de snapshot
* Em caso de revert: as entradas do diário voltam ao snapshot
* Em caso de sucesso: as mudanças são confirmadas nas contas da Solana
* Instruções CPI não-EVM são executadas imediatamente (as próprias garantias de atomicidade da Solana asseguram a correção)

## O que vem a seguir

* [Orçamento de Computação](https://docs.rome.builders/pt-br/conceitos-principais/compute-budget.md) — custos de CU e estratégias de otimização
* [Restrições](https://docs.rome.builders/pt-br/conceitos-principais/constraints.md) — limites e fronteiras importantes


---

# 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/conceitos-principais/execution-model.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.
