> 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/08-open-your-solana-program-to-evm-users.md).

# 8. Abre tu programa de Solana a usuarios de EVM

Permite que los usuarios de MetaMask llamen a un programa que ya ejecutas en Solana, a través de un contrato delgado de Solidity y el precompilado CPI, sin portarlo ni crear una segunda copia de tu estado.

Tienes un programa de Solana que funciona. Sus usuarios tienen billeteras de Solana. Rome permite que una segunda audiencia acceda a él: personas que tienen una billetera EVM como MetaMask, sin que tengas que reescribir el programa en Solidity.

## Lo que aprenderás

* Por qué querrías abrir un programa de Solana a usuarios EVM, y qué conservas.
* Cómo una llamada EVM llega a tu programa: un contrato Solidity ligero y el precompile de CPI.
* Lo que tu programa ve como firmante y como cuentas.
* Cómo los tokens de un usuario EVM llegan a tu programa y vuelven.
* Los límites en torno a los que diseñar: una sola ruta, una sola transacción atómica, el límite de cuentas.

## El caso de uso

Esta lección sirve para un caso de uso de [Lo que puedes construir](https://docs.rome.builders/es/rome-academy/02-what-you-can-build.md): una aplicación de Solana existente que quiere más usuarios. Un mercado de préstamos, un AMM, un vault, un mercado de predicción o un programa de privacidad encajan.

La audiencia EVM es grande y ya tiene billeteras, herramientas y hábitos. Si portas tu programa a Solidity, mantienes dos bases de código y separas tu estado. En Rome conservas un solo programa y un solo estado. Los usuarios EVM llegan a él mediante un pequeño contrato Solidity, y los usuarios de Solana siguen llamándolo de forma nativa. Ambos operan contra las mismas cuentas y la misma liquidez. [Elige tu núcleo](https://docs.rome.builders/es/conceptos-basicos/choose-your-core.md) llama a esta forma (b), un núcleo nativo de Solana con un router CPI ligero.

[rome-dex](https://github.com/rome-protocol/rome-dex) es la referencia: un pool nativo de Solana, con un router EVM delante.

## Antes de empezar

* Termina [7. Abre tu app de EVM a billeteras de Solana](https://docs.rome.builders/es/rome-academy/07-open-to-solana-wallets.md), la misma idea desde el otro lado.
* Conoce [5. Llama a Solana desde Solidity](https://docs.rome.builders/es/rome-academy/05-call-solana-from-solidity.md) y [6. Tokens en ambos lados](https://docs.rome.builders/es/rome-academy/06-tokens-on-both-sides.md). Esta lección las reúne.
* Ten tu programa desplegado en Solana devnet. Hadrian liquida allí, así que el programa debe existir en ese clúster. Consulta [Hadrian](https://docs.rome.builders/es/redes/hadrian.md).

## La ruta en breve

### Paso 1: coloca un contrato ligero delante de tu programa

El contrato es un adaptador. No contiene lógica de negocio. Verifica al llamador, construye tu instrucción y llama al precompile de CPI con `invoke_signed`. Todo lo demás permanece en tu programa de Solana. La mecánica de la llamada está en [Llamar a Solana desde EVM](https://docs.rome.builders/es/guias-para-desarrolladores/call-solana-from-evm.md#calling-custom-solana-programs), y la interfaz está `contracts/interface.sol` en el público [rome-solidity](https://github.com/rome-protocol/rome-solidity) repositorio.

Tu adaptador tiene tres formas de mantener la posición de un usuario. La guía las compara en [Tres formas de mantener la posición de un usuario](https://docs.rome.builders/pages/52b676b8d62317a0f46fd6ed850e41457cb887c8#id-2.-three-ways-to-hold-a-users-position):

| Forma                          | Qué es                                                           | Se adapta a                                             |
| ------------------------------ | ---------------------------------------------------------------- | ------------------------------------------------------- |
| Contrato adaptador             | Retira los tokens del usuario, llama a tu programa como sí mismo | Una fachada reutilizable para un programa con depósitos |
| El usuario llama al precompile | La propia autoridad del usuario firma, sin contrato              | Concesiones únicas y programas simples                  |
| Router sin custodia            | Nunca retiene tokens, gasta la delegación del usuario            | Swaps y otras acciones de un solo uso                   |

Elige el adaptador para un vault o programa de préstamos, y el router para un swap.

### Paso 2: entiende a quién ve tu programa

Cada dirección EVM tiene una identidad de Solana, su PDA de autoridad externa, derivada bajo el programa Rome. Cuando un contrato llama al precompile, Rome firma con la autoridad de ese contrato. Tu programa ve una clave pública de 32 bytes marcada como firmante. Nunca ve una dirección EVM de 20 bytes ni ve al usuario.

Así que el usuario no es el firmante. Para distinguir a los usuarios, el adaptador pasa un valor por usuario en los datos de la instrucción, o le pide a Rome que firme además con un sub-PDA salteado derivado de la dirección del usuario. Tu programa entonces mantiene una posición por sub-PDA. Las reglas de firma están en [Cada dirección EVM tiene una identidad de Solana](https://docs.rome.builders/pages/52b676b8d62317a0f46fd6ed850e41457cb887c8#id-1.-every-evm-address-has-one-solana-identity).

Escribe tu programa para actuar sobre la autoridad que firme. Así dará servicio tanto a una billetera de Solana como a un adaptador.

### Paso 3: mueve los tokens del usuario

En Rome, los USDC de un usuario son un solo token SPL visto desde dos lados, como mostró la lección 6. El saldo del usuario está en una cuenta de tokens que su autoridad posee. Para permitir que un adaptador lo gaste, el usuario concede al adaptador una delegación SPL antes del depósito. El adaptador retira los tokens a una cuenta de tokens que él posee, y luego llama a tu programa. Al salir, tu programa paga a la propia cuenta de tokens del usuario, y el usuario lo ve de inmediato como un saldo ERC-20.

Aquí importan dos trampas:

* Un ERC-20 `transferFrom` a un contrato solo acredita el libro mayor de custodia del wrapper. El contrato no obtiene ninguna cuenta de tokens de la que gastar. Usa la delegación, no el wrapper.
* Una cuenta de tokens tiene un solo delegado. Tu concesión desplaza la concesión del wrapper, y las transferencias normales de tokens del usuario se detienen hasta que vuelva a conceder permiso al wrapper. Comprueba `isEnabled` después de tu flujo.

La secuencia completa está en [Tokens de entrada, tokens de salida](https://docs.rome.builders/pages/52b676b8d62317a0f46fd6ed850e41457cb887c8#id-3.-tokens-in-tokens-out).

### Paso 4: mantente dentro de los límites

* **Una sola ruta.** Una llamada de programa personalizada es una CPI de la ruta legacy. Una transacción no puede mezclarla con llamadas de la ruta cached, así que mantén el wrapper cached fuera de esa transacción.
* **Solo atómica.** Una CPI de la ruta legacy no puede ejecutarse en una transacción iterativa. Toda la llamada debe caber en una sola transacción de Solana, unas 1,4 M de unidades de cómputo, 64 direcciones y 4 KB. Tu programa comparte ese presupuesto de cómputo con el programa Rome.
* **Cuentas por adelantado.** Rome emula la llamada y pone cada cuenta que toca en la transacción de Solana. Cada cuenta debe poder derivarse de entradas que tenga el adaptador. Una cuenta nueva sigue teniendo nombre.
* **Profundidad superficial.** Tu programa se ejecuta un nivel por debajo de Rome. Cada programa que llama usa otro nivel.
* **La renta corre a cargo del usuario.** Las cuentas que crea tu instrucción se pagan mediante el gas del usuario.

Mantén cada acción en un solo movimiento de tokens y una sola CPI hacia tu programa. Divide cualquier cosa mayor en dos transacciones de usuario. Los límites están en una tabla en [Restricciones](https://docs.rome.builders/es/conceptos-basicos/constraints.md).

## Un ejemplo trabajado

Supón que tu programa es un vault. Un usuario de Solana deposita USDC y luego lo retira. Quieres que los usuarios de MetaMask hagan lo mismo.

1. Despliegas un adaptador que conoce el ID de tu programa y el mint de USDC. En su constructor crea su propia identidad de Solana y una cuenta de tokens para ella.
2. Un usuario de MetaMask envía una transacción que concede al adaptador una delegación SPL sobre sus USDC.
3. El usuario llama a `depósito`. El adaptador retira los USDC a su propia cuenta de tokens y luego llama a tu programa con su propia autoridad y un sub-PDA salteado para ese usuario como firmantes.
4. Tu programa mueve los USDC a su vault y registra la posición bajo el sub-PDA.
5. La concesión del adaptador reemplazó la del wrapper, así que tu app lee `isEnabled` en el wrapper para el usuario. Devuelve `false`, y el usuario envía `approve_spl` de nuevo para el wrapper. El siguiente depósito necesita una nueva concesión al adaptador.
6. El usuario llama a `withdraw`. El adaptador hace que tu programa pague desde el vault directamente a la cuenta de tokens del usuario. El saldo aparece en MetaMask como el token ERC-20.

Tus usuarios de Solana nunca tocaron el adaptador. Llaman al vault directamente y ven los mismos totales. El esquema Solidity correspondiente está en [Un depósito y un retiro, en Solidity](https://docs.rome.builders/pages/52b676b8d62317a0f46fd6ed850e41457cb887c8#id-7.-a-deposit-and-a-withdraw-in-solidity).

Prueba primero en Hadrian. `eth_call` y `eth_estimateGas` ejecuta la misma emulación que usa el proxy para enviar, así que una CPI que falla allí falla en cadena por la misma razón, y el revert lleva el error de tu programa. Después de un envío, lee el lado Solana de la transacción con `rome_solanaTxForEvmTx`. Véase [Pruebas](https://docs.rome.builders/pages/52b676b8d62317a0f46fd6ed850e41457cb887c8#id-8.-testing).

## Compruébalo tú mismo

Toma un pequeño programa tuyo, o el que está en rome-dex, y anota, sin código:

1. El firmante que ve tu programa cuando un adaptador lo llama.
2. Las cuentas que nombra un depósito.
3. El número de movimientos de tokens y de CPIs en ese depósito.

Luego despliega tu adaptador en Hadrian, financia la cuenta de tokens del usuario, envía la concesión SPL al adaptador y ejecuta el depósito a través de `eth_estimateGas` con la dirección del usuario como `a partir de`. La estimación debería tener éxito. Si falla, los datos del revert nombran el error de Solana.

<details>

<summary>1. Un usuario de MetaMask deposita a través de tu adaptador. ¿Quién firma para tu programa?</summary>

La PDA de autoridad externa del adaptador, más cualquier sub-PDA salteado que el adaptador indique. No el usuario. Los derechos del usuario provienen de la delegación SPL que concedió.

</details>

<details>

<summary>2. ¿Por qué no retirar los USDC del usuario con el <code>transferFrom</code>?</summary>

Los tokens terminarían en la cuenta de custodia del wrapper y quedarían registrados en su libro mayor. El adaptador no tendría ninguna cuenta de tokens propia que pasar a tu programa.

</details>

<details>

<summary>3. Tu depósito crece hasta que hace diez CPIs y Rome lo ejecuta de forma iterativa. ¿Qué ocurre?</summary>

Falla. Se rechaza una CPI de la ruta legacy en una transacción iterativa. Reduce la acción a un solo movimiento de tokens y una sola CPI, o divídela en dos transacciones.

</details>

## Siguiente

[9. Construye una app de doble carril](https://docs.rome.builders/es/rome-academy/09-build-a-dual-lane-app.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/08-open-your-solana-program-to-evm-users.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.
