> 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/integrate-solana-program.md).

# Integrar un programa de Solana

Integra un programa de Solana con Rome EVM: quién es el firmante de Solana, cómo llega el valor a tu programa y vuelve, la regla de un solo recorrido, atómico frente a iterativo y aprovisionamiento de cuentas.

Esta guía es para un equipo de programa de Solana que quiere que los usuarios de Rome EVM usen su programa — un programa de privacidad, préstamos o bóveda que debería retener valor para cuentas EVM. Se basa en [Llamar a Solana desde EVM](https://docs.rome.builders/es/guias-para-desarrolladores/call-solana-from-evm.md) (la mecánica de los precompilados) y responde a las preguntas que surgen una vez que un programa real está al otro lado: *quién* firma, *cómo* cómo entran y salen los tokens, y *qué* límites dan forma al diseño.

El flujo usado a lo largo de todo el documento: una cuenta EVM mueve USDC a tu programa ("shield" o "deposit"), tu programa lo mantiene para ese usuario y, más tarde, lo devuelve ("unshield" o "withdraw"). Sustituye los verbos por los tuyos.

## 1. Cada dirección EVM tiene una identidad de Solana

Rome deriva una cuenta de Solana para cada dirección EVM — usuarios y contratos por igual — llamada su **autoridad externa**:

```
external_auth(addr) = find_program_address(["EXTERNAL_AUTHORITY", addr_h160], rome_evm_program_id)
```

Es propietaria de las cuentas de tokens asociadas de esa dirección (de ahí es de donde `wUSDC.balanceOf(addr)` lee) y es la clave que firma las CPI hechas en nombre de esa dirección. Tu programa ve una clave pública de Solana de 32 bytes; nunca ve un H160.

**Quién firma lo decide quién llama al precompile:**

| El precompile es llamado por                                                               | El firmante de Solana                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| ------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Una app **contrato**, con un `CALL`                                                        | Los **propia del contrato** autoridad externa (`external_auth(contract)`), más cualquier sub-PDA con sal del contrato que solicite                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| Una app **usuario**, en una transacción enviada directamente a la dirección del precompile | Los **propia del usuario** autoridad externa                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| Un contrato vía `DELEGATECALL`                                                             | La autoridad sin firma es rechazada (`DelegatecallOwnerAuthority`). `invoke` sin firmante, y `invoke_signed` con sub-PDAs con sal, aún se ejecutan — pero esos sub-PDAs se agrupan en un espacio de nombres por la dirección del contrato en ejecución (`["EXTERNAL_AUTHORITY", caller, running_contract, salt]`), así que `pda_with_salt` no los deriva. De HelperProgram solo pasan los selectores de creación y financiación (`create_ata*`, `create_pda*`, `swap_gas_to_lamports`, `init_spl_mint`, `create_and_init_mint`); están exentos porque su destino está vinculado al llamante o financiado por el operador, no porque no firmen nada |

La consecuencia es la regla ERC-20 que ya conoces: **un contrato no puede mover por sí solo los activos de un usuario.** Actúa como su propia identidad, y el usuario primero le concede derechos. Para los tokens que tienen que moverse en el lado de Solana, esa concesión es una delegación SPL en la cuenta de tokens del usuario; la ERC-20 del wrapper `approve` es solo una autorización del lado EVM que respetan las transferencias del propio wrapper. Así funcionan los wrappers de tokens propios de Rome, y así funcionará tu adaptador (sección 3).

Sub-PDAs con sal: `invoke_signed` toma una lista de `bytes32` salts, y Rome firma con `["EXTERNAL_AUTHORITY", caller_h160, salt]` por cada una (con bump añadido; el llamante es el contrato en una llamada directa). `HelperProgram.pda_with_salt(addr, salt)` devuelve la dirección desde Solidity. Usa una sal por usuario (por ejemplo, la dirección del usuario) cuando tu programa quiera una cuenta propietaria distinta por posición.

Financiación: un PDA de autoridad externa no tiene que existir para ser propietario de un ATA (`create_ata` es idempotente y el pagador de la comisión de Solana de la transacción cubre la renta). Solo debe existir y tener lamports cuando financia cuentas que crea tu instrucción. `HelperProgram.create_pda(addr)` lo crea como un System `CreateAccount`, así que llámalo una vez; no es idempotente. `swap_gas_to_lamports(n)` abona al PDA de la dirección con `n` lamports procedentes del pagador de la comisión de Solana de la transacción, y el llamante los paga en gas de Rome: el efecto de cada CPI de la pista legacy sobre el saldo del pagador de la comisión se añade a la comisión de la transacción y se cobra al usuario al precio del gas, del mismo modo que se cobra la renta de las cuentas que crea un CPI. El paso de aprovisionamiento de la vía de Solana se describe en [Llamar a EVM desde Solana](https://docs.rome.builders/es/guias-para-desarrolladores/call-evm-from-solana.md); un contrato aprovisiona su propio PDA en su constructor o en su primera llamada.

## 2. Tres formas de mantener la posición de un usuario

**A. Un contrato adaptador (recomendado para un adaptador reutilizable).** Un contrato Solidity hace de frente para tu programa. El usuario concede a la autoridad del adaptador una delegación SPL en su cuenta de tokens; el adaptador extrae los tokens a una cuenta de tokens que posee, llama a tu programa como sí mismo, y indexa la posición del usuario dentro de tu programa mediante un sub-PDA por usuario o mediante un identificador que pasa en los datos de la instrucción. En la salida, le indica a tu programa que libere a la propia cuenta de tokens del usuario. El adaptador es la única identidad de Solana que tu programa necesita conocer. La concesión es una delegación SPL, no una ERC-20 `approve`; la sección 3 explica por qué y qué coste tiene para el usuario.

**B. El usuario como firmante de Solana.** El frontend envía una transacción desde la cuenta EVM del usuario **directamente al precompile CpiProgram** (`to = 0xff…08`, calldata = el ABI codificado `invoke` ni `invoke_signed`), así que la propia autoridad externa del usuario firma y tu programa indexa la posición por ella. No hay contrato adaptador ni delegación, pero cada acción es una transacción opaca de calldata en la cartera, y cualquier cosa que el flujo necesite aparte del CPI (el ATA, una transferencia previa) es una transacción separada. Encaja para concesiones de una sola vez (la `approve_spl` del usuario a un wrapper) y para programas simples, no para flujos de varios pasos. [Cardo](https://github.com/rome-protocol/cardo) usa esta forma: su frontend envía el `invoke` directamente al precompile desde la cartera del usuario.

**C. Un router sin custodia.** Un contrato que nunca retiene los tokens del usuario. El usuario concede a la autoridad del router una delegación SPL sobre su propia cuenta de tokens; el router hace CPI a tu programa con esa autoridad como autoridad de transferencia, de modo que los tokens se mueven desde la cuenta de tokens del usuario a la cuenta de tu programa (o de vuelta a la del usuario), y el router no retiene nada entre llamadas. El router deriva cada cuenta del lado del usuario a partir de `msg.sender`, así que la concesión de un usuario no puede apuntar a la cuenta de otro usuario, y llama a un programa fijo con formas de instrucción fijas en lugar de actuar como un `invoke` passthrough general. El `RomeDexRouter` en [rome-dex](https://github.com/rome-protocol/rome-dex) está escrito así; la vía EVM de rome-dex también ofrece el directo bruto `invoke` de la forma B. Necesita la misma concesión que A, con el mismo coste de un solo delegado (sección 3), y sin paso de pull.

El resto de esta guía sigue A; C usa la misma concesión y la misma regla de firma.

## 3. Tokens dentro, tokens fuera

USDC en Rome es una sola mint SPL vista desde dos lados: el `wUSDC` wrapper ERC-20 del lado EVM y el ATA de la autoridad externa del lado Solana. Para la propia dirección de un usuario, ambos son el mismo saldo: `wUSDC.balanceOf(user)` lee el ATA del usuario. Nada se mueve ni se sincroniza entre las dos vistas.

**El saldo del wrapper de un contrato no es una cuenta de tokens que el contrato controle.** La fábrica despliega `SPL_ERC20_cached` para una mint ordinaria, y la de Hadrian es una `wUSDC` . Ese wrapper no puede firmar por un contrato, así que cuando `wUSDC.transferFrom(user, adapter, amount)` ni `transfer` envía tokens a un contrato, los tokens SPL se mueven al **propio token account de escrow del wrapper** (`escrow_ata()`), y el wrapper registra la cantidad por contrato en su almacenamiento. `wUSDC.balanceOf(adapter)` devuelve ese registro, un libro mayor de escrow, no el saldo de una cuenta de tokens propiedad de `external_auth(adapter)`. Tu adaptador no puede entregar esos tokens a tu programa en un CPI; solo pueden salir otra vez a través del wrapper. Así que un adaptador que se financia con `transferFrom` no tiene nada que pueda gastar del lado de Solana.

La ruta que funciona es una delegación SPL:

* **Otorgamiento.** El usuario envía `approve_spl(adapter, amount, mint)` como una transacción **directamente al HelperProgram** (`to = 0xff…09`), donde `mint` es el `mint_id()`. La propia autoridad del usuario firma, y el delegado que establece en la cuenta de tokens del usuario es la autoridad externa del adaptador.
* **Entrada.** Del adaptador `deposit(amount)` extrae con la sobrecarga de delegado `HelperProgram.transfer_spl(srcAta, dstAta, amount, mint)`, con el ATA del usuario como origen y el ATA propio del adaptador (`HelperProgram.ata(address(this), mint)`, creado una vez con `create_ata`) como destino. La autoridad del adaptador firma como delegado. Los tokens están ahora en una cuenta de tokens propiedad de `external_auth(adapter)`, que es la cuenta que nombra tu CPI; el firmante y el origen son propios del adaptador, así que no se necesita más permiso. No aparecen en `wUSDC.balanceOf(adapter)`.
* **Salida.** La instrucción withdraw de tu programa transfiere al **ATA del** , `HelperProgram.ata(user, mint)`. Recibir no necesita firma del usuario, y el saldo es inmediatamente visible como `wUSDC.balanceOf(user)`. Si es posible que el ATA aún no exista, créalo primero con `HelperProgram.create_ata(user, mint)` (idempotente).

**Una cuenta de tokens tiene un delegado.** El otorgamiento anterior reemplaza el propio otorgamiento del wrapper sobre esa cuenta. Hasta que el usuario vuelva a otorgar permiso al wrapper, toda `wUSDC` `transfer` ni `transferFrom` salida desde su dirección revierte con el error SPL `0x4`. Después de cualquier flujo que use este otorgamiento, llama a `wUSDC.isEnabled(user)`; cuando devuelva `false`, pide al usuario que envíe `approve_spl(wrapper, 2^64-1, mint)` al HelperProgram de nuevo, la misma concesión máxima sobre la que está construido el wrapper (véase [Una sola vez: concede al wrapper](https://docs.rome.builders/es/guias-para-desarrolladores/dual-lane-app.md#one-time-grant-the-wrapper)). Una concesión con tope rompería las `wUSDC` transferencias ordinarias del usuario de nuevo una vez que se agote, y `isEnabled` permanece `verdadero` mientras quede algo, así que la app no sabría que tiene que volver a pedirlo.

Para comprobar qué wrapper tiene una mint, lee el `wrapper_kind_by_mint(mint)` (la dirección de la fábrica está en el `contracts.json` en el [registro](https://github.com/rome-protocol/rome-registry)). `1` es el wrapper cacheado que describe esta sección. `2` es el wrapper de CPI directo que la fábrica despliega para una mint Token-2022 con un transfer hook armado; esta guía no lo cubre. El `tokens.json` enumera la dirección del wrapper y la mint, pero no qué tipo es.

## 4. Una pista por contrato y por transacción

Rome tiene dos familias de precompilados que cambian el estado de Solana, y **una transacción usa exactamente uno de ellos** — el runtime rechaza una transacción que mezcle llamadas mutantes de ambas, incluso entre contratos.

| Pista        | Precompilados                                                                                       | Los efectos aterrizan                                                                                                 | Funciona en ejecución iterativa                                                            |
| ------------ | --------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------ |
| **Legacy**   | `CpiProgram` `0xff…08` (`invoke`, `invoke_signed`), `HelperProgram` `0xff…09`, `Withdraw` `0x42…16` | Inmediatamente, como un CPI real dentro del paso EVM                                                                  | **No** — un CPI legacy en una transacción iterativa falla con `CpiProhibitedInIterativeTx` |
| **Cacheado** | `SplCached` `0xff…05`, `ASplCached` `0xff…06`, `SystemCached` `0xff…04`, `WithdrawCached` `0xff…0b` | Se preparan en una capa superpuesta y se confirman como CPI al final de la transacción; un revert de EVM los descarta | Sí                                                                                         |

Lo que esto significa para una integración de programa:

* **Llamar a las instrucciones de tu propio programa solo es posible en la pista legacy.** La pista cacheada no tiene un `invoke`; cubre transferencias SPL, creación de ATA, operaciones del programa del sistema y retirada de gas.
* Así que el paso que financia el adaptador también debe ser de pista legacy si se ejecuta en la misma transacción que el CPI. La `transferFrom` del wrapper cacheado es una llamada de pista cacheada, así que no puede compartir una transacción con tu CPI (y, como muestra la sección 3, solo abonaría un libro mayor de escrow). Extrae con `HelperProgram.transfer_spl(userAta, adapterAta, amount, mint)` en su lugar, después de que el usuario haya convertido al adaptador en el delegado SPL (`approve_spl`, enviado por el usuario directamente al HelperProgram). El pull y el CPI son ambos de pista legacy, así que se ejecutan en una sola transacción.
* **Mantén el wrapper fuera de esa transacción.** No llames a las funciones mutantes del wrapper (`wUSDC.transfer`, `transferFrom`) desde el adaptador en la misma transacción que un CPI legacy. Comprueba `isEnabled(user)` y los saldos desde el frontend con `eth_call`.
* **Y la transacción del CPI debe ser atómica.** Ese es el límite bajo el que se sitúa el diseño.

Las lecturas están fuera de la regla: `account_info`, `account_data_at`, `account_u64_at`, `account_lamports`, `pdas_batch_derive` y `HelperProgram.user_balance` / `allowance_of` son lecturas de cuentas precargadas (sin CPI), permitidas en cualquier pista y en ambos modos de ejecución. Coloca ahí tus comprobaciones previas. Una regla de orden: una vez que una mutación cacheada se ha disparado en una transacción, las lecturas de la pista legacy quedan bloqueadas durante el resto de la misma — primero lee, luego muta.

## 5. Lo atómico es el presupuesto

Una transacción atómica de Rome es una transacción de Solana: aproximadamente **1,4M unidades de cómputo**, una **lista de 64 direcciones** de cuentas y un **4 KB** tamaño en la red (transacciones Solana v1). El programa Rome y tu CPI comparten ese presupuesto. Una transferencia del wrapper consume unas 170K CU en Hadrian y tu instrucción añade las suyas; mídelo con el de la confirmación de Solana, `computeUnitsConsumed`no con EVM `gasUsed`.

Cuando la emulación decide que una transacción no cabe, Rome la ejecuta **de forma iterativa** a través de varias transacciones de Solana, y entonces un CPI legacy dentro de ella falla. Mantén tanto deposit como withdraw en un solo movimiento de tokens más un solo CPI hacia tu programa, y mantén pequeño el Solidity que los rodea. Divide cualquier cosa más grande en dos transacciones de usuario.

Profundidad del CPI: Solana permite 4 niveles y Rome usa uno, así que tu instrucción se ejecuta en el nivel 2 con dos niveles por debajo (tu programa → SPL Token deja uno).

## 6. Aprovisionamiento de cuentas

Tu programa no recibe sus cuentas desde Solidity en tiempo de ejecución. El proxy **emula** cada transacción antes de enviarla, registra cada cuenta de Solana que tocaron los CPI y las coloca en la transacción de Solana. Tu adaptador nombra las cuentas en la `invoke_signed` lista de cuentas; la emulación demuestra que resuelven. Se siguen tres cosas:

* Cada cuenta que toca tu instrucción debe poder derivarse de entradas que tiene el adaptador (su propio PDA y sub-PDAs, el ID de tu programa, las mints, la dirección del usuario). `SystemProgram.find_program_address` y `CpiProgram.pdas_batch_derive` hacen las derivaciones en Solidity.
* Una cuenta que todavía no existe (una posición nueva, un ATA nuevo) sigue teniendo que nombrarse en la lista de cuentas; su dirección es lo que llega a la transacción de Solana.
* Todo lo que toca la transacción — incluidas las cuentas propias de Rome para el usuario, el adaptador y el wrapper — debe mantenerse por debajo de 64 direcciones. Un diseño que toque diez mercados en una sola llamada no cabrá.

Para la vía de la cartera de Solana, `rome_emulateCallAccounts` expone el mismo descubrimiento a un cliente; el SDK lo usa.

Dos cuentas que un CPI nunca puede nombrar: el pagador de comisiones de Solana que envía la transacción (excepto dentro de una instrucción simple de transferencia del System) y el propio programa Rome. Se rechaza un CPI de vuelta al programa Rome.

## 7. Un deposit y un withdraw, en Solidity

Un esbozo mínimo de un adaptador en la pista legacy. El usuario ya ha enviado `approve_spl(adapter, amount, mint)` al HelperProgram (sección 3). `PRIVACY_PROGRAM` es el ID de tu programa; `encodeDeposit` / `encodeWithdraw` construyen los datos de tu instrucción (Borsh, little-endian); las account metas siguen el diseño de tu instrucción.

```solidity
import {ICrossProgramInvocation, IHelperProgram}
    from "@rome-protocol/rome-solidity/contracts/interface.sol";

contract PrivacyAdapter {
    ICrossProgramInvocation constant Cpi    = ICrossProgramInvocation(0xFF00000000000000000000000000000000000008);
    IHelperProgram          constant Helper = IHelperProgram(0xFF00000000000000000000000000000000000009);
    bytes32 constant SPL_TOKEN = 0x06ddf6e1d765a193d9cbe146ceeb79ac1cb485ed5f5b37913a8cf5857eff00a9; // TokenkegQ...

    bytes32 immutable PRIVACY_PROGRAM;
    bytes32 immutable USDC_MINT;

    constructor(bytes32 program, bytes32 mint) {
        PRIVACY_PROGRAM = program; USDC_MINT = mint;
        Helper.create_pda(address(this));                 // la propia identidad de Solana del adaptador
        Helper.create_ata(address(this), USDC_MINT);      // y una cuenta de USDC que posee
    }

    function _salt(address user) internal pure returns (bytes32) { return bytes32(uint256(uint160(user))); }

    function deposit(uint64 amount) external {
        bytes32 self       = Helper.pda(address(this));                   // firmante: la autoridad del adaptador
        bytes32 adapterAta = Helper.ata(address(this), USDC_MINT);
        bytes32 position   = Helper.pda_with_salt(address(this), _salt(msg.sender)); // sub-PDA por usuario, también firma

        // Extrae desde la cuenta de tokens del usuario. La autoridad del adaptador firma como el
        // delegado SPL que el usuario concedió; esta es una llamada de pista legacy, igual que el CPI de abajo.
        Helper.transfer_spl(Helper.ata(msg.sender, USDC_MINT), adapterAta, amount, USDC_MINT);

        ICrossProgramInvocation.AccountMeta[] memory accs = new ICrossProgramInvocation.AccountMeta[](5);
        accs[0] = ICrossProgramInvocation.AccountMeta(self,       true,  true);
        accs[1] = ICrossProgramInvocation.AccountMeta(position,   true,  true);
        accs[2] = ICrossProgramInvocation.AccountMeta(adapterAta, false, true);                          // origen: propiedad de la autoridad del adaptador
        accs[3] = ICrossProgramInvocation.AccountMeta(_vaultFor(position), false, true);                 // la bóveda de tu programa
        accs[4] = ICrossProgramInvocation.AccountMeta(SPL_TOKEN, false, false);

        bytes32[] memory salts = new bytes32[](1);
        salts[0] = _salt(msg.sender);
        Cpi.invoke_signed(PRIVACY_PROGRAM, accs, encodeDeposit(amount), salts);
    }

    function withdraw(uint64 amount) external {
        bytes32 position = Helper.pda_with_salt(address(this), _salt(msg.sender));
        bytes32 userAta  = Helper.ata(msg.sender, USDC_MINT);            // destino: la propia cuenta del usuario
        // ... misma forma: tu programa mueve `amount` desde la bóveda a userAta, firmado por `position`
        Cpi.invoke_signed(PRIVACY_PROGRAM, accs, encodeWithdraw(amount), salts);
    }
}
```

El adaptador nunca llama al `wUSDC` contrato. El pull es una llamada a HelperProgram que gasta la delegación del usuario, y los tokens quedan en una cuenta de tokens que `external_auth(adapter)` posee, por lo que el CPI puede gastarlos.

Notas sobre el firmante. Rome firma exactamente para dos tipos de cuenta: la autoridad sin firma del contrato llamante (`Helper.pda(address(this))`), que firma sin estar listado en `salts`, y un sub-PDA con sal por cada entrada en `salts`. Cada sal que enumeres debe aparecer en la lista de cuentas como firmante, o la llamada falla con `no se encontró la cuenta firmante calculada a partir de la semilla proporcionada`. Cualquier otra cuenta marcada como firmante, incluida la propia autoridad del usuario, no recibe ninguna semilla de Rome, y el runtime de Solana rechaza el CPI. Los derechos del usuario sobre sus tokens provienen de la delegación, nunca de que el adaptador firme como el usuario.

Delegación sin pull: si tu programa debe gastar directamente desde la cuenta de tokens del usuario, el usuario envía `HelperProgram.approve_spl_raw_delegate(userAta, yourProgramPda, amount, mint, decimals)` directamente al HelperProgram, nombrando el PDA de tu programa como delegado SPL. El puente de Rome usa esto para Wormhole. La regla de un solo delegado de la sección 3 también se aplica aquí: la concesión desplaza la del wrapper.

## 8. Pruebas

* Despliega contra **Hadrian** (testnet, chain 200010) primero; las direcciones y el RPC están en [Direcciones de contrato](https://docs.rome.builders/es/referencia/contract-addresses.md) y los [registro](https://github.com/rome-protocol/rome-registry).
* `eth_call` y `eth_estimateGas` ejecuta la misma emulación que usa el proxy para enviar, así que un CPI que falla allí falla en cadena por la misma razón, y los datos del revert llevan el error subyacente de Solana (`non-evm call error: …` en el registro del programa de Solana).
* Lee el lado de Solana de una transacción EVM ya aterrizada con `rome_solanaTxForEvmTx(hash)`; la confirmación de Solana es donde viven las CU y los registros de tu programa.
* Un CPI que funciona en `eth_call` pero se rechaza al enviarlo normalmente tropezó con un límite que reporta la emulación: el tope de 64 direcciones, el presupuesto atómico de CU (la transacción pasó a iterativa) o la regla de pista.

## 9. Referencia

* [Referencia de precompilados](https://docs.rome.builders/es/referencia/precompiles.md) — cada selector de cada precompile, con su clase de despacho y la regla de delegatecall.
* [Restricciones](https://docs.rome.builders/es/conceptos-basicos/constraints.md) — los límites anteriores en una sola tabla.
* [Interop de tokens](https://docs.rome.builders/es/conceptos-basicos/token-interop.md) — wrappers, mints canónicas, deposit y withdraw.
* Aplicaciones de referencia en los repos públicos: [cardo](https://github.com/rome-protocol/cardo) (el usuario llama directamente al precompile CPI, forma B), [rome-dex](https://github.com/rome-protocol/rome-dex) (directo `invoke` más un router sin custodia, forma C), y [aerarium](https://github.com/rome-protocol/aerarium) (una app de préstamos de Compound III sobre un único mercado compartido; no llama a programas de Solana desde Solidity (sin CPI), así que no es un ejemplo de adaptador).


---

# 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/integrate-solana-program.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.
