> 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 endpoints 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 qué está soportado 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/conteo de bloques. **Logs y filtros:** `eth_getLogs`, `eth_newFilter`, `eth_newBlockFilter`, `eth_getFilterChanges`, `eth_getFilterLogs`, `eth_uninstallFilter`. **Suscripciones de WebSocket:** `eth_subscribe` / `eth_unsubscribe` (`newHeads`, `logs`). Consulta [Suscripciones de WebSocket](/es/guias-para-desarrolladores/websocket-subscriptions.md). **Red / web3:** `net_version`, `net_listening`, `net_peerCount`, `web3_clientVersion`. **Métodos de introspección menores:** `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` (no hay ommers, así que los conteos son `0x0` y las búsquedas devuelven `null`), `eth_newPendingTransactionFilter` (se acepta, pero nunca devuelve hashes porque no hay mempool público), y `txpool_status`que siempre devuelve `{"pending":"0x0","queued":"0x0"}` porque no hay mempool público. **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`, 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` (no hay transacciones blob), y los `txpool_*` métodos distintos de `txpool_status` (no hay mempool público). `newPendingTransactions` las suscripciones se aceptan pero nunca emiten. ## Métodos de extensión de Rome Además del RPC estándar de Ethereum, el proxy expone `rome_*` métodos: | Método | Propósito | | --------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `rome_emulateTx` | Emula una transacción fuera de cadena (devuelve el resultado de ejecución de Solana) | | `rome_emulateTxWithPayer` | Emula frente a 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 del estado del pool 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 en cadena | | `rome_isCompatible` | Comprueba la compatibilidad entre proxy/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 cartera Solana; la cartera la firma y la app la transmite. Se rechaza cuando la llamada no cabe en una única transacción atómica | | `rome_composeUnsignedIterativeV1` | Lo mismo, pero devuelve cada tramo (atómica si cabe, de lo contrario los tramos iterativos); la cartera 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 cartera sigue siendo la pagadora de comisiones | | `rome_relayUnsignedV1` | Una firma de la cartera, el pagador del proxy impulsa los tramos; el sintético paga el gas de Rome (fináncialo primero con `rome_composeExternalDepositV1`). Devuelve el hash de la tx EVM | | `rome_composeExternalDepositV1` | Una transacción firmada por la cartera que abona al sintético saldo nativo de gas desde los tokens de la cartera | ## Comportamientos específicos de Rome ### El gas se deriva de Solana: estima, 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 cuenta de tokens nueva, 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 llama y obtiene un valor utilizable. Para llamadas que tocan programas de Solana, añade un margen (el SDK `submitRomeTx` lo amplía 1,3x) y establece 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 hace CPI de Solana puede salir baja. La del SDK `submitRomeTx` amplía la estimación 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 | | Convertir 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 puntuales 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 se queda corta frente al modelo de gas de Rome. Añade `--skip-simulation` para que Foundry use el de la cadena `eth_estimateGas` en su lugar: ```bash forge script script/Deploy.s.sol:Deploy \\ --rpc-url --private-key $PRIVATE_KEY --broadcast --skip-simulation ``` `forge create`, `cast send`y Hardhat no se ven afectados — ya estiman en cadena. ### `eth_getLogs` tiene un límite de rango (\~12.000 bloques) Al igual que 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 explora todo el historial y superará el límite — pasa un `fromBlock`/`toBlock`. Las aserciones de eventos basadas en recibos (p. ej., esperar una tx y leer sus logs) no se ven afectadas. ### Comisiones `eth_gasPrice` devuelve el precio real derivado del oráculo; las carteras (incluida MetaMask) lo usan y muestran comisiones correctas. Los campos de comisiones 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=&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.