> 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/primeiros-passos-1/key-concepts.md).

# Conceitos-chave

Terminologia essencial da Solana e da Rome EVM para desenvolvedores — programs, accounts, PDAs, CPI, tokens SPL e execução atômica vs. iterativa.

Terminologia e conceitos essenciais para construir sobre o Protocolo Rome.

## Conceitos da Solana

**Programa** — O equivalente da Solana a um contrato inteligente. Programas são executáveis sem estado implantados on-chain. O Rome EVM em si é um programa da Solana.

**Conta** — Todo o estado na Solana vive em contas. Cada conta tem um proprietário (programa), um saldo (lamports) e dados. Diferentemente da Ethereum, código e estado são armazenados em contas separadas.

**PDA (Endereço Derivado de Programa)** — Um endereço determinístico derivado de seeds e de um ID de programa. PDAs permitem que programas "possuam" contas sem uma chave privada. Rome usa PDAs para mapear endereços Ethereum para contas da Solana.

**CPI (Invocação entre Programas)** — Um programa da Solana chamando outro dentro da mesma transação. É assim que contratos do Rome EVM interagem com Jupiter, Kamino, SPL Token e outros programas da Solana.

**SPL Token** — O programa padrão de tokens da Solana. Equivalente ao ERC-20 na Ethereum. Todos os tokens fungíveis na Solana (USDC, SOL etc.) são tokens SPL.

**Token-2022** — O programa de tokens SPL de próxima geração, com extensões como Transfer Hooks, Transferências Confidenciais e Delegados Permanentes.

**Transfer Hook** — Uma extensão do Token-2022 que invoca um programa em cada `transfer_checked` chamada.

**ATA (Conta de Token Associada)** — Uma conta de token determinística para um par específico de carteira + mint. Cada usuário tem uma ATA por token que mantém.

**Lamports** — A menor unidade de SOL. 1 SOL = 1.000.000.000 lamports (10^9).

**Unidades de Computação (CU)** — O equivalente do gás da Ethereum na Solana. Cada transação tem um orçamento de computação (padrão \~200 mil CU, máximo \~1,4 milhão de CU). As operações consomem CU.

## Conceitos Rome

**Programa Rome EVM** — O programa da Solana que contém o interpretador de bytecode da EVM. Implantado em um ID de programa específico por ambiente.

**ID da cadeia** — Cada aplicação no Rome recebe seu próprio chain ID da EVM. Isso cria ambientes EVM isolados que compartilham o mesmo estado subjacente da Solana.

**Execução Atômica (VmAt)** — Uma transação EVM executada inteiramente dentro de uma única transação Solana. Usada para a maioria das operações.

**Execução Iterativa (VmIt)** — Uma transação EVM dividida em várias transações Solana, com cada etapa empacotando o máximo de opcodes que couber no orçamento de computação de uma transação Solana (adaptativo, não uma contagem fixa). Usada para operações intensivas em computação, como emparelhamento BN254.

**Conta armazenadora** — Um buffer on-chain que armazena transações EVM grandes (até 80 KB) que excedem o limite de tamanho de 4 KB de transações da Solana (v1). Gerenciado transparentemente pelo SDK.

**StateHolder** — Uma conta on-chain que armazena o estado serializado da VM entre etapas de execução iterativas.

**Proxy Rome** — O servidor JSON-RPC (porta 9090) que traduz chamadas da API Ethereum em transações Solana. Seu MetaMask e Hardhat se conectam aqui.

**Hércules** — O indexador de blocos que monitora eventos da Rome EVM na Solana e produz dados de blocos compatíveis com Ethereum.

**Pagador** — Um par de chaves da Solana que assina e paga por transações Solana em nome de usuários da EVM. Gerenciado pelo Proxy via pools de pagadores.

## Conceitos de Tokens

**SPL\_ERC20 / SPL\_ERC20\_cached** — Contratos wrapper ERC-20 que representam um token SPL dentro do Rome EVM. Para uma wallet, o wrapper lê o saldo diretamente da conta de token SPL subjacente. Tokens mantidos por um contrato ficam na própria conta de token em custódia do wrapper e são rastreados no storage do wrapper (veja [Integrar um programa Solana](https://docs.rome.builders/pt-br/guias-do-desenvolvedor/integrate-solana-program.md) ). A factory implanta a variante em cache hoje.

**ERC20SPLFactory** — Um contrato factory que implanta wrappers para qualquer token SPL.

**Registro** — Wrappers canônicos, tokens de gás e a configuração da bridge são curados off-chain no [rome-protocol/registry](https://github.com/rome-protocol/rome-registry); não há um contrato de registro de tokens on-chain. Isso mantém cada ativo mapeado para um único mint SPL canônico.

## Precompiles

**Pré-compilados padrão da Ethereum** — ecrecover (0x01), SHA-256 (0x02), RIPEMD-160 (0x03), identity (0x04), modexp (0x05), BN254 ecAdd/ecMul/ecPairing (0x06-0x08), Blake2f (0x09).

**Pré-compilado do Sistema** (`0xFF...07` ) — derivação de PDA e conversão de base58 a partir de Solidity.

**Pré-compilado CpiProgram** (`0xFF...08` ) — invocação entre programas (`invoke` / `invoke_signed` ) além de atalhos de leitura entre estados.

**Pré-compilado HelperProgram** (`0xFF...09` ) — criação de ATA/PDA, transferências SPL e conversão gás↔lamports; a principal superfície para operações SPL assinadas por PDA do usuário.

**Pré-compilado de Saque** (`0x42...16` ) — sacar SOL ou tokens SPL da EVM de volta para a Solana.

Uma família de trilhas em cache (`0xff…04/05/06/0b` ) espelha estas para leituras eficientes em CU; um contrato usa uma trilha de forma consistente.

## Tipos de Transação

O SDK em Rust constrói três tipos de transação. Rome liquida cada uma delas na Solana.

**Uma transação EVM (`RheaTx`)** — Uma única transação EVM em uma cadeia Rome. O tipo mais comum.

**Várias transações EVM (`RemusTx`)** — Transações EVM em diferentes cadeias Rome, executadas juntas em uma única transação Solana. Se qualquer uma falhar, todas revertem.

**Transações EVM mais instruções Solana (`RomulusTx`)** — Transações EVM e instruções nativas da Solana em uma única transação atômica da Solana, para que Solidity e programas da Solana sejam executados juntos ou não sejam executados de forma alguma.

## O que vem a seguir

* [Modelo de execução](https://docs.rome.builders/pt-br/conceitos-principais/execution-model.md) — um mergulho profundo em como as transações EVM executam na Solana
* [Interoperação de Tokens](https://docs.rome.builders/pt-br/conceitos-principais/token-interop.md) — como ERC-20 e tokens SPL interagem
* [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/primeiros-passos-1/key-concepts.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.
