> 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/referencia/json-rpc.md).

# Suporte a JSON-RPC

Métodos Ethereum JSON-RPC suportados pelos endpoints EVM da Rome, além de comportamentos específicos da Rome — para Foundry, Hardhat, ethers, viem e MetaMask.

Os endpoints EVM do Rome falam o Ethereum JSON-RPC padrão. Foundry, Hardhat, ethers, viem e MetaMask funcionam com o Rome da mesma forma que em qualquer cadeia EVM. Esta página lista o que é suportado e os poucos comportamentos específicos do Rome que vale a pena conhecer.

## Métodos suportados

**Núcleo (estado e execução):** `eth_chainId`, `eth_blockNumber`, `eth_getBalance`, `eth_getCode`, `eth_getStorageAt`, `eth_getTransactionCount`, `eth_call`, `eth_estimateGas`, `eth_gasPrice`, `eth_maxPriorityFeePerGas`, `eth_feeHistory`.

**Blocos e transações:** `eth_getBlockByNumber`, `eth_getBlockByHash`, `eth_getBlockReceipts`, `eth_getTransactionByHash`, `eth_getTransactionReceipt`, `eth_sendRawTransaction`, variantes por índice/contagem de bloco.

**Logs e filtros:** `eth_getLogs`, `eth_newFilter`, `eth_newBlockFilter`, `eth_getFilterChanges`, `eth_getFilterLogs`, `eth_uninstallFilter`.

**Assinaturas WebSocket:** `eth_subscribe` / `eth_unsubscribe` (`newHeads`, `logs`). Veja [Assinaturas WebSocket](https://docs.rome.builders/pt-br/guias-do-desenvolvedor/websocket-subscriptions.md).

**Rede / web3:** `net_version`, `net_listening`, `net_peerCount`, `web3_clientVersion`.

**Pequenos métodos de introspecção:** `rpc_modules` (lista `debug`, `eth`, `net`, `rome`, `rpc`, `txpool`, `web3`), `eth_syncing` (sempre `false`), `eth_accounts` (sempre uma lista vazia), `eth_getUncleCountByBlockNumber`, `eth_getUncleCountByBlockHash`, `eth_getUncleByBlockNumberAndIndex` e `eth_getUncleByBlockHashAndIndex` (não há uncles, então as contagens são `0x0` e as consultas retornam `null`), `eth_newPendingTransactionFilter` (aceito, mas nunca retorna hashes porque não há mempool público), e `txpool_status`, que sempre retorna `{"pending":"0x0","queued":"0x0"}` porque não há mempool público.

**Rastreamento:** `debug_traceRomeTransaction` recebe um hash de transação e retorna a divisão por subchamada e por CPI de uma transação que agrupa várias chamadas em um único lote. Transações comuns retornam `null`, assim como um hash desconhecido ou ainda não indexado.

### Não suportado

`debug_traceTransaction` / `trace_*` (rastreamento de transações no estilo Ethereum; eles retornam `-32601`), `eth_getProof`, `eth_createAccessList`, `eth_blobBaseFee` (não há transações blob), e os `txpool_*` métodos, exceto `txpool_status` (sem mempool público). `newPendingTransactions` as assinaturas são aceitas, mas nunca emitem.

## Métodos de extensão do Rome

Além do RPC padrão do Ethereum, o proxy expõe `rome_*` métodos:

| Método                            | Finalidade                                                                                                                                                                                                                             |
| --------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `rome_emulateTx`                  | Emula uma transação fora da cadeia (retorna o resultado de execução no Solana)                                                                                                                                                         |
| `rome_emulateTxWithPayer`         | Emula contra um pagador específico                                                                                                                                                                                                     |
| `rome_emulateCallAccounts`        | Emula e retorna as contas do Solana tocadas por uma chamada                                                                                                                                                                            |
| `rome_emulateRegRollup`           | Emula um registro de rollup                                                                                                                                                                                                            |
| `rome_getResources`               | Reporta o estado do pool de recursos do proxy (pagadores, detentores)                                                                                                                                                                  |
| `rome_mintId`                     | Resolve o mint SPL por trás de um wrapper ERC-20                                                                                                                                                                                       |
| `rome_buildInfo`                  | Informações de build do proxy + do programa on-chain                                                                                                                                                                                   |
| `rome_isCompatible`               | Verifica a compatibilidade entre proxy/programa                                                                                                                                                                                        |
| `rome_solanaTxForEvmTx`           | Obtém a(s) transação(ões) do Solana para um hash de tx EVM                                                                                                                                                                             |
| `rome_sendUnsignedTransaction`    | Submete uma transação não assinada (fluxos de remetente sintético)                                                                                                                                                                     |
| `rome_composeUnsignedAtomicV1`    | Compõe uma transação Solana v1 para um corpo EIP-1559 não assinado autorizado pela assinatura Ed25519 de uma carteira Solana; a carteira a assina e o app a transmite. Recusa quando a chamada não cabe em uma única transação atômica |
| `rome_composeUnsignedIterativeV1` | O mesmo, mas retorna cada etapa (atômica se couber, senão as etapas iterativas); a carteira assina cada uma e as envia com `rome_submitSignedV1Plan`                                                                                   |
| `rome_submitSignedV1Plan`         | Transmite um plano assinado (até 64 etapas); o proxy é apenas transporte, a carteira continua como pagadora de taxas                                                                                                                   |
| `rome_relayUnsignedV1`            | Uma única assinatura da carteira, o pagador do proxy conduz as etapas; o sintético paga o gás do Rome (carregue-o primeiro com `rome_composeExternalDepositV1`). Retorna o hash da tx EVM                                              |
| `rome_composeExternalDepositV1`   | Uma transação assinada pela carteira que credita o saldo nativo de gás do sintético a partir dos tokens da carteira                                                                                                                    |

## Comportamentos específicos do Rome

### O gás é derivado do Solana — estime, não fixe em código

O Rome mede a execução em unidades de computação do Solana, expostas como gás EVM. A maior parte do custo de uma escrita é criar contas Solana: um destinatário que nunca foi usado, uma nova conta de token, um contrato implantado. Essas contas fazem parte da estimativa. Consequências práticas:

* **Use `eth_estimateGas`, e nunca fixe em código `21000`.** Ferramentas padrão (`forge create`, `cast`, Hardhat, ethers, viem, MetaMask) já a chama e obtém um valor utilizável. Para chamadas que tocam programas do Solana, adicione uma margem (o `submitRomeTx` SDK aplica 1,3x de folga) e defina um teto de gás se a própria estimativa reverter. Um `21000` limite fixo falha sempre que a escrita cria contas, por exemplo uma transferência para um endereço que nunca foi usado.
* **O Rome cobra o gás realmente usado.** Nas medições abaixo, o gás usado nunca foi maior que a estimativa, então uma estimativa superior ao trabalho realizado não custa a diferença para você.
* **Deixe a margem que sua ferramenta adiciona.** O estado pode mudar entre a estimativa e o momento em que a transação é confirmada, e a estimativa para uma chamada que faz CPIs no Solana pode sair baixa. O `submitRomeTx` SDK aplica uma margem de 1,3x à estimativa.

Medido no Hadrian, com o preço do gás em cerca de 10,4 gwei na época:

| Escrita                                                   | `eth_estimateGas` | Gás usado |
| --------------------------------------------------------- | ----------------- | --------- |
| Transferência nativa para um endereço nunca usado         | 1,086,961         | 1,086,961 |
| Transferência nativa para um endereço existente           | 21,000            | 10,001    |
| Transferência de wUSDC para um endereço nunca usado       | 2,544,921         | 2,544,921 |
| Converter gás em wUSDC (`withdraw_to_ata`)                | 21,000            | 10,001    |
| Concessão do wrapper (`approve_spl` no precompile Helper) | 21,000            | 10,001    |
| Implantar um contrato de 10 bytes                         | 1,147,921         | 1,147,921 |

Estas são medições únicas em uma cadeia, não limites. Os números dependem de quais contas uma chamada precisa criar, então estime cada escrita em vez de copiá-los.

### `forge script --broadcast` precisa de `--skip-simulation`

`forge script` define seu limite de gás de broadcast a partir de uma **local** simulação, que fornece gás abaixo do necessário em relação ao modelo de gás do Rome. Adicione `--skip-simulation` para que o Foundry use o `eth_estimateGas` da cadeia em vez disso:

```bash
forge script script/Deploy.s.sol:Deploy \
  --rpc-url <RPC> --private-key $PRIVATE_KEY --broadcast --skip-simulation
```

`forge create`, `cast send`, e Hardhat, não são afetados — eles já estimam on-chain.

### `eth_getLogs` tem limite de intervalo (\~12.000 blocos)

Assim como Infura, Alchemy e outros RPCs de produção, `eth_getLogs` rejeita intervalos de blocos excessivamente amplos (erro `-32005`). Limite suas consultas:

```javascript
const latest = await provider.getBlockNumber();
const logs = await contract.queryFilter(filter, latest - 5000, latest);
```

Um `queryFilter` sem intervalo varre todo o histórico e excederá o limite — passe um `fromBlock`/`toBlock`. Asserções de eventos baseadas em receipt (por exemplo, aguardar uma tx e ler seus logs) não são afetadas.

### Taxas

`eth_gasPrice` retorna o preço real, derivado de oráculo; carteiras (incluindo MetaMask) o usam e exibem taxas corretas. Os campos de taxa enviados são aceitos de forma permissiva — tanto transações legacy quanto EIP-1559 são processadas com os padrões das ferramentas comuns.


---

# 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/referencia/json-rpc.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.
