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

# Soporte de JSON-RPC

Métodos JSON-RPC de Ethereum compatibles con los endpoints de Rome EVM, además de comportamientos específicos de Rome: para Foundry, Hardhat, ethers, viem y MetaMask.

Los extremos EVM de Rome hablan el JSON-RPC estándar de Ethereum. Foundry, Hardhat, ethers, viem y MetaMask funcionan contra Rome igual que en cualquier cadena EVM. Esta página enumera lo que es compatible y los pocos comportamientos específicos de Rome que conviene conocer.

## Métodos compatibles

**Núcleo (estado y ejecución):** `eth_chainId`, `eth_blockNumber`, `eth_getBalance`, `eth_getCode`, `eth_getStorageAt`, `eth_getTransactionCount`, `eth_call`, `eth_estimateGas`, `eth_gasPrice`, `eth_maxPriorityFeePerGas`, `eth_feeHistory`.

**Bloques y transacciones:** `eth_getBlockByNumber`, `eth_getBlockByHash`, `eth_getBlockReceipts`, `eth_getTransactionByHash`, `eth_getTransactionReceipt`, `eth_sendRawTransaction`, variantes por índice/número de bloque.

**Registros y filtros:** `eth_getLogs`, `eth_newFilter`, `eth_newBlockFilter`, `eth_getFilterChanges`, `eth_getFilterLogs`, `eth_uninstallFilter`.

**Suscripciones WebSocket:** `eth_subscribe` / `eth_unsubscribe` (`newHeads`, `logs`). Véase [Suscripciones WebSocket](https://docs.rome.builders/es/guias-para-desarrolladores/websocket-subscriptions.md).

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

**Métodos pequeños de introspección:** `rpc_modules` (enumera `debug`, `eth`, `net`, `rome`, `rpc`, `txpool`, `web3`), `eth_syncing` (siempre `false`), `eth_accounts` (siempre una lista vacía), `eth_getUncleCountByBlockNumber`, `eth_getUncleCountByBlockHash`, `eth_getUncleByBlockNumberAndIndex` y `eth_getUncleByBlockHashAndIndex` (sin tíos, así que los conteos son `0x0` y las búsquedas devuelven `null`), `eth_newPendingTransactionFilter` (aceptado, pero nunca devuelve hashes porque no hay mempool pública), y `txpool_status`, que siempre devuelve `{"pending":"0x0","queued":"0x0"}` porque no hay mempool pública.

**Trazado:** `debug_traceRomeTransaction` toma un hash de transacción y devuelve el desglose por subllamada y por CPI de una transacción que agrupa varias llamadas en un solo lote. Las transacciones ordinarias devuelven `null`, al igual que un hash desconocido o que aún no está indexado.

### No compatible

`debug_traceTransaction` / `trace_*` (trazado de transacciones al estilo Ethereum; devuelven `-32601`), `eth_getProof`, `eth_createAccessList`, `eth_blobBaseFee` (sin transacciones blob), y los `txpool_*` métodos distintos de `txpool_status` (sin mempool pública). `newPendingTransactions` Las suscripciones se aceptan pero nunca emiten.

## Métodos de extensión de Rome

Más allá del RPC estándar de Ethereum, el proxy expone `rome_*` métodos:

| Método                            | Propósito                                                                                                                                                                                                                                       |
| --------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `rome_emulateTx`                  | Emula una transacción fuera de la cadena (devuelve el resultado de ejecución de Solana)                                                                                                                                                         |
| `rome_emulateTxWithPayer`         | Emula contra un pagador específico                                                                                                                                                                                                              |
| `rome_emulateCallAccounts`        | Emula y devuelve las cuentas de Solana que toca una llamada                                                                                                                                                                                     |
| `rome_emulateRegRollup`           | Emula un registro de rollup                                                                                                                                                                                                                     |
| `rome_getResources`               | Informa el estado del conjunto de recursos del proxy (pagadores, titulares)                                                                                                                                                                     |
| `rome_mintId`                     | Resuelve el mint SPL detrás de un envoltorio ERC-20                                                                                                                                                                                             |
| `rome_buildInfo`                  | Información de compilación del proxy + del programa on-chain                                                                                                                                                                                    |
| `rome_isCompatible`               | Comprueba la compatibilidad entre proxy y programa                                                                                                                                                                                              |
| `rome_solanaTxForEvmTx`           | Obtén la(s) transacción(es) de Solana para un hash de tx EVM                                                                                                                                                                                    |
| `rome_sendUnsignedTransaction`    | Envía una transacción sin firmar (flujos de remitente sintético)                                                                                                                                                                                |
| `rome_composeUnsignedAtomicV1`    | Compone una transacción Solana v1 para un cuerpo EIP-1559 sin firmar, autorizado por la firma Ed25519 de una wallet de Solana; la wallet la firma y la app la transmite. Se rechaza cuando la llamada no encaja en una sola transacción atómica |
| `rome_composeUnsignedIterativeV1` | Lo mismo, pero devuelve cada tramo (atómico si encaja; si no, los tramos iterativos); la wallet firma cada uno y los envía con `rome_submitSignedV1Plan`                                                                                        |
| `rome_submitSignedV1Plan`         | Transmite un plan firmado (hasta 64 tramos); el proxy es solo transporte, la wallet sigue siendo el pagador de comisiones                                                                                                                       |
| `rome_relayUnsignedV1`            | Una sola firma de wallet, el pagador del proxy impulsa los tramos; el sintético paga el gas de Rome (cárgalo primero con `rome_composeExternalDepositV1`). Devuelve el hash de la tx EVM                                                        |
| `rome_composeExternalDepositV1`   | Una transacción firmada por la wallet que acredita el saldo nativo de gas del sintético desde los tokens de la wallet                                                                                                                           |

## Comportamientos específicos de Rome

### El gas se deriva de Solana: estímalo, no lo codifiques a mano

Rome mide la ejecución en unidades de cómputo de Solana, expuestas como gas EVM. La mayor parte de lo que cuesta una escritura es crear cuentas de Solana: un destinatario que nunca se ha usado, una nueva cuenta de tokens, un contrato desplegado. Esas cuentas forman parte de la estimación. Consecuencias prácticas:

* **Usa `eth_estimateGas`, y nunca lo codifiques a mano `21000`.** Las herramientas estándar (`forge create`, `cast`, Hardhat, ethers, viem, MetaMask) ya lo llaman y obtienen un valor utilizable. Para llamadas que tocan programas de Solana, añade un margen (el SDK de `submitRomeTx` rellena 1.3x) y fija un techo de gas si la propia estimación revierte. Un `21000` límite codificado a mano falla siempre que la escritura crea cuentas, por ejemplo una transferencia a una dirección que nunca se ha usado.
* **Rome cobra el gas realmente usado.** En las mediciones de abajo, el gas usado nunca fue mayor que la estimación, así que una estimación superior al trabajo realizado no te cuesta la diferencia.
* **Deja el margen que añade tu herramienta.** El estado puede cambiar entre la estimación y el momento en que la transacción se confirma, y la estimación de una llamada que realiza CPI de Solana puede quedar corta. El `submitRomeTx` rellena la estimación por 1.3x como margen.

Medido en Hadrian, con el precio del gas en unos 10.4 gwei en ese momento:

| Escritura                                                       | `eth_estimateGas` | Gas usado |
| --------------------------------------------------------------- | ----------------- | --------- |
| Transferencia nativa a una dirección nunca usada                | 1,086,961         | 1,086,961 |
| Transferencia nativa a una dirección existente                  | 21,000            | 10,001    |
| Transferencia de wUSDC a una dirección nunca usada              | 2,544,921         | 2,544,921 |
| Envolver gas en wUSDC (`withdraw_to_ata`)                       | 21,000            | 10,001    |
| Concesión del wrapper (`approve_spl` en el precompilado Helper) | 21,000            | 10,001    |
| Desplegar un contrato de 10 bytes                               | 1,147,921         | 1,147,921 |

Estas son mediciones únicas en una sola cadena, no límites. Los números dependen de qué cuentas tenga que crear una llamada, así que estima cada escritura en lugar de copiarlos.

### `forge script --broadcast` necesita `--skip-simulation`

`forge script` establece su límite de gas de broadcast a partir de una simulación **local** , que asigna menos de lo necesario frente al modelo de gas de Rome. Añade `--skip-simulation` para que Foundry use el `eth_estimateGas` de la cadena en su lugar:

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

`forge create`, `cast send`, y Hardhat no se ven afectados: ya estiman en cadena.

### `eth_getLogs` está limitado por rango (\~12.000 bloques)

Como Infura, Alchemy y otros RPC de producción, `eth_getLogs` rechaza rangos de bloques demasiado amplios (error `-32005`). Limita tus consultas:

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

Una app `queryFilter` sin rango escanea todo el historial y superará el límite — pasa un `fromBlock`/`toBlock`. Las aserciones de eventos basadas en recibos (por ejemplo, esperar una tx y leer sus logs) no se ven afectadas.

### Comisiones

`eth_gasPrice` devuelve el precio real derivado del oráculo; las wallets (incluida MetaMask) lo usan y muestran comisiones correctas. Los campos de comisión enviados se aceptan de forma permisiva: tanto las transacciones legacy como las EIP-1559 llegan con los valores predeterminados de las herramientas estándar.


---

# 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/es/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.
