> 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/13-build-on-solgate.md).

# 13. Construye sobre Solgate

Desarrolla sobre Solgate, el puente y la ruta de mensajes entre Solana, Ethereum y las cadenas de AggLayer. Descubre qué se transfiere, cómo fluyen los mensajes, cuánto cuestan y cómo pasar de Hadrian a Rubicon.

Rome convierte EVM y Solana en un único mercado. Solgate es el puente y la ruta de mensajes entre ambas. Lleva tokens de Solana a Ethereum y a las cadenas de AggLayer, y tokens de EVM a Solana. También transporta mensajes entre contratos, y el contrato de Rome que recibe uno puede llamar a un programa de Solana en la misma transacción. En esta lección verás qué puede cruzar, cómo fluye un mensaje, qué debes comprobar en un contrato receptor y cómo desarrollar en Hadrian ahora y desplegar en Rubicon. [Lección 10](https://docs.rome.builders/es/rome-academy/10-from-other-chains.md) trata sobre Rome Bridge, que permite transferir USDC. Solgate es la ruta para otros tokens y para mensajes.

## Qué aprenderás

* Qué tokens cruzan en cada dirección y cómo un token sin un mint de Solana se puede transferir mediante el puente.
* Qué significan «Verified» y «Unverified», y cómo los usuarios añaden un token a su monedero.
* Cómo fluye un mensaje de Ethereum a Rome y, desde allí, a un programa de Solana, y viceversa.
* Los tiempos y costes medidos en Hadrian y Sepolia.
* Las reglas que debe seguir un contrato receptor y qué tipos de mensajes no son adecuados.
* Por qué usar Solgate y en qué confías en cada dirección.
* Cómo empezar en Hadrian y qué cambia en Rubicon.

## Antes de empezar

* Completa [10. Traer usuarios y fondos de otras cadenas](https://docs.rome.builders/es/rome-academy/10-from-other-chains.md). Necesitas conocer el concepto de una reclamación de puente.
* Lee [5. Llamar 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). Un contrato receptor que llama a Solana usa el precompilado CPI, y un token de Solana en Rome es el propio mint.
* Ten una cartera de Hadrian con fondos, una cartera de EVM con ETH de Sepolia y una cartera de Solana con SOL de devnet. El paso 7 enumera los faucets.

## La lección

### Paso 1. Comprende qué puede cruzar

Solgate transporta una forma de cada token por cadena: la que está registrada en la cadena. Primero, elige la dirección.

**De Solana a Ethereum y a las cadenas de AggLayer**

| Token                                                                                                                               | ¿Cruza?                                                                             |
| ----------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------- |
| SOL                                                                                                                                 | Sí, como «Wrapped SOL (Rome)»                                                       |
| Tokens SPL clásicos, incluidas las meme coins                                                                                       | Sí. En la red de prueba, elige o pega el mint; el primer envío lo registra          |
| Token-2022 cuya única función adicional es congelar                                                                                 | En la red de prueba. Aún no en la red principal                                     |
| Token-2022 con una comisión por transferencia                                                                                       | No se transfiere                                                                    |
| Otros Token-2022 (ganchos de transferencia, delegado permanente)                                                                    | Permanece en Solana y Rome, donde la EVM de Rome sigue usándolo                     |
| Mints no transferibles, NFT                                                                                                         | No                                                                                  |
| Tokens que otro puente llevó a Solana, cuando AggLayer llega a su cadena de origen (por ejemplo, ETH transferido mediante Wormhole) | No se transfieren por segunda vez. Transfiere el original desde su cadena de origen |
| USDC                                                                                                                                | Se transfiere mediante CCTP de Circle, no Solgate                                   |

**De Ethereum y las cadenas de AggLayer a Solana**

| Token                                                                         | ¿Cruza?                                                                                                    |
| ----------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------- |
| ETH                                                                           | Sí, como «Ether (Rome)», con 9 decimales en Solana                                                         |
| ERC-20 estándar                                                               | Sí, como «\<name> (Rome)», un mint SPL clásico. En la red de prueba, la configuración no requiere permisos |
| ERC-20 con comisión por transferencia                                         | Sí. El puente registra lo que recibió                                                                      |
| Tokens cuyo emisor tiene su propia ruta a Solana (CCTP de Circle y similares) | Usar la ruta del emisor                                                                                    |
| Tokens permisionados (ERC-3643 y similares)                                   | Solo la ruta propia del emisor                                                                             |
| Tokens con rebase                                                             | No. Transferir el wrapper sin rebase                                                                       |
| Copias creadas por otro puente cuando AggLayer llegue a su cadena de origen   | No se puentean dos veces                                                                                   |

Reglas que se aplican a todos los tokens:

* Solgate admite una forma de cada token por cadena. Las formas creadas por otros puentes permanecen separadas y nunca se fusionan.
* Todos los tokens que crea Rome se llaman «\<origin name> (Rome)» y conservan el símbolo del token de origen.
* Solana almacena el suministro en 64 bits, por lo que los tokens con más de 9 decimales tienen 9 en Solana. Las cantidades se transfieren en unidades enteras de Solana. El polvo por debajo de una unidad permanece en el puente como respaldo.
* La mint de Solana que crea Rome no tiene autoridad de congelación. Su única autoridad de acuñación es el contrato del token en Rome.
* En Rome, un token de Solana es la mint. El saldo de Rome de una billetera corresponde a su propia cuenta de tokens de Solana, sin una segunda copia envuelta.
* Por el momento, Solgate no transfiere tokens originados en una cadena de Rome.

Un token que aún no tiene una mint de Solana puede habilitarse para el puente en unos pocos pasos firmados. En la red de prueba, cualquiera puede hacerlo desde una billetera EVM o Solana. En la red principal, Rome incluye los tokens en su lista.

1. **Token originado en EVM.** Envíalo primero a Hadrian. Su primera reclamación allí crea su copia en Rome. Luego abre **Añadir un token** y pega cualquier formato: una palabra, la dirección en la cadena de origen, la dirección de Rome o una mint de Solana.
2. **Firma los pasos numerados.** Son la configuración, un logotipo opcional y la finalización. Una billetera Solana solo paga en SOL y nunca necesita gas de Rome, porque el relé de Rome envía la transacción de finalización en su nombre. La tarjeta muestra el costo total antes de que firmes. La tarifa de configuración de Hadrian es de 1 USDC o 0,06 SOL, más las tarifas de red.
3. **Token originado en Solana.** Selecciona o pega la mint en Bridge. El primer envío la añade al puente y la incluye en la lista mediante pasos que solo se realizan una vez.

El logotipo es opcional, gratuito y requiere una firma más. El archivo debe pesar menos de 256 KB y estar en formato PNG, ya que es posible que las billeteras de Solana no muestren SVG. Puedes añadirlo más tarde desde My tokens.

### Paso 2. Indica a los usuarios qué está verificado y permíteles añadir el token

Los tokens verificados aparecen en la lista de verificados de Rome. Todo lo demás que se configure mediante la ruta abierta aparece como **Sin verificar**. La pestaña **Tokens** muestra todos los tokens. Los usuarios pueden buscar por nombre, símbolo o cualquier dirección. Cada fila muestra el logotipo, la etiqueta y la ruta; al expandirla, aparecen las direcciones por cadena con enlaces para copiarlas y abrirlas en el explorador, **Añadir a la billetera** y **Bridge**. La opción «Solo verificados» está activada de forma predeterminada.

Criterios para estar verificado: un contrato real en su cadena de origen, acreditado por una ficha en CoinGecko o CoinMarketCap, o por el sitio del emisor; un logotipo; y no suplantar la identidad de un token verificado.

Las billeteras y los exploradores realizan sus propias verificaciones. En la red principal de Solana, el orden habitual es una ficha en CoinGecko o CoinMarketCap, seguida de la actualización de reputación de Solscan y la verificación de Jupiter. Solflare asigna su propia etiqueta automáticamente.

En las filas de Tokens, en My tokens y en la pantalla de recepción, las billeteras EVM ofrecen la opción de un clic **Añadir a la billetera** (EIP-747). Las billeteras de Solana obtienen el nombre, el símbolo y el logotipo del token de sus metadatos en la cadena.

### Paso 3. Seguir un mensaje

Cualquier contrato en Ethereum o en una cadena de AggLayer puede enviar un mensaje a un contrato en Rome y viceversa. El estado de Rome reside en Solana, por lo que el contrato receptor de Rome puede llamar a cualquier programa de Solana en la misma transacción, firmada por su propia PDA, una cuenta de Solana que solo ese contrato puede usar para firmar. Del mismo modo, un programa de Solana puede enviar un mensaje a través de Rome.

Necesitas la mensajería cuando el actor es un contrato (una DAO, un ejecutor de gobernanza, una bóveda, un depósito en garantía o una Safe) o cuando Solana debe actuar en una cadena EVM. Una persona con una billetera EVM no la necesita, porque puede usar la misma dirección directamente en Rome.

```
Cadena de Ethereum / AggLayer               Rome (EVM, estado en Solana)                  Solana
remitente ─ bridgeMessage(rome, rcvr, …, data) ─► el comité de Rome publica la raíz de salida
                                          cualquiera: claimMessage(proof, data)
                                          └► rcvr.onMessageReceived(origin, net, data)
                                               └► CPI opcional mediante 0xFF..08,
                                                  firmada por la PDA del receptor ──────► cualquier programa

Programa de Solana ─ CPI al programa EVM de Rome, firmada por su PDA ─► bridgeMessage(dest, rcvr, data)
                                          El certificado de Rome se confirma en Ethereum ─► cualquiera puede reclamar en el destino
```

En la entrada, el emisor llama a `bridgeMessage`. El comité de Rome publica en Rome la raíz de salida de Ethereum. Después, cualquiera puede llamar a `claimMessage` con la prueba, y el puente llama a `onMessageReceived` en tu receptor. En la salida, un programa de Solana llama al programa EVM de Rome, que llama a `bridgeMessage`. El certificado de Rome se confirma en Ethereum y cualquiera puede reclamar en el destino.

### Paso 4. Consulta los tiempos medidos

Estas transferencias se ejecutaron en Hadrian y Sepolia.

| Transferencia                                                         | Resultado                                                                                      | Tiempo hasta que se puede reclamar | Coste en Hadrian                                               |
| --------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------- | ---------------------------------- | -------------------------------------------------------------- |
| Contrato de Sepolia → contrato de Rome                                | Entregado                                                                                      | 133–158 s                          | 0,096 $ a un receptor nuevo; 0,0007 $ después                  |
| Sepolia → contrato de Rome → programa Memo de Solana, una reclamación | Memo se ejecutó; la PDA del receptor firmó                                                     | 158 s                              | 0,096 $ a un receptor nuevo                                    |
| Valor en ETH con un mensaje hacia Rome                                | Llega como un saldo ordinario de ETH envuelto                                                  | 396 s (durante un pico de pruebas) | $0.19                                                          |
| Token y mensaje en una sola transacción de Sepolia                    | 5 de 5 entregados; primero se reclamó el token                                                 | No registrado                      | $0.175 + $0.119                                                |
| El receptor rechaza y luego acepta                                    | La simulación de la API rechazó la reclamación, así que no se envió nada; se ejecutó más tarde | 412 s                              | 0,0007 $ por la reclamación aceptada                           |
| Contrato de Rome → contrato de Sepolia                                | Entregado y reclamado                                                                          | 317 s                              | 0,0007 $ por el envío; 446.636 de gas para reclamar en Sepolia |
| Programa de Solana → Rome → salida                                    | Enviado en una sola transacción de Solana; todavía no se ha reclamado en Sepolia               | n/a                                | 5.000 lamports + un cargo de Rome (no registrado)              |

Un mensaje bridgeMessage de Sepolia `bridgeMessage` con una actualización forzada de la raíz de salida consumió entre 395.000 y 400.000 de gas. El gas de la cadena de origen es un coste adicional a los costes de Hadrian indicados arriba.

Aún no se han probado: la red principal, los mensajes entre L2 de AggLayer, una billetera de Solana como emisor, el envío de valor desde Rome, el envío de valor junto con una llamada a Solana, un receptor de gobernanza realista y una reclamación iterativa.

### Paso 5. Escribe un receptor seguro

* **Comprueba quién llama y cuál es el origen.** `msg.sender` debe ser el puente. `(originNetwork, originAddress)` debe ser el remitente en quien confías.
* **Exactamente una vez es tuya.** Una reclamación revertida sigue siendo reclamable y se puede volver a intentar; además, el rol de Rome que elimina la raíz de salida del puente puede cancelar una reclamación. Conserva tu propio nonce.
* **Nadie reclama automáticamente.** Tu aplicación ejecuta un reclamador, o el usuario reclama. El reclamador paga el gas del destinatario.
* **El valor que entra** llega como ETH envuelto en Rome. **El valor que sale** solo se envía como ETH envuelto (`bridgeMessageWETH`, en múltiplos de 1e9 wei), y esta ruta aún no se ha ejecutado. El USDC de gas de Rome se transfiere mediante CCTP, nunca a través de AggLayer.
* **Un destinatario que llama a Solana recibe mensajes de valor cero.** Envía el valor como un token separado en la misma transacción de origen y comprueba en el destinatario que haya llegado.
* **Mide tu cómputo.** Una transacción de Solana permite aproximadamente 1,35 M de CU y la estimación de gas rechaza valores superiores a aproximadamente 1,25 M. La reclamación Memo-CPI usó 813 199 CU, lo que deja entre 0,44 y 0,54 M de CU aproximadamente para más trabajo en Solana. Todavía no se han medido instrucciones más grandes ni cantidades mayores de cuentas. Para tareas más pesadas, como un intercambio en un DEX o un préstamo, estaciona el mensaje y ejecútalo después en una segunda transacción.
* **Mantén los mensajes pequeños.** Reclamar un mensaje de 16 bytes ya supone aproximadamente 2,4 KB de datos de llamada.
* **Limita lo que puede desbloquear un solo mensaje de Rome** en el destino, con un límite o una demora. Los mensajes salientes dependen únicamente de los firmantes de Rome.

Los mensajes no son adecuados para intents, ejecuciones rápidas, liquidaciones ni feeds de precios. De Sepolia a Rome se tardó entre 133 y 412 s, y una ruta L2 de AggLayer añade la liquidación propia de esa cadena. Tampoco son adecuados para trabajo pesado en Solana dentro de una sola reclamación ni para comprar tokens de Solana mediante mensajes.

### Paso 6. Comprende por qué Solgate y en qué confías

* **Se liquida a través de AggLayer de Polygon en Ethereum.** Rome ejecuta sin modificaciones los contratos del puente de AggLayer de Polygon. Los certificados salientes de Rome se liquidan en Ethereum con la prueba pesimista de AggLayer.
* **No cuenta con una red de validadores independiente para el puente.** Las partes son Ethereum, AggLayer y las propias claves de Rome: un comité 2 de 3 para las entradas y los firmantes de AggLayer de Rome para las salidas.
* **Es un solo mercado.** En Rome, un token de Solana es la misma mint, no una versión envuelta de ella. El saldo de una billetera de Solana en Rome está en su propia cuenta de tokens, y los contratos de Rome transfieren los mismos tokens SPL.
* **Es programable en ambos lados.** Un mensaje de EVM puede activar un programa de Solana en la transacción en la que se ejecuta. Un programa de Solana puede enviar un mensaje a través de Rome.
* **En la testnet, la configuración no requiere permisos y se puede realizar desde cualquiera de las dos billeteras.** Una billetera de Solana solo paga SOL. Un token de EVM se convierte en una mint SPL clásica sin autoridad de congelación y solo lo acuña su contrato en Rome.
* **Hay un único formato por cadena; no se vuelve a envolver un token envuelto.** Rome marca lo que crea con «(Rome)», deja los tokens con una ruta del emisor en esa ruta y nunca vuelve a transferir una copia de otro puente.
* **Es una sola conexión a AggLayer.** El mismo puente unificado conecta con Ethereum y con todas las cadenas de AggLayer que incluya la aplicación.
* **Compara los modelos de confianza.** Wormhole, LayerZero, CCIP y otros también conectan Solana con cadenas EVM; cada uno tiene su propio modelo de confianza. Compara la tabla siguiente con los modelos de estos servicios para decidir cuál te conviene.

| Dirección                                | En qué confías                                                                                                                                                                                                                                 |
| ---------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Ethereum → Rome                          | Ethereum y un comité 2 de 3 que publica en Rome la raíz de salida de Ethereum. El Safe de Rome controla el comité, protegido por un bloqueo temporal.                                                                                          |
| Cadena de AggLayer → Rome                | Lo anterior, más el certificado de esa cadena liquidado en Ethereum                                                                                                                                                                            |
| Rome → Ethereum o una cadena de AggLayer | Los firmantes de AggLayer de Rome. La prueba pesimista limita cada token procedente de otra cadena a la cantidad recibida. Los mensajes y los tokens cuyo origen en AggLayer es Rome (SOL y otros tokens de Solana) dependen de los firmantes. |

### Paso 7. Empieza en Hadrian

La aplicación está en [solgate.testnet.romeprotocol.xyz](https://solgate.testnet.romeprotocol.xyz). Incluye las secciones Bridge, Add a token, Tokens, Claim, Activity y How it works. La lista de cadenas activa está en `GET /v1/chains`.

| Cadena           | Red AggLayer | ID de cadena | Notas                                                                                                                       |
| ---------------- | ------------ | ------------ | --------------------------------------------------------------------------------------------------------------------------- |
| Rome Hadrian     | 74           | 200010       | RPC `https://hadrian.testnet.romeprotocol.xyz/`, explorador `via-hadrian.testnet.romeprotocol.xyz`; estado en Solana devnet |
| Ethereum Sepolia | 0            | 11155111     | Lo reclamas tú mismo                                                                                                        |
| Katana Bokuto    | 37           | 737373       | Lo reclamas tú mismo                                                                                                        |
| Billions Testnet | 32           | 6913         | Lo reclamas tú mismo                                                                                                        |

Tokens de prueba:

* **SOL de Solana devnet.** faucet.solana.com. Una cartera de Solana no necesita nada más en Solgate.
* **Gas de Hadrian (USDC).** USDC de prueba de la faucet de Circle (faucet.circle.com), transferidos a tu dirección EVM como gas de Hadrian mediante la testnet de Rome Bridge (bridge-api.devnet.romeprotocol.xyz). Elige una testnet de origen que aparezca en la lista de Rome Bridge.
* **ETH de Sepolia.** Cualquier faucet pública de Sepolia.
* **Tokens ERC-20 de Sepolia ya verificados en Hadrian.** Tokens de la faucet de Sepolia de Aave (DAI, USDT, WBTC, AAVE, EURS). O despliega los tuyos y configúralos.

Contratos y código que puedes consultar:

* Puente Rome Hadrian: `0x5366e5864cb9dba587a706d8dd48cfdc40b961af` (red 74). Puente de Sepolia: `0x528e26b25a34a4A5d0dbDa1d57D318153d2ED582` (red 0).
* Puente de Polygon: `github.com/agglayer/agglayer-contracts`. Lee `AgglayerBridge.sol` y `AgglayerBridgeL2.sol` (`bridgeMessage`, `bridgeMessageWETH`, `claimMessage`) y la `IBridgeMessageReceiver` interfaz (`onMessageReceived`).
* Precompilados de Solana de Rome: `github.com/rome-protocol/rome-solidity`, `contracts/interface.sol`. La CPI a cualquier programa está en `0xFF00…0008`, y el precompilado de tokens SPL está en `0xff00…0005`.
* Direcciones de tokens por cadena: `GET /v1/tokens`. Cadenas: `GET /v1/chains`. Interruptores activos: `GET /v1/switches`.

La API de mensajes está activa en Hadrian.

| Llama a                                      | Usa                                                                                                                                                                                                              |
| -------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `POST /v1/transfers` `{ networkId, txHash }` | Registra una transferencia que hayas minado. `networkId` es la red de origen                                                                                                                                     |
| `GET /v1/transfers?wallet=<address>`         | Tus registros                                                                                                                                                                                                    |
| `GET /v1/transfers?tx=<hash>`                | Los registros de una transferencia, con el token primero                                                                                                                                                         |
| `GET /v1/transfers/:id`                      | Un registro, con su etapa: enviado → certificado → liquidado → listo\_para\_reclamar → reclamado → recibido                                                                                                      |
| `GET /v1/transfers/:id/claim`                | La transacción de reclamación, simulada primero. Si el receptor provocaría una reversión, la respuesta es `message_would_fail`. La simulación no detecta si la reclamación supera el límite de cómputo de Solana |

### Paso 8. Pasa de Hadrian a Rubicon

Rubicon es la cadena de la red principal de Rome, con estado en la red principal de Solana y liquidación en AggLayer sobre la red principal de Ethereum. Solgate está activo en Rubicon en [solgate.romeprotocol.xyz](https://solgate.romeprotocol.xyz), con Ethereum, X Layer y Katana, y Rome publica allí la lista de tokens. Lo que construyas en Hadrian se traslada, con los ID de cadena y las direcciones modificados. Vuelve a medir los tiempos y los costos en la red principal, porque las cifras de Hadrian corresponden a una red de prueba. La migración general se describe en [11. Publicar en Rubicon](https://docs.rome.builders/es/rome-academy/11-ship-to-rubicon.md).

En la red principal: envíos en ambas direcciones y reclamación en Solana para SOL, ETH, USDT, WBTC y OKB; reclamación automática de depósitos de ETH desde Ethereum a una billetera EVM en Rubicon; la pestaña Tokens; los filtros de actividad y la tarjeta «Llegó». El seguimiento de mensajes, la configuración de tokens sin permisos desde cualquiera de las dos billeteras y el proceso de listado de tokens originados en Solana funcionan en la red de prueba y aún no están disponibles en la red principal. Consulta [Uso de Solgate](https://docs.rome.builders/es/apps-en-rome/solgate/using.md).

Qué cambia en la red principal:

* Gas real: USDC en Rubicon (transfiérelo con Rome Bridge) y ETH en Ethereum.
* Los tiempos de llegada dependen de la liquidación en la red principal: de Ethereum a Solana, unos 120 segundos; de Solana a Ethereum, unos 6 minutos; de Solana a X Layer, unos 18 minutos; de Solana a Katana, unos 4 minutos; y de Katana a Solana, unos 65 minutos. [Uso de Solgate](https://docs.rome.builders/es/apps-en-rome/solgate/using.md#times) los enumera.
* En la red principal, Phantom y Solflare añaden sus propias instrucciones a las transacciones.
* Las billeteras y los exploradores realizan sus propias comprobaciones de tokens (paso 2).
* El modelo de confianza es el mismo, con el comité y el conjunto de firmantes de la red principal de Rome.

Empieza a desarrollar en Hadrian. Publica en Rubicon cuando estés listo.

## Comprueba por tu cuenta

Haz un pequeño recorrido de ida y vuelta en Hadrian.

1. Despliega un ERC-20 de prueba en Sepolia, transfiere algunos tokens a Hadrian y luego ejecuta **Añadir un token** con una billetera EVM. Lee el total de la tarjeta antes de firmar.
2. Crea una emisión SPL en Solana devnet, selecciónala en Bridge con una billetera de Solana, envíala a Ethereum Sepolia y reclámala allí.
3. Escribe un receptor con las dos comprobaciones y un nonce. Envíale un mensaje desde un contrato de Sepolia y reclámalo con `GET /v1/transfers/:id/claim`.

Luego responde:

* ¿Qué dos valores comprueba un receptor antes de confiar en un mensaje?
* Un receptor llama a Solana y también debe recibir valor. ¿Cómo se lo envías?
* ¿Por qué los mensajes no son adecuados para una liquidación?

<details>

<summary>Respuestas</summary>

* `msg.sender`, que debe ser el puente, y `(originNetwork, originAddress)`, que debe ser el remitente de confianza.
* Envía el mensaje con valor cero. Envía el valor como un token independiente en la misma transacción de origen y comprueba en el receptor que haya llegado.
* El trayecto de Sepolia a Rome tardó entre 133 y 412 s, y una ruta de AggLayer L2 añade el tiempo de liquidación de esa cadena. Una liquidación no puede esperar tanto.

</details>

## Siguiente

En [Ideas de Solgate](https://docs.rome.builders/es/apps-en-rome/solgate/ideas.md). Las páginas de referencia son [Desarrollar en Solgate](https://docs.rome.builders/es/apps-en-rome/solgate/builders.md) para tokens y [Mensajería en Solgate](https://docs.rome.builders/es/apps-en-rome/solgate/messaging.md) para mensajes.

[Volver al mapa del curso](https://docs.rome.builders/es/rome-academy/academy.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/13-build-on-solgate.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.
