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

# Abre tu contrato a usuarios de Solana

Despliega un contrato Solidity en Rome (testnet Hadrian, mainnet Rubicon) y ábrelo a carteras de Solana: lo que necesita el contrato, cómo lo llama un usuario con cartera de Solana, direcciones por red y un lanza

Una sola implementación, dos tipos de usuarios. Un contrato en Rome es alcanzado por usuarios de MetaMask con su clave EVM y por usuarios de wallets de Solana (Solflare, por ejemplo) con su clave de Solana — misma dirección, mismo estado. Esta página es el recorrido de extremo a extremo: desplegar, hacer que el contrato esté listo para Solana, conectar el carril de Solana en tu app y lanzar en mainnet.

## 1. Despliega en la red que quieras

Las cadenas de Rome son destinos EVM estándar: Hardhat, Foundry, viem y ethers funcionan sin cambios (guía completa en [Desplegar contratos de Solidity](https://docs.rome.builders/es/guias-para-desarrolladores/deploy-solidity.md)).

| Red                                                                     | ID de cadena | RPC                                         | Explorador                                                                            | Token de gas   | Cómo obtener gas                                                                                                                                                                                                   |
| ----------------------------------------------------------------------- | ------------ | ------------------------------------------- | ------------------------------------------------------------------------------------- | -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| [**Rubicon**](https://docs.rome.builders/es/redes/rubicon.md) (mainnet) | `7531`       | `https://rubicon.mainnet.romeprotocol.xyz/` | [via-rubicon.mainnet.romeprotocol.xyz](https://via-rubicon.mainnet.romeprotocol.xyz/) | USDC           | Transfiere USDC desde Ethereum, Base, Arbitrum, Polygon, Avalanche, Monad u OP (CCTP) o desde Solana con el [Rome Bridge](https://bridge-api.mainnet.romeprotocol.xyz/); llega como gas                            |
| **Hadrian** (testnet)                                                   | `200010`     | `https://hadrian.testnet.romeprotocol.xyz/` | [via-hadrian.testnet.romeprotocol.xyz](https://via-hadrian.testnet.romeprotocol.xyz/) | USDC de prueba | Transfiere USDC de prueba desde una testnet ([Faucets](https://docs.rome.builders/es/recursos/faucets.md)) o envuélvelo desde una wallet de devnet de Solana en el [Rome App](https://app.devnet.romeprotocol.xyz) |

El gas es USDC con 18 decimales en el lado EVM; no hay un faucet de Rome en Rubicon ni en Hadrian. Las escrituras cuestan más gas de lo que sugiere la intuición de Ethereum, porque la mayor parte del costo es crear cuentas de Solana: un destinatario que nunca se ha usado, una nueva cuenta de token, un contrato desplegado. Usa `eth_estimateGas`, que es lo que hace la tooling estándar, y nunca codifiques 21,000. Medido en Hadrian, desplegar un contrato de 10 bytes estimó y consumió 1,147,921 gas, y una transferencia nativa a una dirección nunca usada 1,086,961, frente a 21,000 para una transferencia a una dirección existente. Rome cobra el gas realmente usado, que en estas mediciones nunca fue mayor que la estimación. Financia unos pocos USDC antes del primer despliegue. Verifica el origen en el explorador después ([Verificar contratos](https://docs.rome.builders/es/guias-para-desarrolladores/verify-contracts.md); el verificador de mainnet es `https://verify.mainnet.romeprotocol.xyz`).

Desarrolla en Hadrian y luego vuelve a desplegar los mismos artefactos en Rubicon con el chain id y las direcciones del wrapper de mainnet intercambiados; nada en el contrato cambia entre redes. Rubicon está en el registro público desde v0.3.0, pero `create-rome-app` y `rome-cli` siguen fijando el registro en v0.2.0, que no tiene entrada para Rubicon, así que no pueden apuntar a él; para esas herramientas, rellena los valores a mano desde [Rubicon](https://docs.rome.builders/es/redes/rubicon.md). El gas en Rubicon es USDC real a aproximadamente diez veces el precio del gas de Hadrian, así que allí un despliegue cuesta dinero real.

## 2. Qué hace que un contrato esté listo para Solana

La identidad EVM de un usuario de Solana es su **dirección sintética**, `keccak256(solana_pubkey)[12:]`: un `msg.sender`, con un nonce ordinario. La mayoría de los contratos no necesitan ningún cambio. Las tres cosas que importan:

* **Recibe valor como ERC-20, no como `msg.value`.** Los fondos de un usuario de Solana son tokens SPL en su wallet, vistos en el lado EVM como el wrapper del token (`wUSDC`, `wETH`, `wSOL`). El sintético no retiene nada en reposo y los activos del usuario llegan como el wrapper, así que retira con `transferFrom` después de un `approve` y devuelve con `transfer`. Cada usuario concede al wrapper su derecho de delegado SPL una vez antes del primer retiro ([Una sola vez: concede al wrapper](https://docs.rome.builders/es/guias-para-desarrolladores/dual-lane-app.md#one-time-grant-the-wrapper)). Un `pagadero` el punto de entrada solo funciona una vez que al sintético se le ha dado gas nativo (el `rome_composeExternalDepositV1`), cosa que el modelo de financiar y barrer no hace. Un vault ERC-20 existente, AMM o mercado de préstamo ya tiene la forma correcta.
* **Usa los wrappers canónicos.** Cada cadena tiene un wrapper por mint; las direcciones están en [Direcciones de contrato](https://docs.rome.builders/es/referencia/contract-addresses.md) (el de Hadrian también en el público [registro](https://github.com/rome-protocol/rome-registry)). Apunta los constructores a esas direcciones; no despliegues las tuyas propias.
* **Adapta el presupuesto atómico al punto donde una wallet firma.** Una wallet de Solana firma una transacción de Solana, así que una llamada por el carril de Solana debe caber en ella: alrededor de 1.4M unidades de cómputo, 64 cuentas, 4 KB ([Restricciones](https://docs.rome.builders/es/conceptos-basicos/constraints.md)). Medido en Hadrian: caben una transferencia, un approve y un suministro en Aave; un swap de Uniswap V3 cabe con poco margen (alrededor de 1.24M CU); un borrow en Aave no cabe y toma el camino de relay en la siguiente sección. Mide con el recibo de Solana, solicitando la transacción con `computeUnitsConsumed`, `maxSupportedTransactionVersion: 1` (las piernas de Rome son transacciones v1; sin eso el RPC rechaza la solicitud).

Lo que no necesitas: un programa de Solana, un puente, un segundo despliegue, ni ningún Solidity específico de Rome. Si el contrato también llama a programas de Solana a través de los precompiles, consulta [Llamar a Solana desde EVM](https://docs.rome.builders/es/guias-para-desarrolladores/call-solana-from-evm.md).

## 3. Deja que una wallet de Solana lo llame

La ruta EVM de tu app no cambia (MetaMask + `submitRomeTx`, o viem/ethers sin más). Para la ruta de Solana hay dos formas.

**La ruta del SDK — una transacción Solana v1 por llamada.** [`@rome-protocol/sdk`](https://github.com/rome-protocol/rome-sdk-ts) (`submitRomeTxV1`) hace que el proxy componga una transacción Solana v1 para tu llamada EVM (hasta 64 cuentas y 4 KB, sin address lookup table; no hay instrucción ComputeBudget, wallet de tesorería ni descubrimiento de cuentas en tu código). La wallet firma dos veces con la misma clave: primero un mensaje de autorización legible (`autorización Rome` en una línea, `0x` y el hash de la transacción EVM en la siguiente), que la cadena verifica mediante el programa Ed25519, y luego la transacción. La app envía la transacción firmada al RPC de Solana; la llamada devuelve el hash de la transacción EVM y su recibo. Antes de que la wallet firme la transacción, el SDK la comprueba: el pagador es el único firmante, solo se ejecutan el programa Rome y el verificador Ed25519, la instrucción de Rome lleva exactamente la llamada que el usuario autorizó y no hay tarifa prioritaria. Cualquier otra cosa se rechaza.

Si una llamada no cabe en una sola transacción, el composer la rechaza y el SDK la entrega al proxy para hacer relay, con la misma firma de autorización, así que el usuario sigue viendo un único aviso de autorización. El resultado entonces tiene `route: "relay"`. Las reglas para llamadas relay y llamadas largas están en [Llamadas retransmitidas y llamadas largas](https://docs.rome.builders/es/guias-para-desarrolladores/call-evm-from-solana.md#relayed-calls-and-long-calls). Una llamada relay se paga con el gas nativo de la cadena, así que el sintético necesita un saldo de gas: `fundSyntheticGas(deps, amountWei)` mueve el token de gas de la cadena (USDC en Hadrian y Rubicon) desde la cuenta de tokens de la wallet hacia él, en una transacción v1 firmada por la wallet.

El tramo de financiación (`buildFundLeg`) y la creación de la cuenta de token de la wallet antes de un sweep son instrucciones normales de Solana; `submitSolanaInstructionsV1` también las envía como transacciones v1, firmadas por el mismo firmante de la wallet, sin que intervenga ningún proxy. La propia llamada de sweep (`buildSweepLeg`, `HelperProgram.transfer_spl`pasa por `submitRomeTxV1` como cualquier otra, y el proxy encuentra las cuentas de tokens. `submitRomeTxV1` no crea por sí misma la cuenta de un nuevo sintético: antes de la primera llamada que mueve valor, comprueba `isSyntheticProvisioned(...)` y, si es falso, envía `buildCreatePdaCall(synthetic)` a través de `submitRomeTxV1` una vez. Un recorrido completo de depósito y retiro con código está en [Crear una app de doble vía](https://docs.rome.builders/es/guias-para-desarrolladores/dual-lane-app.md); la mecánica está en [Llamar a EVM desde Solana](https://docs.rome.builders/es/guias-para-desarrolladores/call-evm-from-solana.md). La versión anterior `submitRomeTxSolanaLane`, que construye una transacción de Solana legacy en el cliente, sigue en el SDK como la ruta antigua.

**Dónde `dependencias` proviene cada** El `dependencias` objeto tiene cinco campos obligatorios (el resto, como `fetchImpl` y los timeouts, son opcionales). Cuatro vienen de la cadena y uno de la wallet:

| `dependencias` campo | De dónde viene                                                                                                                   | Obtenedor del registro (`@rome-protocol/registry` v0.2.0)                                               |
| -------------------- | -------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- |
| `proxyUrl`           | la URL RPC de la cadena                                                                                                          | `getChain(chainId).rpcUrl`                                                                              |
| `chainId`            | el ID de la cadena                                                                                                               | `getChain(chainId).chainId`                                                                             |
| `programId`          | el ID de programa de Rome en el que se ejecuta la cadena                                                                         | `getChain(chainId).romeEvmProgramId`                                                                    |
| `conexión`           | un RPC de Solana para el clúster de la cadena, donde se envía la transacción firmada (devnet para Hadrian, mainnet para Rubicon) | `getChain(chainId).solana.rpc` (una URL pública de devnet para Hadrian); para mainnet usa un RPC propio |
| `signer`             | la `LaneSigner`, o un `Keypair` en scripts                                                                                       | ninguno                                                                                                 |

Los constructores de los tramos toman valores que no están en `dependencias`. Su `mint` (llamado `usdcMint` en el recorrido) es el mint de Solana del token de gas, de `getTokens(chainId)` (la entrada con `kind: "gas"`, campo `mintId`). La dirección del wrapper wUSDC no es una entrada del constructor de tramos; la usas para las llamadas ERC-20, y es la entrada con `kind: "spl_wrapper"` y símbolo `wUSDC` (campo `address`). El registro cubre Hadrian y, desde v0.3.0, Rubicon. Para rellenar a mano los valores de Rubicon en su lugar: `proxyUrl` `https://rubicon.mainnet.romeprotocol.xyz/`, `chainId` `7531`, `programId` `RomePq9X3iAoTr813HR7uRarafFDUJty6GdiEceYpzX`, `mint` `EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v`, el wrapper de la tabla de la siguiente sección, y un RPC de Solana mainnet para `conexión`. [Rubicon](https://docs.rome.builders/es/redes/rubicon.md) tiene la lista completa.

**Los endpoints externos-V1 del proxy — el mismo carril sin el SDK.** El SDK encapsula la composición atómica, el relay y el depósito de gas (`fundSyntheticGas`). Los métodos RPC en bruto permanecen para clientes que no usan el SDK, e incluyen la composición iterativa, que el SDK no encapsula. La wallet firma un mensaje Ed25519 sobre la llamada (la forma legible `Rome authorization\n0x<hash>` o el hash bruto), y el proxy o bien compone la(s) transacción(es) de Solana para que la wallet las firme (`rome_composeUnsignedAtomicV1`, `rome_composeUnsignedIterativeV1` + `rome_submitSignedV1Plan`) o ejecuta toda la ejecución por sí mismo con una sola firma de wallet (`rome_relayUnsignedV1`, después de un `rome_composeExternalDepositV1` (el `fundSyntheticGas`) que financia el saldo de gas del sintético; las llamadas relay gastan de ahí, así que recárgalo cuando baje). Las formas de los métodos están en [Compatibilidad con JSON-RPC](https://docs.rome.builders/es/referencia/json-rpc.md); las reglas de autorización en [Llamar a EVM desde Solana](https://docs.rome.builders/es/guias-para-desarrolladores/call-evm-from-solana.md#the-external-v1-endpoints). Usa el relay para cualquier cosa iterativa, y el carril del SDK para todo lo que quepa.

En cualquier caso, el contrato ve una transacción normal desde la dirección sintética y el usuario nunca posee una clave EVM.

## 4. Direcciones de wrapper por red

| Red              | `wUSDC` envoltorio                           | Otros envoltorios                                                                                        |
| ---------------- | -------------------------------------------- | -------------------------------------------------------------------------------------------------------- |
| Rubicon (7531)   | `0x0952d233b0c254cd375f3bfb3e5869c1a906f9b3` | `wETH` `0x01e8b3573da1d4b7b4b1ce0932cf07c8af0c92e9`, `wSOL` `0xc4e29e0f726a906e93277cbbc37bf27a9848a113` |
| Hadrian (200010) | `0xbce339ba4c3a8de3bb8af1c5539e6ac11da3112d` | `wETH` `0x02aeace038269f9961c93d04dcacd6fb3adfa55f`, `wSOL` `0x39f36444fcb79b3e691544aee2a832ebef54ca9f` |

El token de gas nativo aparece como `0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee` en las listas de tokens; no es un contrato ERC-20. Los wrappers llevan los decimales del mint SPL, no 18: wUSDC 6, wETH 8, wSOL 9.

## 5. Lista de verificación para el lanzamiento

1. Desplegado en Hadrian; la ruta EVM funciona desde MetaMask.
2. Cada punto de entrada que mueve valor se basa en ERC-20 y apunta al wrapper canónico de la cadena.
3. Una wallet de Solana que firma transacciones v1 (Solflare lo hace hoy en devnet; Phantom todavía no) completa el recorrido de ida y vuelta en Hadrian: provisionar el sintético (`create_pda`, una vez) → tramo de financiación → conceder → aprobar → llamar → tramo de barrido, usando la ruta del SDK; o la ruta de relay si la llamada es iterativa.
4. El `computeUnitsConsumed` de cada llamada por el carril de Solana
5. se lee del recibo de Solana y queda dentro del presupuesto atómico, o la llamada se enruta por el relay. `isEnabled(user)` La concesión del wrapper está en el flujo de primer depósito de tu app para ambos carriles: `approve_spl` se comprueba y[Una sola vez: concede al wrapper](https://docs.rome.builders/es/guias-para-desarrolladores/dual-lane-app.md#one-time-grant-the-wrapper)).
6. Código fuente verificado en el explorador.
7. se envía una vez cuando es falso ( `dependencias` Vuelve a desplegar en Rubicon con las direcciones del wrapper de mainnet. Sus [Rubicon](https://docs.rome.builders/es/redes/rubicon.md)valores provienen del registro (v0.3.0 o posterior) o a mano desde

## Qué sigue

* [Crear una app de doble vía](https://docs.rome.builders/es/guias-para-desarrolladores/dual-lane-app.md) . La misma ida y vuelta se ejecuta una vez con fondos reales, usando una wallet de la que has verificado que firma transacciones v1 en mainnet.
* [Llamar a EVM desde Solana](https://docs.rome.builders/es/guias-para-desarrolladores/call-evm-from-solana.md) — direcciones sintéticas, descubrimiento de cuentas, los endpoints externos-V1
* [Desplegar contratos de Solidity](https://docs.rome.builders/es/guias-para-desarrolladores/deploy-solidity.md) · [Verificar contratos](https://docs.rome.builders/es/guias-para-desarrolladores/verify-contracts.md) · [Direcciones de contrato](https://docs.rome.builders/es/referencia/contract-addresses.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/guias-para-desarrolladores/open-to-solana-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.
