> 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/05-call-solana-from-solidity.md).

# 5. Llama a Solana desde Solidity

Usa los precompilados CPI y Helper de Rome para leer cuentas de Solana, crear cuentas de tokens y llamar a programas de Solana desde un contrato de Solidity.

En Rome, un contrato de Solidity puede leer cuentas de Solana y llamar a programas de Solana en la misma transacción. Aprenderás a leer el saldo de un token de Solana, crear una cuenta de token y cómo construir una llamada a un programa.

## Lo que aprenderás

* Qué es un precompilado en Rome y cuáles tres usarás más.
* La firma que ve un programa de Solana cuando tu contrato lo llama.
* Cómo leer el estado de Solana y crear una cuenta de token desde Solidity.
* Las reglas que deciden si una llamada de Solana funciona: cuentas declaradas, una sola pista, solo atómica.

## Antes de empezar

* Termina [4. Cómo Rome ejecuta tu código](https://docs.rome.builders/es/rome-academy/04-how-rome-runs-your-code.md). El presupuesto atómico y el límite de 64 cuentas importan aquí.
* Ten financiada tu billetera de Hadrian y funcionando tu configuración de despliegue de la lección 3. Los grifos están listados en [Faucets](https://docs.rome.builders/es/recursos/faucets.md).
* Instala las interfaces de Solidity de Rome desde el `rome-solidity` repositorio, como se describe en [Despliega Solidity](https://docs.rome.builders/es/guias-para-desarrolladores/deploy-solidity.md#using-the-rome-solidity-sdk).

## Los precompilados son la puerta

Un precompilado es una dirección fija que ejecuta código nativo en lugar de bytecode. Ethereum tiene algunos, como `ecrecover`. Rome añade precompilados cuya tarea es llegar a Solana. Los llamas como cualquier contrato, a través de una interfaz.

Usarás tres:

| Precompilado  | Qué te proporciona                                                                                                           |
| ------------- | ---------------------------------------------------------------------------------------------------------------------------- |
| CpiProgram    | `invoke` y `invoke_signed` para llamar a cualquier programa de Solana, además de vistas de solo lectura de cuentas de Solana |
| HelperProgram | Operaciones listas para usar sobre tokens y cuentas: crear una cuenta de token, transferir tokens SPL, derivar direcciones   |
| System        | Derivación de PDA y conversión a base58                                                                                      |

Las direcciones están en [Referencia de precompilados](https://docs.rome.builders/es/referencia/precompiles.md) y [Direcciones de contrato](https://docs.rome.builders/es/referencia/contract-addresses.md). No necesitas escribirlas. Importar `interface.sol` a partir de `rome-solidity` te da constantes listas para usar llamadas `CpiProgram`, `HelperProgram` y `SystemProgram`.

## Quién firma

Cuando tu contrato llama a un precompilado, Solana ve la propia identidad de tu contrato, no la del usuario. Cada dirección EVM tiene una dirección derivada por programa de Solana, su PDA de autoridad externa. Posee las cuentas de token de esa dirección y firma en su nombre.

Esta es la misma regla que conoces de ERC-20: un contrato no puede mover los activos de un usuario a menos que el usuario lo haya autorizado. La lección 6 muestra cómo el usuario lo autoriza en Rome. La regla y las tres maneras de mantener la posición de un usuario están en [Integra un programa de Solana](https://docs.rome.builders/pages/52b676b8d62317a0f46fd6ed850e41457cb887c8#id-1.-every-evm-address-has-one-solana-identity).

## Paso 1: lee antes de escribir

Empieza con lecturas. No cambian ningún estado y funcionan en la ejecución atómica e iterativa. Lee antes de mutar: una vez que se ha ejecutado una llamada almacenada en caché, las lecturas de la pista heredada se rechazan durante el resto de la transacción.

```solidity
import "@rome-protocol/rome-solidity/contracts/interface.sol";

contract SolanaPeek {
    // La cuenta de token que Rome usa para el llamante y la mint de gas de la cadena
    function myTokenAccount() external view returns (bytes32) {
        return HelperProgram.ata(msg.sender, SystemProgram.mint_id());
    }

    // El saldo del llamante en esa cuenta
    function myBalance() external view returns (uint64) {
        return HelperProgram.user_balance(msg.sender, SystemProgram.mint_id());
    }
}
```

Las direcciones de Solana son `bytes32` aquí, no direcciones de 20 bytes. Las otras lecturas, `account_info`, `account_data_at` y `account_u64_at`, te permiten inspeccionar cualquier cuenta de Solana. Consulta [Lectura de datos de cuentas](https://docs.rome.builders/es/guias-para-desarrolladores/call-solana-from-evm.md#reading-account-data).

## Paso 2: usa un asistente

Para tareas comunes no necesitas construir una instrucción manual. El Helper crea cuentas de token, mueve tokens SPL y lamports, y convierte entre gas y lamports. Las firmas están en `contracts/interface.sol`, y un contrato de ejemplo está en [Transferir lamports](https://docs.rome.builders/es/guias-para-desarrolladores/call-solana-from-evm.md#transfer-lamports).

```solidity
function createMyAta() external {
    HelperProgram.create_ata(msg.sender, SystemProgram.mint_id());
}
```

Un contrato que llama al Helper actúa como sí mismo. Los tokens que mueve son propios, no del usuario.

## Paso 3: llama a cualquier programa de Solana

Para un programa que los helpers no cubren, construye tú mismo la lista de cuentas y los bytes de instrucción y llama a `invoke`. Cada cuenta es un pubkey más dos banderas, firmante y escribible. Los datos de la instrucción son lo que el programa objetivo espera, normalmente Borsh.

El contrato completo está en [Llamada a programas personalizados de Solana](https://docs.rome.builders/es/guias-para-desarrolladores/call-solana-from-evm.md#calling-custom-solana-programs). `invoke_signed` añade sub-PDA con sal cuando el destino necesita más de un firmante de tu contrato. Para obtener la dirección de una PDA dentro de Solidity, usa `find_program_address` en el precompilado System; consulta [Derivación de PDA](https://docs.rome.builders/es/guias-para-desarrolladores/call-solana-from-evm.md#pda-derivation).

## Las reglas que deciden si funciona

* **Declara cada cuenta.** Solana necesita la lista completa de cuentas antes de que se ejecute la llamada. El proxy la encuentra emulando primero tu transacción, así que cada cuenta debe poder derivarse de entradas que tenga el contrato. El total debe mantenerse dentro del límite de 64 direcciones.
* **Mantén la atomicidad.** Una llamada que hace una CPI de la pista heredada no puede ejecutarse de forma iterativa. Tiene que caber en una sola transacción atómica, así que limita cada acción a un solo movimiento de token y una sola CPI.
* **Elige una sola pista.** Rome tiene dos familias de precompilados que cambian el estado de Solana: heredados (`CpiProgram`, `HelperProgram`, `Withdraw`) y en caché (el `...En caché` conjunto). Una transacción usa una sola familia. Solo la pista heredada puede llamar a un programa personalizado. Lee la tabla en [Integra un programa de Solana](https://docs.rome.builders/pages/52b676b8d62317a0f46fd6ed850e41457cb887c8#id-4.-one-track-per-contract-and-per-transaction).
* **Mantén la profundidad baja.** Tu llamada a un programa de Solana usa niveles de CPI, y lo mismo hace cada programa al que llama a su vez. El límite de profundidad de Solana es bajo. [Restricciones](https://docs.rome.builders/es/conceptos-basicos/constraints.md#cpi-constraints) explica los niveles.
* **Sin llamadas de regreso a Rome.** Una CPI no puede nombrar ni llamar al programa de Rome. No puede nombrar al pagador de tarifas de Solana excepto en una instrucción simple de transferencia del Sistema.

## Compruébalo tú mismo

Añade `createMyAta` a `SolanaPeek` y desplégalo en Hadrian. Luego:

1. Llama a `myTokenAccount` y `myBalance` con una llamada de lectura desde la dirección de tu billetera.
2. Envía una transacción que llame a `createMyAta`.
3. Abre la transacción en el explorador de Hadrian. Consulta [Vía explorador](https://docs.rome.builders/es/apps-en-rome/via.md).

Deberías ver la instrucción de Solana detrás de tu llamada y sus unidades de cómputo. Una llamada que llega a Solana muestra un programa de Solana en el explorador, no solo una llamada EVM.

<details>

<summary>1. Un contrato llama a <code>HelperProgram.transfer_spl</code>. ¿Los tokens de quién se mueven?</summary>

Los del propio contrato. El firmante es la PDA de autoridad externa del contrato. Para mover los tokens de un usuario, el usuario debe conceder primero un derecho.

</details>

<details>

<summary>2. ¿Por qué una llamada que usa <code>invoke</code> debe caber en una sola transacción atómica?</summary>

Las CPI de la pista heredada se rechazan dentro de una transacción iterativa. Si la llamada necesita más de una transacción de Solana, falla.

</details>

<details>

<summary>3. ¿En qué lecturas puedes confiar en cualquier modo de ejecución?</summary>

Las vistas de solo lectura: `account_info`, `account_data_at`, `account_u64_at`, `account_lamports`, `pdas_batch_derive` y las lecturas del Helper, como `user_balance`. No tienen efectos secundarios. Ejecútelas antes de cualquier mutación en caché en la misma transacción.

</details>

## Siguiente

[6. Tokens en ambos lados](https://docs.rome.builders/es/rome-academy/06-tokens-on-both-sides.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/05-call-solana-from-solidity.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.
