> 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/conceptos-basicos/constraints.md).

# Restricciones

Límites al construir sobre Rome EVM: tamaño de transacción de Solana, presupuesto de \~1,4M CU, límites de cuentas, diseño de almacenamiento y cómo Rome sortea cada uno.

Límites y restricciones importantes al construir sobre Rome EVM. Comprender estas limitaciones ayuda a diseñar contratos que funcionen de forma fiable.

## Límites de transacciones de Solana

| Restricción                 | Valor              | Impacto                                                                                                                                 |
| --------------------------- | ------------------ | --------------------------------------------------------------------------------------------------------------------------------------- |
| Tamaño de la transacción    | 4 KB (4,096 bytes) | Rome envía transacciones Solana v1; las transacciones EVM más grandes se almacenan temporalmente en cuentas contenedoras (transparente) |
| Unidades de cómputo por tx  | \~1.4M CU          | Las operaciones que superan esto usan el modo iterativo, que tiene sus propios límites (abajo)                                          |
| Cuentas por tx              | 64 direcciones     | El límite de la transacción v1; cuenta todo lo que toca la tx EVM y sus CPI, incluidas las propias cuentas de Rome                      |
| Tamaño máximo de contenedor | 80 KB              | Tamaño máximo de RLP para una sola transacción EVM                                                                                      |

## Límites de ejecución de EVM

| Restricción                                    | Valor                                             | Notas                                                                                                                                                                                                                            |
| ---------------------------------------------- | ------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Slots de almacenamiento del contrato           | 256 por cuenta de almacenamiento                  | Se pueden crear varias cuentas de almacenamiento por contrato                                                                                                                                                                    |
| Opcodes por iteración                          | Adaptativo                                        | Empaquetado según el presupuesto de CU de cada tx de Solana (VmIt)                                                                                                                                                               |
| TTL del bloqueo de cuenta                      | 3 s (4 s cuando la sesión toca más de 28 cuentas) | Durante la ejecución iterativa; renovado en cada paso                                                                                                                                                                            |
| Duración de la sesión iterativa                | 160 pasos                                         | Al superar el límite, el siguiente paso libera los bloqueos de la sesión y la termina sin comprometer nada                                                                                                                       |
| Tramos planificados por el SDK de Rome en Rust | 128                                               | El techo del compositor iterativo; las llamadas reales se resuelven en muchas menos                                                                                                                                              |
| Transacciones por plan firmado por la wallet   | 64                                                | Como máximo `rome_submitSignedV1Plan` acepta en una sola llamada; ver [Llamadas retransmitidas y llamadas largas](https://docs.rome.builders/es/guias-para-desarrolladores/call-evm-from-solana.md#relayed-calls-and-long-calls) |
| Monederos de tesorería                         | 64                                                | Monederos del fondo de comisiones                                                                                                                                                                                                |
| Límite de tamaño del contrato                  | 24 KB                                             | Igual que Ethereum (EIP-170, 24,576 bytes)                                                                                                                                                                                       |

## Restricciones de CPI

| Restricción                        | Valor                                                                    | Notas                                                                                                                                        |
| ---------------------------------- | ------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------- |
| Profundidad de CPI                 | 4 niveles máx.                                                           | El límite de profundidad de CPI de Solana                                                                                                    |
| Cuentas por llamada CPI            | Dentro del límite de 64 direcciones de la transacción                    | Compartido con cualquier otra cuenta que la transacción toque                                                                                |
| Profundidad de CPI + Transfer Hook | Usa niveles de CPI                                                       | Los transfer hooks desde dentro de CPI pueden exceder la profundidad                                                                         |
| Una ruta por contrato              | Legado (`0xff…07/08/09`, `0x42…16`) **ni** en caché (`0xff…04/05/06/0b`) | Se rechaza mezclar llamadas mutantes de ambos en una sola transacción                                                                        |
| CPI heredada en modo iterativo     | No permitido                                                             | Una CPI de ruta heredada en una transacción iterativa falla con `CpiProhibitedInIterativeTx`; los efectos de la ruta en caché sí se permiten |

**La profundidad de CPI es la restricción más crítica.** Rome EVM consume un nivel de CPI cuando Solana llama al programa de Rome. Si tu contrato de Solidity luego llama a otro programa de Solana vía CPI, eso es el nivel 2. Si ese programa llama a otro, eso es el nivel 3. Tienes como máximo 4 niveles en total.

```
Nivel 0: Runtime de Solana → Programa Rome EVM
Nivel 1: Programa Rome EVM → Tu destino CPI (p. ej., Jupiter)
Nivel 2: Jupiter → otro programa (p. ej., Raydium)
Nivel 3: Raydium → SPL Token (profundidad máxima)
```

## Restricciones de Transfer Hook de Token-2022

| Restricción             | Impacto                                                                                            |
| ----------------------- | -------------------------------------------------------------------------------------------------- |
| Un hook por mint        | Un mint de Token-2022 tiene un único slot de transfer hook                                         |
| `transfer_checked` solo | Los hooks no se activan con `transfer`. Las operaciones del puente de Rome usan `transfer_checked` |
| Mint/burn sin hook      | Controlado mediante la autoridad de mint, no por hooks                                             |

## Restricciones de gas y precios

| Restricción                      | Notas                                                                     |
| -------------------------------- | ------------------------------------------------------------------------- |
| Fuente del precio del gas        | Pool DAMM de Meteora, v1 o v2 (token de gas SPL)                          |
| Multiplicador del precio del gas | Configurables por proxy (`gas_price_mul`)                                 |
| Precio mínimo del gas            | Establecido por la configuración del proxy                                |
| Estimación de gas                | Realizada fuera de la cadena mediante el emulador Mollusk antes del envío |

## Restricciones específicas de la red

| Entorno           | ID de cadena | ID del programa rome-evm                      |
| ----------------- | ------------ | --------------------------------------------- |
| Hadrian (testnet) | 200010       | `RPTWwELXAY4KC9ZPHhaxp7Sq1hHtU3HNEgLbSegCcWf` |
| Rubicon (mainnet) | 7531         | `RomePq9X3iAoTr813HR7uRarafFDUJty6GdiEceYpzX` |

## Restricciones de precompilados

| Precompilado                 | Restricción                                                                                                                               |
| ---------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------- |
| Modexp (0x05)                | **Deshabilitado** — una llamada revierte con `la llamada big_mod_exp está deshabilitada` hasta que Solana active la `big_mod_exp` syscall |
| BN254 ecPairing (0x08)       | Aproximadamente 22K CU más 12.8K por par según el precio del programa; una comprobación de cuatro pares cabe en una transacción atómica   |
| Precompilado CPI (0xFF...08) | Las cuentas deben declararse por adelantado en la transacción de Solana                                                                   |

## Validación de transacciones

| Regla                         | Efecto                                                                                                                                                                                              |
| ----------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Maleabilidad de firma (EIP-2) | Una transacción firmada cuyo `s` está por encima de la mitad del orden de la curva es rechazada                                                                                                     |
| Forma RLP                     | Se rechaza una transacción cuya lista RLP contiene bytes sobrantes más allá de su último elemento                                                                                                   |
| Opcode no implementado        | Aborta toda la transacción (`IncompatibleVersionEVM(opcode)`); no se compromete nada y el contrato que la llama no puede absorberlo                                                                 |
| Contabilización de gas        | Rome no tiene una tabla de gas por opcode: el gas pasado a `CALL`/`CREATE` no se aplica, y no existe un estipendio de 2300 gas — no confíes en la protección contra reentrada basada en estipendios |

## Restricciones de oráculos

| Restricción                            | Valor                                                                 |
| -------------------------------------- | --------------------------------------------------------------------- |
| Desactualización máxima predeterminada | 60 segundos                                                           |
| Datos históricos de rondas             | No compatible — `getRoundData(roundId)` revierte                      |
| Switchboard EMA                        | No compatible — `latestEMAData()` revierte en SwitchboardV3           |
| Desplazamientos del analizador         | Validado empíricamente — debe revalidarse antes de volver a desplegar |

## Recomendaciones de diseño

1. **Mantén la profundidad de CPI poco profunda.** Diseña los contratos para minimizar el anidamiento. Si llamas a Jupiter, que llama a Raydium, que llama a SPL Token, estás en 3 niveles: peligrosamente cerca del límite.
2. **Prefiere el modo atómico.** Diseña las operaciones para que entren dentro de \~1.4M CU. El modo iterativo añade latencia (bloqueos de 3 a 4 segundos), un límite de 160 iteraciones por sesión y un aviso de wallet por tramo en la ruta de Solana cuando la wallet firma los tramos por sí misma. Una llamada que realiza CPI de ruta heredada no puede ejecutarse en modo iterativo en absoluto.
3. **Declara las cuentas por adelantado.** Todas las cuentas de Solana tocadas por CPI deben conocerse en el momento de crear la transacción (la emulación del proxy las descubre). No es posible el descubrimiento dinámico de cuentas dentro de una llamada CPI, y el total debe caber en el límite de 64 direcciones.
4. **Elige una sola ruta de precompilado por contrato.** Llamar a un programa personalizado de Solana (`invoke_signed`) es de ruta heredada y solo atómico; ver [Integra un programa de Solana](https://docs.rome.builders/es/guias-para-desarrolladores/integrate-solana-program.md).
5. **Usa `transfer_checked`.** Si estás construyendo cualquier cosa que toque tokens Token-2022, usa siempre `transfer_checked` para garantizar que se activen los hooks.
6. **Prueba el consumo de CU.** Mide las unidades reales de cómputo de Solana a partir del recibo de la transacción (`computeUnitsConsumed`) — EVM `gasUsed` no es un proxy fiel de las CU de Solana. Optimiza con Yul para las rutas críticas.

## Qué sigue

* [Presupuesto de cómputo](https://docs.rome.builders/es/conceptos-basicos/compute-budget.md) — costes detallados de CU por operación
* [Interop de tokens](https://docs.rome.builders/es/conceptos-basicos/token-interop.md) — modelo de puente ERC-20 ↔ SPL
* [Referencia de precompilados](https://docs.rome.builders/es/referencia/precompiles.md) — cada selector y su clase de despacho


---

# 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/conceptos-basicos/constraints.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.
