> 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/rome-academy/04-how-rome-runs-your-code.md).

# 4. Cómo Rome ejecuta tu código

Cómo una transacción de Rome se convierte en transacciones de Solana, por qué la mayoría de las llamadas se ejecutan de forma atómica y qué cambia cuando una llamada es demasiado grande.

Tu Solidity se ejecuta sin cambios. Lo que cambia es dónde se ejecuta: dentro de un programa de Solana, bajo los límites de Solana. Esta lección te da la visión que necesitas para predecir cuánto costará una llamada y cuándo fallará.

## Lo que aprenderás

* El recorrido que sigue una transacción desde tu wallet hasta un validador de Solana y de vuelta a un recibo EVM.
* La diferencia entre ejecución atómica e iterativa, y por qué quieres la atómica.
* Qué límites de Solana afectan a tu Solidity: cómputo, tamaño, número de cuentas, bloqueos.
* Cómo medir lo que realmente cuesta una llamada.

## Antes de empezar

* Termina [3. Tu primer contrato en Hadrian](https://docs.rome.builders/es/rome-academy/03-first-contract-on-hadrian.md). Necesitas un contrato desplegado y una transacción que le hayas enviado.
* Ten a mano el hash de esa transacción. Lo abrirás en el explorador al final de esta lección.

## El recorrido de una transacción

Firmas una transacción EVM normal y la envías al proxy de Rome con `eth_sendRawTransaction`. El proxy aún no la reenvía. Primero ejecuta la llamada fuera de la cadena en un emulador que ejecuta la misma lógica EVM que el programa en cadena. La emulación le dice tres cosas: cuánta gas necesita la llamada, qué cuentas de Solana toca y si la llamada cabe en una sola transacción de Solana.

Luego el proxy envuelve tu llamada como instrucciones de Solana y las envía. El programa EVM de Rome, que es un programa normal de Solana, interpreta tu bytecode. Los cambios de estado llegan a cuentas de Solana. Un indexador lee el resultado y produce el bloque EVM y el recibo que esperan tus herramientas.

Cada dirección EVM se mapea a una cuenta de Solana propiedad del programa Rome. El saldo, nonce, código y almacenamiento de tu contrato son todas cuentas de Solana. Por eso el proxy debe conocer la lista de cuentas antes de enviarla: Solana exige que todas las cuentas se nombren de antemano.

Lee el ciclo de vida completo en [Modelo de ejecución](https://docs.rome.builders/es/conceptos-basicos/execution-model.md).

## Primero, atómica

La mayoría de las llamadas se ejecutan en una sola transacción de Solana. Rome llama a esto ejecución atómica (VmAt). Es todo o nada: si cualquier paso falla, toda la llamada revierte. Una transferencia, un swap y la mayoría de las llamadas DeFi encajan. Algunas no: un borrow de Aave en Hadrian necesitó más de una transacción de Solana.

Una llamada atómica tiene un presupuesto de aproximadamente 1.4M unidades de cómputo. Estos límites moldean cada llamada:

| Límite              | Qué significa para ti                                                                                                                                        |
| ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Cómputo             | Aproximadamente 1.4M CU compartidas por el trabajo EVM y cada programa que llames                                                                            |
| Cuentas             | 64 direcciones, contando las cuentas de Rome y todo lo que toquen tus CPI                                                                                    |
| Tamaño              | 4 KB por transacción de Solana; cargas útiles EVM más grandes, como grandes despliegues, se preparan a través de una cuenta holder y el SDK lo maneja por ti |
| Tamaño del contrato | 24 KB, como en Ethereum                                                                                                                                      |

La lista completa, con los valores, está en [Restricciones](https://docs.rome.builders/es/conceptos-basicos/constraints.md).

## Iterativa cuando una llamada es demasiado grande

Si el emulador encuentra que una llamada no cabe, Rome la ejecuta iterativamente (VmIt). La llamada se divide en tramos. Cada tramo es su propia transacción de Solana y ejecuta tantos opcodes como permita su presupuesto de cómputo. Entre tramos, el estado de la VM se guarda en una cuenta holder y el siguiente tramo lo retoma.

La ejecución iterativa funciona, pero tiene un costo:

* Una sesión termina después de 160 tramos. Pasado eso, libera sus bloqueos y no confirma nada.
* La sesión bloquea sus cuentas de saldo y almacenamiento durante unos segundos, renovados en cada tramo. Una escritura atómica sobre una cuenta bloqueada se rechaza con `AccountLocked`, y el cliente reintenta.
* Las llamadas que hacen CPI de Solana en la ruta legada (las `CpiProgram` y `HelperProgram` llamadas de la lección 5) no pueden ejecutarse iterativamente en absoluto. Tienen que caber de forma atómica.
* En la vía de Solana, una wallet que firma sus propios tramos le pide confirmación al usuario una vez por tramo.

La regla de diseño es esta: da forma a cada acción del usuario para que quepa en una sola transacción atómica. Si un flujo es más grande, divídelo en dos acciones de usuario en lugar de depender del modo iterativo. La lección 5 vuelve sobre esto cuando llamas a programas de Solana.

## Lo que pagas

Rome calcula el coste de una llamada en lamports de Solana: comisiones de firma, un peaje fijo, renta por cualquier cuenta que la llamada cree. Una unidad de gas representa un lamport de coste. El precio del gas lo convierte al token de gas de la cadena, que es USDC en Hadrian y Rubicon.

La renta es la parte que sorprende a la gente. La primera transferencia a una dirección que nunca se había usado crea cuentas, así que cuesta mucho más que una transferencia repetida. Espera un gas alto en el primer uso y un gas normal después. Los números detallados están en [Cómo se encuentran Solana y la EVM en Rome](https://docs.rome.builders/es/conceptos-basicos/how-solana-and-evm-meet.md#gas-and-rent).

## Mide, no adivines

EVM `gasUsed` no es un sustituto fiel del cómputo de Solana. En Rome una unidad de gas es un lamport de coste, así que `eth_estimateGas` dimensiona tu límite de gas pero no te dice nada sobre las unidades de cómputo. Lee el cómputo desde el lado de Solana. Via enlaza la transacción de Solana desde su fila "Settled in", y el explorador de Solana muestra sus unidades de cómputo. En código, obtén las firmas de Solana detrás de un hash EVM con `rome_solanaTxForEvmTx`, busca cada una con Solana's `getTransaction` y `maxSupportedTransactionVersion: 1`, y lee `computeUnitsConsumed`. Una llamada iterativa tiene una transacción por tramo. [Presupuesto de cómputo](https://docs.rome.builders/es/conceptos-basicos/compute-budget.md) tiene costos típicos por operación y los hábitos baratos que los reducen: constantes para IDs de programa, derivaciones PDA en caché, menos cuentas.

Dos comportamientos difieren de Ethereum y conviene conocerlos ahora:

* Rome no tiene un medidor de gas por opcode. El gas que pasas a un `CALL` no se aplica y no existe un estipendio de 2300 gas. Protégete explícitamente contra la reentrada.
* `block.number` es el slot de Solana y `block.timestamp` es el reloj de Solana.

## Compruébalo tú mismo

Abre tu transacción de la lección 3 en el explorador de Hadrian. Encuentra el enlace de red en [Hadrian](https://docs.rome.builders/es/redes/hadrian.md) y las notas del explorador en [Vía explorador](https://docs.rome.builders/es/apps-en-rome/via.md).

Observa dos cosas:

1. La transacción de Solana que liquidó tu llamada, desde la fila "Settled in".
2. Las unidades de cómputo que consumió, en el explorador de Solana.

Compara ese número con el presupuesto de 1.4M. Una llamada sencilla usa una pequeña parte de él.

Luego responde:

<details>

<summary>1. ¿Por qué el proxy emula una llamada antes de enviarla?</summary>

Solana necesita que todas las cuentas se nombren de antemano, y el proxy tiene que saber si la llamada cabe en una sola transacción. La emulación encuentra las cuentas tocadas, estima el gas y decide entre atómica o iterativa.

</details>

<details>

<summary>2. Una llamada hace una CPI de ruta legada (las llamadas `CpiProgram` y `HelperProgram` de la lección 5) y necesita más de 1.4M CU. ¿Qué sucede?</summary>

No puede ejecutarse. Las CPI de ruta legada se rechazan dentro de una transacción iterativa, así que la llamada debe caber en una sola transacción atómica. Divide el trabajo en acciones de usuario más pequeñas.

</details>

<details>

<summary>3. ¿Por qué es cara la primera transferencia a una nueva dirección?</summary>

Rome crea cuentas de Solana para ella, y la renta de esas cuentas se cobra al remitente como gas.

</details>

## Siguiente

[5. Llama a Solana desde Solidity](https://docs.rome.builders/es/rome-academy/05-call-solana-from-solidity.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/rome-academy/04-how-rome-runs-your-code.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.
