> 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/primeros-pasos-1/architecture.md).

# Arquitectura

Cómo encajan los componentes de Rome: ejecución EVM dentro de un programa de Solana.

Rome incrusta un intérprete de bytecode de EVM dentro de un programa en cadena de Solana. En el carril de clave EVM, los usuarios envían transacciones EVM firmadas al Rome Proxy a través del JSON-RPC estándar de Ethereum. El proxy las envía al programa Rome EVM en Solana. Una transacción EVM puede requerir varias transacciones de Solana para escribir fragmentos en cuentas holder o ejecutar una ejecución iterativa. En el carril v1 de clave Solana, el proxy compone la transacción. La cartera de Solana la firma y la envía directamente al RPC de Solana. No hay una capa de ejecución separada que mantener sincronizada — el estado de EVM *es* estado de Solana.

## Descripción general del sistema

<figure><img src="https://1082203750-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F671PKS8ZQSNqtoC8PGvz%2Fuploads%2Fgit-blob-4d7d386c95b500079204f3dea2103d9759c5de8f%2Farchitecture.svg?alt=media" alt="EVM wallet and Solana wallet connected to Rome Proxy with its emulator. The Solana cluster holds the Rome EVM program, per-chain state, external-authority PDA, token accounts, Solana programs and holder accounts. Hercules feeds blocks, receipts and logs back to the proxy."><figcaption></figcaption></figure>

## Componentes

### Programa Rome EVM (en cadena)

El núcleo de Rome: un programa BPF de Solana que contiene un intérprete completo de bytecode de EVM (un fork de SputnikVM). Hace lo siguiente:

* Recibe transacciones EVM firmadas y cuerpos EIP-1559 sin firmar como instrucciones de Solana. Una clave de Solana autoriza un cuerpo sin firmar mediante la firma del pagador de comisiones de Solana o una instrucción verificador Ed25519
* Ejecuta bytecode de Solidity dentro del entorno de ejecución de Solana
* Mapea cada dirección de Ethereum (H160) a una PDA de balance por cadena que contiene su nonce, saldo nativo y código. Las PDAs de almacenamiento separadas están asociadas con la PDA de balance. Cada dirección también tiene una dirección derivada del programa para la autoridad sobre llamadas de Solana, llamada su **PDA de autoridad externa**Esta PDA se comparte entre todas las cadenas del programa. Posee las cuentas de tokens SPL de la dirección y firma sus invocaciones entre programas (CPI)
* Expone precompilaciones para llamar a Solana (CPI, System, Helper, Withdraw) junto con las precompilaciones de Ethereum. La familia en caché añade SystemCached (`0xff…04`), SplCached (`0xff…05`), ASplCached (`0xff…06`) y WithdrawCached (`0xff…0b`). La fábrica despliega envoltorios en esta vía en caché
* Almacena el estado de EVM (saldos, nonce, código, almacenamiento) como datos de cuenta de Solana
* Un solo programa Rome EVM aloja muchos IDs de cadena. El ID de cadena forma parte de las direcciones de las PDAs de balance y almacenamiento, no de la PDA de autoridad externa

### Rome Proxy (servidor JSON-RPC)

Rome Proxy es un servidor JSON-RPC estándar de Ethereum. Los usuarios se conectan a `https://hadrian.testnet.romeprotocol.xyz/` para Hadrian (testnet) y `https://rubicon.mainnet.romeprotocol.xyz/` para Rubicon (mainnet). Traduce las llamadas de la API de Ethereum en actividad de Solana:

* `eth_sendRawTransaction` → enviar una o más transacciones v1 de Solana: atómicas `DoTx`, fragmentos de holder (`TransmitTx`) `DoTxHolder`, o tramos iterativos. Un pagador agrupado firma y paga SOL. Un receptor de comisiones agrupado cobra el gas del usuario
* `eth_call` → ejecutar el intérprete de EVM de forma nativa en el emulador sobre cuentas de Solana reales leídas por RPC. Mollusk ejecuta los programas de Solana alcanzados mediante CPI. También ejecuta el programa Rome EVM cuando el proxy mide unidades de cómputo
* `eth_estimateGas` → simular para la estimación de gas. Una unidad de gas equivale a un lamport de costo de Solana. La estimación nunca es inferior a 21.000
* `eth_getBalance`, `eth_getCode`, `eth_getTransactionCount`, `eth_getStorageAt` → leer cuentas de Solana en vivo a través del emulador. `eth_getBlockByNumber`, los recibos y los logs provienen de Hercules

También expone extensiones de Rome: `rome_emulateTx`, `rome_emulateRegRollup`, `rome_mintId`, `rome_buildInfo` y `rome_getResources`. Los métodos de la billetera de Solana incluyen `rome_emulateCallAccounts`, `rome_composeUnsignedAtomicV1`, `rome_composeUnsignedIterativeV1`, `rome_submitSignedV1Plan`, `rome_relayUnsignedV1`, `rome_composeExternalDepositV1` y `rome_sendUnsignedTransaction`. El proxy también expone `rome_solanaTxForEvmTx`.

### Hercules (indexador)

Hercules vigila el programa Rome EVM en Solana y reconstruye bloques compatibles con Ethereum en PostgreSQL. Estos contienen transacciones, recibos, logs y cambios de estado. En las cadenas públicas funciona en modo alineado con slots, por lo que un número de bloque se corresponde con un slot de Solana y el mismo slot produce el mismo bloque en cualquier indexador. El proxy sirve estos bloques a wallets y exploradores.

Hercules indexa bloques confirmados. Vuelve a verificar cada bloque al estar finalizado y lo recarga si el hash del bloque cambió. El [Vía explorador](https://docs.rome.builders/es/apps-en-rome/via.md) lee los datos de Hercules.

### Precompilados

Rome implementa ecrecover, SHA-256, RIPEMD-160, identity, las operaciones de la curva BN254 y blake2f con semántica de Ethereum, excepto por los datos de error de BN254 y blake2f. Una llamada fallida a BN254 o blake2f devuelve el `Error(string)` datos de revert en lugar de un búfer vacío. Modexp (`0x05`) está deshabilitado y revierte con `"la llamada big_mod_exp está deshabilitada"`. blake2f rechaza más de 1.000.000 de rondas, lo que Ethereum permite.

Las precompilaciones no EVM interactúan con Solana: **CpiProgram** (`0xFF…08`, CPI arbitraria), **System** (`0xFF…07`, derivación de PDA y utilidades base58), **HelperProgram** (`0xFF…09`, creación de ATA/PDA, transferencias SPL, gas↔lamports), y **Withdraw** (`0x42…16`). La familia en caché es **SystemCached** (`0xff…04`), **SplCached** (`0xff…05`), **ASplCached** (`0xff…06`y **WithdrawCached** (`0xff…0b`). Las CPI heredadas se ejecutan inmediatamente y solo en transacciones atómicas. Las CPI en caché se registran durante la ejecución y se envían al confirmarse. Revierte con la EVM. Pueden ejecutarse en transacciones iterativas. Consulte la [Direcciones de contrato](https://docs.rome.builders/es/referencia/contract-addresses.md) referencia para la tabla completa.

## Modos de ejecución

Rome ejecuta una transacción EVM de una de dos maneras:

### Atómico (VmAt)

Una sola transacción de Solana. Toda la transacción EVM se ejecuta dentro del presupuesto de cómputo de una transacción de Solana (\~1,4 M de unidades de cómputo). Se usa para la mayoría de operaciones: transferencias, llamadas ordinarias a contratos, swaps.

### Iterativo (VmIt)

Para trabajo que excede el presupuesto de una sola transacción. La ejecución se divide en varias transacciones de Solana:

1. Cada paso (una transacción de Solana) ejecuta tantos opcodes de EVM como quepan en su presupuesto de cómputo — el tamaño del paso es adaptativo, no fijo
2. El estado de la VM se serializa con Borsh en una `StateHolder` cuenta entre pasos
3. Las cuentas se bloquean con TTL durante unos segundos durante la ejecución

El proxy recurre a la ejecución iterativa cuando las unidades de cómputo, el heap o el recuento de instrucciones no caben en una sola transacción de Solana. Una sesión tiene un límite de 160 iteraciones. Se rechaza una CPI de la ruta heredada en una transacción iterativa, porque no puede dividirse entre tramos. Se permiten las CPI de la ruta en caché.

## Mapeo de cuentas

Cada dirección de Ethereum se asigna determinísticamente a una PDA de balance de Solana derivada del ID de cadena y de la dirección bajo el programa Rome EVM. Su saldo nativo de gas es un campo de esa PDA, junto con el nonce y el código del contrato. Los slots de almacenamiento residen en PDAs de almacenamiento separadas. Los saldos SPL viven en cuentas de token propiedad de la PDA separada de autoridad externa. Esa autoridad se comparte entre todas las cadenas del mismo programa.

## Dos formas de entrada

* **Carril de clave EVM:** una billetera envía una transacción EVM firmada con secp256k1 al Rome Proxy. El proxy envía las transacciones de Solana.
* **Carril de clave Solana:** una billetera autoriza un cuerpo EIP-1559 sin firmar con su clave de Solana. Para la ruta v1 directa, el proxy compone la transacción de Solana. La billetera la firma y la envía directamente al RPC de Solana. La ruta de relé usa el proxy para enviarla en su lugar. La ruta heredada más antigua hace que la billetera construya, firme y pague por una `DoTxUnsigned` transacción de Solana, y el programa deriva el remitente a partir del firmante de Solana.

Una clave pública de Solana se asigna a la dirección sintética `keccak256(pubkey)[12:]`, los últimos 20 bytes del hash. Véase [Cómo se encuentran Solana y la EVM en Rome](https://docs.rome.builders/es/conceptos-basicos/how-solana-and-evm-meet.md).

## Quién firma una llamada a Solana

El programa Rome EVM firma una CPI con la PDA de autoridad externa del llamador inmediato de la precompilación. Un contrato firma como sí mismo. Para gastar los tokens SPL de un usuario, el contrato necesita una delegación SPL de ese usuario. El usuario la concede con `HelperProgram.approve_spl(spender, amount, mint)`. Una llamada directa desde la dirección EVM o sintética del usuario a la precompilación usa la PDA de autoridad externa del usuario.

## Cuentas holder

Las transacciones de Solana (v1) tienen un límite de 4 KB, pero las transacciones EVM (especialmente los despliegues de contratos) pueden ser mucho más grandes. Rome divide las transacciones grandes en fragmentos de 3.600 bytes y los escribe secuencialmente en **cuentas holder** (hasta 80 KB). Luego ensambla cada transacción y la ejecuta en cadena. El SDK de Rome gestiona esto de forma transparente. La comisión de firma de cada fragmento se carga al gas del remitente.

## Gas y precios

Cada cadena tiene su propio token de gas: SOL o un token SPL. La fuente de precios es la API de Hermes, un pool Meteora DAMM v1, un pool Meteora DAMM v2 o un precio fijo. Proporciona la conversión entre el token de gas y SOL para las comisiones subyacentes de la transacción de Solana.

* Una unidad de gas equivale a un lamport de costo de Solana
* `eth_gasPrice` es wei del token de gas por lamport
* El remitente paga al receptor de comisiones desde su saldo nativo de gas. El pagador del proxy paga SOL
* Sin receptor de comisiones, como en el carril atómico de la billetera de Solana, no se cobra gas de EVM. La billetera paga SOL directamente
* El saldo nativo tiene 18 decimales. Está respaldado por SPL de token de gas mantenido en una billetera del programa por cadena

## Finalidad

Rome utiliza la finalidad de Solana. El SDK espera a `confirmado`. Hercules vuelve a verificar cada bloque indexado al estar `finalizado` y lo recarga si el hash del bloque cambió.

## Qué sigue

* [Redes](https://docs.rome.builders/es/redes/networks.md) — conéctese a Hadrian (testnet) y Rubicon (mainnet)
* [Inicio rápido](https://docs.rome.builders/es/primeros-pasos-1/quickstart.md) — despliega tu primer contrato
* [Modelo de ejecución](https://docs.rome.builders/es/conceptos-basicos/execution-model.md) — ejecución atómica frente a iterativa en profundidad
* [Interop de tokens](https://docs.rome.builders/es/conceptos-basicos/token-interop.md)
* [Restricciones](https://docs.rome.builders/es/conceptos-basicos/constraints.md)
* [Llamar a Solana desde EVM](https://docs.rome.builders/es/guias-para-desarrolladores/call-solana-from-evm.md)
* [Llamar a EVM desde Solana](https://docs.rome.builders/es/guias-para-desarrolladores/call-evm-from-solana.md)
* [Referencia de precompilados](https://docs.rome.builders/es/referencia/precompiles.md)
* [Cómo se encuentran Solana y la EVM en Rome](https://docs.rome.builders/es/conceptos-basicos/how-solana-and-evm-meet.md)


---

# 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/primeros-pasos-1/architecture.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.
