> 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/guias-para-desarrolladores/call-evm-from-solana.md).

# Llamar a EVM desde Solana

Permite que una cartera de Solana controle contratos EVM en Rome, sin clave de Ethereum. La cartera firma y su transacción se envía a Solana.

El reverso de [Llamar a Solana desde EVM](https://docs.rome.builders/es/guias-para-desarrolladores/call-solana-from-evm.md): una cartera de Solana (por ejemplo, Solflare) llama directamente a cualquier contrato EVM en Rome, con **sin clave de Ethereum**. Así es como [Aerarium](https://docs.rome.builders/es/apps-en-rome/apps.md) permite que los usuarios nativos de Solana compartan los mismos contratos que los usuarios EVM.

La forma de una sola llamada es la del SDK `submitRomeTxV1`, que hace que el proxy componga una transacción v1 de Solana para la llamada; esta página explica la mecánica.

## Direcciones sintéticas

La identidad EVM de una cartera de Solana es su **dirección sintética** — los últimos 20 bytes de la `keccak256` de su clave pública de Solana de 32 bytes:

```
synthetic_evm_address = keccak256(solana_pubkey)[12:]
```

Esta es la `msg.sender` cuando la cartera llama a un contrato, y la identidad estable bajo la que viven su nonce y su almacenamiento. La derivación está fijada en el protocolo, así que una cartera siempre se mapea a la misma dirección.

```javascript
import { syntheticAddress } from "@rome-protocol/sdk";
const from = syntheticAddress(solanaPubkey); // 0x… 20 bytes
```

## La sintética actúa como un conducto: no mantiene tokens en reposo

El saldo gastable de un usuario nativo de Solana vive en su **cartera de Solana** (como tokens SPL), expuesto 1:1 en el lado EVM como el **envoltorio ERC20SPL** (p. ej., `wUSDC`). La sintética no mantiene nada en reposo, así que el valor fluye *a través de* ella — cada paso firmado por la cartera de Solana:

1. **Aprovisionamiento (una vez).** El PDA de autenticación externa de una sintética recién creada no existe hasta que `create_pda` se ejecuta — y las transferencias de abajo están firmadas por ese PDA. `submitRomeTxSolanaLane` la aprovisiona automáticamente en el primer uso (o llama a `provisionSynthetic` para un paso explícito de "Activar"; compruébalo con `isSyntheticProvisioned`). Con `submitRomeTxV1`, comprueba `isSyntheticProvisioned` y envía `buildCreatePdaCall` a través de ella una vez.
2. **Fase de financiación (cartera → sintética).** Mueve el token del ATA de la cartera al de la sintética — el `ActivateAta` paso, construido por `buildFundLeg`. Ahora `wrapper.balanceOf(synthetic)` lee ese saldo, así que la sintética lo gasta como un ERC-20 ordinario (`transfer` / `transferFrom`) — **no** como nativo `msg.value`, que no posee.
3. **La(s) llamada(s) (`DoTxUnsigned`).** La sintética ejecuta la(s) transacción(es) EVM — p. ej. `approve` luego un vault `depósito` que extrae mediante `transferFrom`.
4. **Fase de barrido (sintética → cartera).** Después de que un retiro / préstamo / reclamación deposite tokens en la sintética, `buildSweepLeg` los empuja de vuelta al ATA de la propia cartera del usuario (`HelperProgram.transfer_spl`), así que la sintética queda en cero.

La siguiente sección describe lo que el antiguo `submitRomeTxSolanaLane` construye en el lado del cliente. `submitRomeTxV1` hace que el proxy componga en su lugar una transacción v1, sin descubrimiento de cuentas, ComputeBudget ni cartera tesorera en tu código; consulta [los endpoints externos V1](#the-external-v1-endpoints) a continuación.

## Cómo se construye la llamada

`submitRomeTxSolanaLane` hace todo esto. La mecánica:

1. **Construye una transacción EIP-1559 sin firmar** con `a partir de` = la dirección sintética — sin firma secp256k1.
2. **Descubrir cuentas** — llama a [`rome_emulateCallAccounts`](https://docs.rome.builders/es/referencia/json-rpc.md) con el `a partir de`, `a`, `datos`, **y `valor`** (cuando la llamada es payable). Pasar `valor` importa: el proxy emula la *real* llamada, así que cualquier escritura de almacenamiento dependiente del valor — p. ej., una nueva ranura de mapeo — se asigna y se devuelve su cuenta de Solana. Omitirlo hace que falte esa cuenta y la transacción falle con *"instruction modified data of a read-only account."*
3. **Ensamblar la transacción de Solana:** dos **ComputeBudget** instrucciones (el EVM de Rome necesita un límite de CU más alto ≈1,35 M y una gran heap frame ≈250 KB — los valores predeterminados de Solana fallan) + la **`DoTxUnsigned`** instrucción (el RLP sin firmar + las cuentas descubiertas) + la **cartera tesorera** (la ejecución le paga una pequeña comisión; el descubrimiento la omite, así que el SDK la agrega).
4. **La cartera firma y envía.** Los **La cartera de Solana firma la transacción de Solana (Ed25519) y la envía al RPC de Solana — no al proxy.** El runtime de Solana verifica la firma; en cadena, el programa deriva `msg.sender` a partir de ese firmante. La autoridad es la firma de Solana, no una de Ethereum. (El proxy solo se usa para la emulación/el descubrimiento en el paso 2.)

El PDA del usuario (`["EXTERNAL_AUTHORITY", synthetic_address]`) posee sus cuentas de tokens y firma las CPI de SPL en su nombre — así, un usuario de Solana puede suministrar, pedir prestado, intercambiar y aportar liquidez por completo desde su cartera de Solana.

## Los endpoints externos V1

`submitRomeTxV1` es la forma de una sola llamada: le pide al proxy una transacción v1 compuesta, la comprueba, hace que la cartera la firme y la envía al RPC de Solana, retransmitiéndola a través del proxy cuando la llamada no encaja. El proxy expone el mismo canal que los métodos RPC, así que cualquier cliente puede usarlo sin el SDK (lista completa en [Compatibilidad con JSON-RPC](https://docs.rome.builders/es/referencia/json-rpc.md)):

* `rome_composeUnsignedAtomicV1(rlp, pubkey, signature)` — una transacción v1 de Solana; la cartera la firma y la aplicación la transmite al RPC de Solana. Se rechaza cuando la llamada no cabe en una transacción atómica.
* `rome_composeUnsignedIterativeV1(rlp, pubkey, signature)` — cada fase de la ejecución (atómica si cabe, de lo contrario las fases iterativas); la cartera firma cada una, `rome_submitSignedV1Plan` las transmite. Los límites de un plan largo están en [Llamadas retransmitidas y llamadas largas](#relayed-calls-and-long-calls).
* `rome_relayUnsignedV1(rlp, pubkey, signature)` — una sola firma de la cartera, el pagador del proxy impulsa las fases y devuelve el hash de la tx EVM; la sintética paga el gas de Rome, así que cárgala una vez con `rome_composeExternalDepositV1`.

**La firma de autorización.** `rlp` es el cuerpo EIP-1559 sin firmar de 9 campos. La cartera firma, con su clave Ed25519, ya sea el crudo de 32 bytes `keccak256(0x02 ‖ rlp)` o el mensaje legible

```
Autorización de Rome
0x<64 caracteres hexadecimales en minúscula de ese hash>
```

Ambos se aceptan; el formato legible es el que una cartera muestra de forma legible en su `signMessage` indicador. El programa vuelve a calcular el hash a partir del cuerpo que ejecuta y exige que el mensaje firmado sea exactamente una de las dos formas, de modo que una firma sobre un cuerpo nunca puede autorizar otro, y el nonce del cuerpo evita la repetición.

## Llamadas retransmitidas y llamadas largas

Algunas llamadas no caben en una transacción de Solana. Esta sección cubre qué ocurre entonces y qué límites aplican.

### Cuando el compositor atómico se niega

`rome_composeUnsignedAtomicV1` rechaza una llamada que no cabe en una transacción atómica. `submitRomeTxV1` entonces retransmite la llamada a través del proxy con la **misma** firma de autorización, así que no se le pide de nuevo a la cartera. El resultado tiene `route: "relay"` y ninguna `firma de Solana`. Pasa `relayOnRefusal: false` para obtener el rechazo como error en su lugar, o llama a `relayV1` tú mismo para retransmitir a propósito.

Tres cosas que debes saber sobre una llamada retransmitida:

* **La sintética paga el gas.** En la ruta de retransmisión, el proxy presenta y paga las transacciones de Solana, y la llamada se paga en el token nativo de gas de la cadena con el saldo de la sintética. El saldo debe ser al menos `gasLimit × maxFeePerGas`. `fundSyntheticGas(deps, amountWei)` lo recarga desde la propia cuenta de token de la cartera del token de gas de la cadena (USDC en Hadrian y Rubicon); la cartera firma una transacción v1 normal y necesita un poco de SOL para la comisión de Solana. `amountWei` está en wei de 18 decimales de la cadena y debe ser un múltiplo de 10^12, o el proxy lo rechaza. Sin el SDK, `rome_composeExternalDepositV1` construye la misma transacción.
* **Un revert no lanza excepción.** Una llamada retransmitida que revierte en el lado EVM se resuelve normalmente, con `receipt.status === "0x0"`. Comprueba `receipt?.status === "0x1"` antes de dar por terminada la llamada. `receipt` es `null` si el receipt no apareció a tiempo.
* **`relayOnRefusal: false` es una decisión tomada en el SDK, no un bloqueo.** El proxy ya tiene la firma de autorización para ese payload y puede ejecutarlo por cualquiera de las dos rutas, hasta `gasLimit × maxFeePerGas`.

```javascript
const res = await submitRomeTxV1(deps, { to, data, value });
if (res.route === "relay" && res.receipt?.status !== "0x1") {
  // una llamada retransmitida que revirtió se resuelve; no lanza excepción
}
```

### Llamadas largas

Una llamada que necesita más de una transacción se ejecuta como una sesión iterativa: el programa ejecuta tantos pasos EVM como quepan en cada transacción de Solana y guarda su estado entre ellas. Dos formas de controlarla desde una cartera de Solana:

* **Retransmitirla.** `rome_relayUnsignedV1` toma una sola firma de la cartera y el pagador del proxy envía cada fase. La sintética paga el gas, como arriba.
* **Firma tú mismo las fases.** `rome_composeUnsignedIterativeV1` devuelve cada fase con un espacio de firma vacío, la cartera firma cada una y `rome_submitSignedV1Plan` las transmite en orden. Cada fase es una transacción de Solana separada para que la firme la cartera, así que una cartera que firma una transacción a la vez solicita una vez por fase, además de la firma de autorización. La cartera paga la comisión de Solana en cada fase.

Los límites:

| Límite                                                 | Valor                | De dónde viene                                                                                                                     |
| ------------------------------------------------------ | -------------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
| Transacciones en una `rome_submitSignedV1Plan` llamada | 64                   | El proxy rechaza un plan más largo                                                                                                 |
| Fases que planificará el compositor iterativo          | 128                  | El límite en el compositor iterativo del SDK de Rust de Rome, que también acota el plan `rome_composeUnsignedIterativeV1` devuelve |
| Iteraciones en una sesión                              | 160                  | El programa Rome EVM; más allá de eso la sesión deja de reanudarse, libera sus bloqueos de cuenta y termina                        |
| Tamaño de la transacción de Solana y cuentas           | 4 KB, 64 direcciones | Cada fase es una transacción v1 de Solana                                                                                          |

La mayoría de las llamadas reales se resuelven en muchas menos fases que estos límites. El límite de 64 transacciones en un plan firmado por la cartera es el que encontrarás primero. Una llamada que necesite más fases que eso no puede transmitirse a través de `rome_submitSignedV1Plan`.

Una llamada larga no puede hacer CPI del canal legacy. Las llamadas que modifican estado en los precompilados legacy (`0xff…08`, `0xff…09` y `0x42…16`) se rechazan en una sesión iterativa con `CpiProhibitedInIterativeTx`. Las lecturas del estado de Solana y los precompilados del canal cacheado (`0xff…04`, `0xff…05`, `0xff…06`, `0xff…0b`) funcionan. Una llamada que hace CPI del canal legacy debe caber en una transacción atómica, sea cual sea el canal que la envíe. Consulta [Restricciones](https://docs.rome.builders/es/conceptos-basicos/constraints.md) y [Presupuesto de cómputo](https://docs.rome.builders/es/conceptos-basicos/compute-budget.md).

## Implementaciones de referencia

* **Aerarium** — impulsa Compound v3 (suministrar / pedir prestado) desde una cartera de Solana mediante `DoTxUnsigned`. Es la referencia para el antiguo canal de transacción legacy descrito arriba, no para `submitRomeTxV1`.
* **Rome DEX** no es un ejemplo de esta página: su lado de Solana es un programa nativo de Solana para el que la cartera firma directamente, y su lado EVM comparte el mismo pool.

Aerarium no necesita una segunda cartera — la dirección sintética convierte una clave de Solana en una cuenta EVM de primera clase. Para el patrón v1, sigue [Crear una app de doble vía](https://docs.rome.builders/es/guias-para-desarrolladores/dual-lane-app.md).

## Qué sigue

* [Llamar a Solana desde EVM](https://docs.rome.builders/es/guias-para-desarrolladores/call-solana-from-evm.md) — la otra dirección, vía CPI
* [Interop de tokens](https://docs.rome.builders/es/conceptos-basicos/token-interop.md) — cómo se comparten los saldos entre EVM y Solana


---

# 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/guias-para-desarrolladores/call-evm-from-solana.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.
