> 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/conceptos-basicos/how-solana-and-evm-meet.md).

# Cómo se encuentran Solana y la EVM en Rome

Cómo las billeteras de Solana llaman a contratos de Solidity, las direcciones EVM llaman a programas de Solana, y Rome gestiona la identidad, los tokens, las tarifas y los límites de ejecución.

Esta página explica cómo las llamadas cruzan entre Solana y la EVM en Rome. Cubre quién firma, dónde viven los tokens, quién paga y qué reglas de Solana afectan a los contratos de Solidity.

Salvo que se indique lo contrario, las cifras y transacciones de esta página son de Hadrian (testnet) a fecha de 19 de octubre de 2026.

## ¿Qué es una dirección sintética?

Una dirección sintética es la identidad EVM de una clave pública de Solana. Rome la calcula como los últimos 20 bytes de `keccak256` de la clave pública: `keccak256(pubkey)[12..32]`. El mapeo es fijo. Se llama sintética porque nadie posee una clave secp256k1 para ella: MetaMask no puede firmar por ella y solo la clave de Solana puede autorizar llamadas desde ella.

En la llamada de contrato de nivel superior, tanto `msg.sender` y `tx.origin` son la dirección sintética. Rome almacena el nonce de la EVM bajo esa dirección. El contrato no puede distinguir esta identidad de un usuario de MetaMask a través de esos campos.

## ¿Cómo llama un usuario de Solana a un contrato de Solidity?

La billetera autoriza una llamada EIP-1559 sin firmar a través de una de dos rutas. La ruta v1 es el camino actual. La ruta heredada es el camino anterior: la billetera firma y paga la transacción de Solana que transporta `DoTxUnsigned`, y el programa EVM de Rome deriva la dirección sintética a partir de ese firmante de Solana.

En la ruta v1, la billetera firma un mensaje legible que contiene `autorización Rome`, un salto de línea y el hash de la llamada como `0x` seguido de 64 caracteres hexadecimales en minúsculas. La transacción lleva esta firma en una instrucción de verificación Ed25519 en el índice 0. El programa EVM de Rome deriva la dirección sintética de la clave que autorizó la llamada.

El Rome Proxy compone la transacción v1. Luego la billetera la firma y la envía a Solana. En la ruta de relé, Rome Proxy envía la transacción y paga SOL, y la dirección sintética paga el gas desde su saldo nativo en el token de gas de la cadena (USDC en Hadrian y Rubicon).

Cuando la billetera paga directamente, la ruta v1 cuesta 15.000 lamports: una tarifa de firma de 5.000 lamports, 5.000 lamports por la firma de verificación Ed25519 y un peaje del tesoro de 5.000 lamports. La ruta heredada `DoTxUnsigned` no tiene instrucción Ed25519 y cuesta 10.000 lamports. Ambas rutas también pagan renta por cualquier cuenta creada. Ninguna ruta directa cobra gas de EVM. Una transacción de la ruta heredada en Hadrian costó a la billetera 10.000 lamports e informó `gasUsed = 0` y `effectiveGasPrice = 0`.

El `submitRomeTxV1` sigue estos pasos:

1. Lee el nonce de la dirección sintética con `eth_getTransactionCount`, estima el gas y construye la llamada sin firmar.
2. Pídele a la billetera que firme el mensaje legible `autorización Rome` .
3. Solicita una transacción a `rome_composeUnsignedAtomicV1`.
4. Verifica el pagador devuelto, los bytes de la llamada, la autorización Ed25519, los programas permitidos y la ausencia de una tarifa de prioridad.
5. Pídele a la billetera que firme la transacción v1, envíala a Solana y consulta al Rome Proxy por el recibo de EVM.
6. Si la llamada requiere ejecución iterativa, enrútala a través de `rome_relayUnsignedV1` usando la misma firma de autorización.

Usa `fundSyntheticGas` para financiar el saldo nativo necesario para un relé o `msg.value`. Deposita el token de gas desde la cuenta de tokens de la billetera y acredita el saldo nativo de la dirección sintética. Los saldos nativos usan 18 decimales.

Para usar tokens en un contrato, el SDK financia la dirección sintética, llama al contrato y devuelve cualquier token restante. `buildFundLeg` usa `ActivateAta` para mover tokens desde la billetera a la cuenta de tokens de la dirección sintética. `buildSweepLeg` usa `transfer_spl` para devolver los tokens restantes a la billetera.

La billetera debe admitir la firma de transacciones v1 de Solana. Solflare admite esto en Solana devnet; Phantom aún no. Cada llamada comprueba e incrementa el nonce de EVM bajo la dirección sintética para evitar la repetición.

Ver [Llamar a EVM desde Solana](https://docs.rome.builders/es/guias-para-desarrolladores/call-evm-from-solana.md), [Crear una app de doble vía](https://docs.rome.builders/es/guias-para-desarrolladores/dual-lane-app.md), y [Rome SDK](https://docs.rome.builders/es/productos/rome-sdk.md).

## ¿Cómo llama un usuario de EVM, o un contrato, a un programa de Solana?

Cada dirección EVM tiene una dirección derivada de programa de Solana que posee sus cuentas de tokens y puede firmar llamadas a programas de Solana. Esta es su PDA de autoridad externa. El programa EVM de Rome la deriva a partir de la semilla `EXTERNAL_AUTHORITY` seguida por la dirección EVM. Las semillas no contienen ID de cadena, así que las cadenas alojadas por el mismo programa EVM de Rome comparten esta autoridad.

Un usuario o contrato llama al precompilado CPI en `0xFF…08` con el ID del programa objetivo, la lista de cuentas y los bytes de la instrucción. CPI significa invocación entre programas. El precompilado invoca el programa de Solana dentro de la misma transacción de Solana.

`invoke` firma para la PDA de autoridad externa del llamador cuando la lista de cuentas la marca como firmante. `invoke_signed` también admite PDAs derivadas con sales. Cada PDA con sal debe aparecer en la lista de cuentas como firmante.

Los métodos `account_info`, `account_data_at`, `account_u64_at`, `account_lamports`, y `pdas_batch_derive` son ayudas de solo lectura. No invocan un programa de Solana.

El precompilado rechaza llamadas dirigidas al propio programa EVM de Rome. También rechaza una lista de cuentas que contenga el ID del programa EVM de Rome. Una CPI no puede nombrar al pagador de tarifas de Solana, excepto dentro de una instrucción System simple `Transfer` .

Un swap de RomeDexRouter 2.0.0 en Hadrian siguió estos pasos:

1. El router llamó a `HelperProgram.create_ata` para asegurarse de que existiera la cuenta de tokens de salida del usuario.
2. Derivó las cuentas de tokens de entrada y salida del usuario y marcó su propia PDA de autoridad externa como firmante.
3. Llamó a `CPI.invoke` con el programa de swap de Solana, la lista de cuentas y los bytes de la instrucción de swap.
4. SPL Token movió tokens desde la cuenta del usuario al pool y devolvió tokens de salida a la otra cuenta del usuario. La PDA del router firmó como delegado SPL del usuario. El router no tenía tokens.
5. El router comprobó la cantidad recibida con `CPI.account_u64_at(dstAta, 64)`.
6. El recibo informó 10.001 gas: `5,000 + 5,000 + 1 = 10,001` lamports de costo de Solana. Esos costos fueron la tarifa de firma, el peaje del tesoro y la tarifa de prioridad. El Rome Proxy pagó SOL y el usuario pagó gas en USDC.

Ver [Llamar a Solana desde EVM](https://docs.rome.builders/es/guias-para-desarrolladores/call-solana-from-evm.md), [Integra un programa de Solana](https://docs.rome.builders/es/guias-para-desarrolladores/integrate-solana-program.md), y el [Referencia de precompilados](https://docs.rome.builders/es/referencia/precompiles.md).

## ¿Quién firma cuando un contrato llama a un programa de Solana?

Rome firma con la PDA de autoridad externa del llamador inmediato del precompilado. Por lo tanto, un contrato firma como sí mismo. Solo una llamada enviada directamente al precompilado por la propia EVM del usuario o la dirección sintética firma con la PDA del usuario.

Para permitir que un router o adaptador mueva los tokens de un usuario, el usuario llama a `approve_spl(spender, amount, mint)`. Esto establece la PDA de autoridad externa del contrato como delegada SPL de la cuenta de tokens del usuario. Es la versión de Rome de ERC-20 `approve`.

En `DELEGATECALL`, el precompilado rechaza la PDA de autoridad externa en bruto como firmante. Las autoridades con sal incluyen el contrato en ejecución en su derivación bajo `DELEGATECALL`.

## Todas las direcciones tienen una PDA, entonces ¿por qué los wrappers no dividen la liquidez?

Para una billetera, un wrapper es una vista de sus tokens SPL. `balanceOf` lee la cuenta de tokens real de la billetera en Solana. `totalSupply` lee la oferta del mint.

Los tres wrappers wUSDC en Hadrian (testnet), 9.0.0 (`0xbce339ba…`), 8.0.0 (`0xae287c43…`), y mayo de 2026 (`0x9fd4d58d…`), muestran el mismo saldo para cada billetera. Los tres devuelven la oferta del mint desde `totalSupply`.

Un titular nativo de Solana y un titular de EVM usan cuentas del mismo mint. La billetera de Solana posee directamente su cuenta de tokens. La PDA de autoridad externa de la dirección EVM posee su cuenta de tokens. `ActivateAta` y `transfer_spl` mueven tokens entre estas cuentas. Ambos titulares operan contra las mismas cuentas y reservas del pool de Solana.

Los saldos mantenidos por contratos requieren un tratamiento diferente. Los tokens enviados a un contrato se quedan en la cuenta de custodia del wrapper. El wrapper lleva el saldo del contrato. Un par al estilo UniswapV2 en Hadrian tenía un saldo de 9.600.566 a través del wrapper 9.0.0 y 0 a través del wrapper 8.0.0. Usa el wrapper canónico del registro para pools, bóvedas y mercados de préstamo.

Cada cuenta de tokens tiene un único espacio de delegado SPL. Otorgar permiso a un router o puente reemplaza la concesión del wrapper. Después de una rotación de wrapper, el usuario debe conceder permiso al nuevo wrapper con `approve_spl`. Vuelve a conceder permiso al wrapper si otro delegado lo ha reemplazado.

Cada fábrica permite un wrapper por mint. Los wrappers de diferentes fábricas aún pueden leer las mismas cuentas de tokens de la billetera. Véase [Interop de tokens](https://docs.rome.builders/es/conceptos-basicos/token-interop.md).

## ¿Cómo sortea Rome las diferentes semánticas de Solana y la EVM?

| Diferencia                                        | Qué hace Rome                                                                                                                                                                                                                                     |
| ------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Cuentas declaradas de antemano vs acceso dinámico | Emula primero la llamada y usa las cuentas tocadas como lista de cuentas de la instrucción de Solana.                                                                                                                                             |
| Límites de cómputo y tamaño de una transacción    | Usa ejecución atómica (VmAt) cuando la llamada cabe. Las cuentas de titular llevan cargas útiles más grandes, y la ejecución iterativa (VmIt) divide el trabajo entre transacciones.                                                              |
| Bloqueos de cuenta entre tramos                   | Renueva los bloqueos de las cuentas de saldo y almacenamiento en cada tramo. Los bloqueos duran 3 segundos, o 4 segundos cuando la transacción nombra más de 28 cuentas. Una escritura atómica en una cuenta bloqueada falla con `AccountLocked`. |
| Token de gas y tarifas                            | Cuenta los costos de Solana en lamports y los convierte en cargos del token de gas con el precio del gas de la transacción. Las llamadas pagadas por la billetera pagan SOL directamente.                                                         |
| Bloques y slots                                   | Usa el slot de Solana para `block.number` y el reloj de Solana para `block.timestamp`.                                                                                                                                                            |
| Finalidad                                         | Confirma en Solana `confirmado`. Hercules vuelve a comprobar los bloques indexados en `finalizado`.                                                                                                                                               |
| Firmas                                            | Verifica las firmas de EVM con `secp256k1_recover`. La autorización de Solana usa Ed25519. Ambos producen un remitente EVM de 20 bytes.                                                                                                           |
| Renta                                             | Financia la creación y el crecimiento de cuentas de Solana a través del pagador de tarifas. Cobra al remitente de EVM mediante gas cuando hay un destinatario de tarifas.                                                                         |
| Decimales y ancho entero                          | Usa 18 decimales para los saldos nativos de gas. La conversión a unidades SPL debe ser exacta y caber en `u64`. Los wrappers usan los decimales del mint y rechazan importes superiores al `uint64` máximo.                                       |
| Reentrada y medición de gas                       | No tiene medidor de gas por opcode EVM. El estipendio de 2.300 gas no restringe las llamadas, así que los contratos necesitan protectores explícitos contra reentrada.                                                                            |
| Profundidad de CPI                                | Ejecuta el programa EVM de Rome en profundidad 1 y un objetivo CPI en profundidad 2. Solana permite anidamiento hasta profundidad 5.                                                                                                              |
| Atomicidad de los efectos secundarios de Solana   | Ejecuta las CPI heredadas de inmediato y aborta toda la transacción si su marco se revierte después. Las llamadas en caché se registran durante la ejecución y se envían en el commit. Se descartan cuando su marco se revierte.                  |
| `SELFDESTRUCT` y opcodes desconocidos             | Deshabilita `SELFDESTRUCT`. Él y otros opcodes no implementados abortan toda la transacción con `IncompatibleVersionEVM`.                                                                                                                         |
| Nonces                                            | Almacena y comprueba un nonce de EVM por remitente en su PDA de saldo. La estimación de gas omite la comprobación de nonce.                                                                                                                       |

### Cuentas

El emulador ejecuta la llamada contra las cuentas de Solana antes del envío. Registra cada cuenta tocada y si debe ser escribible. Ese conjunto se convierte en la lista de cuentas de la instrucción de Solana. Si falta una cuenta requerida en la lista, la llamada on-chain falla.

Una rama dependiente del tiempo puede cambiar entre la emulación y la ejecución. Si ese cambio hace que la llamada supere su presupuesto de cómputo, Rome Proxy recompone una vez en el bloque siguiente.

### Tamaño de transacción y cómputo

La ejecución atómica (VmAt) cabe dentro de una sola transacción de Solana, con alrededor de 1,4 millones de unidades de cómputo y como máximo 64 cuentas. La llamada también debe caber en los límites de heap y traza de instrucciones.

Una transacción Solana v1 contiene como máximo 4.096 bytes. Para cargas útiles de transacción EVM mayores, Rome Proxy escribe fragmentos de 3.600 bytes en una `TxHolder` cuenta de titular con un tamaño máximo de 80.000 bytes. La tarifa de firma de cada fragmento se cobra como gas.

La ejecución iterativa (VmIt) guarda el estado de la VM en una `StateHolder` cuenta de titular entre tramos. Una sesión permite como máximo 160 iteraciones. El planificador produce como máximo 128 tramos, con un límite de opcode de al menos 500 por tramo. Las CPI heredadas requieren ejecución atómica. Las llamadas en caché admiten ejecución iterativa.

### Gas y renta

Una unidad de gas de Rome representa un lamport de costo de Solana. Los costos incluyen tarifas de firma, el peaje del tesoro de 5.000 lamports, tarifas de prioridad y renta neta de reembolsos. `eth_gasPrice` reporta wei de token de gas por lamport. Cuando hay un destinatario de tarifas, Rome cobra al remitente `lamports × tx.gasPrice` desde el saldo nativo.

El pagador de tarifas de Solana financia la renta cuando Rome crea o amplía cuentas de saldo y almacenamiento. Ese costo se factura al remitente de EVM como gas cuando hay un destinatario de tarifas. Por lo tanto, una primera transferencia a una dirección nunca usada cuesta aproximadamente 1 millón de gas. `eth_estimateGas` nunca devuelve menos de 21.000.

### Bloques, tiempo y finalidad

`block.number` es el slot de Solana. `block.timestamp` es la marca de tiempo Unix del reloj de Solana. Rome captura ambos cuando crea el estado de la VM y los mantiene a través de tramos iterativos.

`blockhash(n)` es `keccak256(bytes32(n))` dentro de los últimos 256 slots y cero fuera de ellos. No tiene entropía. `block.coinbase` es el destinatario de tarifas, o cero cuando no hay ninguno.

El SDK espera a `confirmado`. Hercules vuelve a verificar cada bloque indexado al estar `finalizado` y lo recarga si el hash del bloque cambió.

### Reversiones, reentrada y CPI

Las CPI heredadas se ejecutan de inmediato. Si un marco que realizó una CPI se revierte después, Rome aborta toda la transacción. Solidity `try/catch` no puede absorber esa reversión. Las llamadas en caché se registran durante la ejecución y se envían en el commit. Un marco revertido descarta sus llamadas registradas. Una vez que una transacción ha escrito por una vía, se rechazan las escrituras por la otra vía. Después de una escritura en caché, también se rechazan los ayudantes de lectura heredados: las lecturas de cuentas de CpiProgram y `pdas_batch_derive`, y las de HelperProgram `user_balance`, `allowance_of` y `mint_info`.

Rome no tiene medidor de gas por opcode EVM. `gasleft()` devuelve el límite de gas, o `U256::MAX` cuando no hay destinatario de tarifas. El gas pasado a `CALL` ni `CREATE` no se aplica. Usa protectores explícitos contra reentrada en lugar de confiar en el estipendio de 2.300 gas.

La profundidad de la pila de instrucciones de Solana es 5. El programa EVM de Rome se ejecuta en profundidad 1, así que su objetivo se ejecuta en profundidad 2 y puede anidar hasta profundidad 5. El swap de Hadrian ejecutó el programa de swap en profundidad 2 y SPL Token en profundidad 3. Un cambio pendiente de Solana (SIMD-0268) elevaría la profundidad de 5 a 9. No estaba activo en devnet ni en mainnet a fecha de 19 de octubre de 2026. Se rechaza una CPI de vuelta al programa EVM de Rome.

Ver [Modelo de ejecución](https://docs.rome.builders/es/conceptos-basicos/execution-model.md), [Restricciones](https://docs.rome.builders/es/conceptos-basicos/constraints.md), [Presupuesto de cómputo](https://docs.rome.builders/es/conceptos-basicos/compute-budget.md), y [Limitaciones conocidas](https://docs.rome.builders/es/seguridad/known-limitations.md).

## Preguntas comunes

### ¿Son MetaMask y Phantom la misma cuenta en Rome?

No. Una clave de MetaMask y una clave de Solana dan dos direcciones EVM distintas, y Rome nunca las vincula. La clave de MetaMask da su dirección habitual de Ethereum. La clave de Solana da su [dirección sintética](#what-is-a-synthetic-address), `keccak256(pubkey)[12..32]`: `2PMoUv…` se convierte en `0x45b64dae…`. En la llamada de nivel superior, `msg.sender` y `tx.origin` son la dirección firmante, incluida la dirección sintética en la ruta de relé.

Las claves distintas causan la separación: dos claves de MetaMask también son dos cuentas. Las curvas solo significan que ninguna clave puede firmar por la dirección de la otra. No hay una función de vinculación. `ActivateAta` financia solo la dirección sintética propia del firmante. Una `Depósito` instrucción puede acreditar cualquier dirección EVM con gas nativo, pagado desde la cuenta de token de gas del firmante. El proxy solo construye depósitos hacia la propia dirección sintética del firmante. Nada de esto convierte dos claves en una sola cuenta. Un pool ve dos titulares, pero ambos negocian contra las mismas reservas; véase [¿La liquidez se comparte](#is-liquidity-shared-between-solana-and-evm-users-or-split).

### ¿Cómo se asignan las cuentas de Solana y EVM?

Rome asigna cada clave de Solana a una única [dirección EVM sintética](#what-is-a-synthetic-address). Cada dirección EVM tiene una PDA de saldo por cadena para su nonce, saldo nativo de gas y código. Su PDA de autoridad externa posee sus cuentas de tokens y firma CPI. Las cadenas en un mismo programa de Rome comparten esa autoridad.

Estas cuentas se leyeron en Hadrian (testnet):

| Cuenta                                    | Dirección de MetaMask `0x35153297…a266`                                       | cartera de Solana `2PMoUv…`, dirección sintética `0x45b64dae…127d`                                 |
| ----------------------------------------- | ----------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------- |
| Cuentas propias de Solana de la billetera | Ninguna de la clave de MetaMask                                               | Cuenta del sistema SOL `2PMoUv…`; cuenta wSOL propia `T8gKAAg9pz5eLcerH1Nh52Hn97m1nnGyhY9z4bwtyir` |
| PDA de saldo                              | `8zuWEakFcuRRJ5Gju44u6Ptyk22gbNUMbsD8VLEQVS4c`                                | `EeRr14Feh3Ft7YuyacAVJQd3YSYsKAPTqdMEN43gtBSd`                                                     |
| PDA de autoridad externa                  | `EZSTURZAg3GMqiWN3NBCvMLjEeLSxGH9PGooW6dAG8Kb`                                | `FMSHMpgdA9rEhzGLSvFniAHT7BmGjJweQqxPiGJJntC1`                                                     |
| Cuenta de tokens que usa Rome             | USDC `8wAzpmag4oL4c6ku6wqQBjxWXYLPoVsek6SyAvrYaxim`, propiedad de `EZSTURZA…` | wSOL `3pPjxR4ho3mVb5AMauVCjqTBUVS2Rif5JAnk9DFukPg2`, propiedad de `FMSHMpgd…`                      |

Los tokens de un usuario de Solana se encuentran en dos lugares: las propias cuentas de la billetera y las cuentas propiedad de la PDA de la dirección sintética que leen los wrappers. El SDK mueve los tokens con `ActivateAta` y de vuelta con `transfer_spl`, como se describe en [¿Cómo llama un usuario de Solana a un contrato de Solidity?](#how-does-a-solana-user-call-a-solidity-contract). El barrido `0x95b2502d…` devolvió 0,016587 wSOL a la billetera. La misma dirección de MetaMask tiene distintas cuentas de tokens en Hadrian (testnet) y Rubicon (mainnet) porque se ejecutan sobre distintos programas de Rome, mints y clústeres de Solana.

### ¿Quién paga qué tarifa cuando un usuario de EVM y un usuario de Solana llaman al mismo contrato? ¿Es una sola vía de tarifas o dos?

Rome usa un modelo de costos con dos maneras de liquidarlo. Una unidad de gas de Rome es un lamport de costo de Solana: tarifas de firma, el peaje del tesoro de 5.000 lamports, cualquier tarifa de prioridad y renta neta de reembolsos.

En las rutas de Solana firmadas por la billetera, el pagador de tarifas de Solana paga ese costo en SOL sin cargo de gas de EVM. En las llamadas de MetaMask y de relé, el Rome Proxy adelanta SOL. El programa cobra al remitente de EVM `lamports × el precio de gas de la transacción` desde su saldo nativo a un destinatario de tarifas del proxy. El token de gas es USDC en Hadrian (testnet) y Rubicon (mainnet).

Estas dos `llamadas de` (USDC desde MetaMask, wSOL desde la clave de Solana) usaron AavePool 2.0.0 (`0x81e7e7e4…`) en Hadrian (testnet). Cada una creó dos cuentas.

| Costo o destinatario              | Clave EVM (MetaMask)                                                               | Clave de Solana (firmada por la billetera v1)                                                                            |
| --------------------------------- | ---------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------ |
| Tx de EVM                         | `0xc7e6ee8d…`, desde `0x35153297…`                                                 | `0xb0712551…`, desde `0x45b64dae…`                                                                                       |
| Quién firmó y pagó SOL            | Pagador proxy de Rome `GNX1fLhb…`                                                  | La billetera del usuario `2PMoUv…`                                                                                       |
| SOL gastado                       | 2.102.962 lamports = 5.000 firma + 2 prioridad + 5.000 peaje + 2 × 1.046.480 renta | 2.107.960 lamports = 10.000 en tarifas de firma (transacción + verificación Ed25519) + 5.000 peaje + 2 × 1.046.480 renta |
| Gas de EVM cobrado                | El remitente pagó 2.102.962 gas × 13.004.742.450 wei = 0,0273485 USDC              | `gasUsed` 0, `gasPrice` 0                                                                                                |
| Gas pagado a                      | Destinatario de tarifa del proxy `0x179d6112…`                                     | Nadie; no `gasRecipient`                                                                                                 |
| Destinatario del peaje del tesoro | `7WDWCxvk…`, cuenta del tesoro #31                                                 | `3F9eKFpr…`, cuenta del tesoro #6                                                                                        |

* **Ruta heredada (camino anterior):** `0x350b8e36…` costó a la billetera 1.056.480 lamports: 5.000 de tarifa de firma + 5.000 de peaje + 1.046.480 de renta, por una cuenta creada. El gas de EVM fue 0.
* **Relé:** Aave `préstamo` transacción `0x18d65e8c…` usó 16 tramos de Solana. La dirección sintética pagó 2.177.992 gas = 0,0226594 USDC, usando la misma vía de tarifas que un usuario de MetaMask. El cargo de gas cubre `16 × 5.002 + 5.000 peaje + 2 × 1.046.480 renta = 2.177.992`. Cada tramo de relé también lleva la firma de verificación Ed25519. El proxy paga esos 5.000 lamports por tramo y no los factura, así que esta llamada le costó al proxy 16 × 10.002 lamports en tarifas.
* **Tesoro compartido:** Cada ruta paga su peaje de 5.000 lamports en una de las 64 cuentas del tesoro de la cadena. Las dos llamadas de suministro anteriores pagaron sus peajes en las cuentas #31 y #6 del mismo conjunto.
* **Precio declarado:** Rome cobra el precio declarado de la transacción, `maxFeePerGas` para EIP-1559. No hay base fee ni reembolso de la diferencia. Las transacciones en vivo con clave EVM declararon entre 1× y 2× la `eth_gasPrice` cotización de 10.403.793.960 wei por lamport, y cada una pagó exactamente lo que declaró. El gas se fija por lamport de costo de Solana, no por opcode de EVM.
* **Costos firmados por la billetera:** Las rutas del SDK no establecen tarifa de prioridad, así que los usuarios no pagan cargo de cómputo. Pagan tarifas de firma, el peaje y la renta en SOL. La ruta v1 paga por dos firmas: la firma de la transacción y la verificación Ed25519.

Véase la [flujo de llamadas de Solana](#how-does-a-solana-user-call-a-solidity-contract) y [guía de doble ruta](https://docs.rome.builders/es/guias-para-desarrolladores/dual-lane-app.md) para las rutas de billetera y relé.

### ¿La liquidez se comparte entre usuarios de Solana y EVM, o se divide?

Compartida. Ambas rutas operan contra las cuentas del mismo mint. En Aave en Hadrian (testnet), una clave de Solana y una clave EVM en la ruta MetaMask suministraron y pidieron prestado a través de la cuenta de custodia wSOL `3yY2FHSG…` (MetaMask: suministro `0xaf460f52…`, préstamo `0x89dbf0b6…`; clave de Solana: suministro `0xb0712551…`, préstamo `0x18d65e8c…`). Esta es la custodia del wrapper wSOL, que contiene la reserva awSOL.

En rome-dex, una billetera de Solana depositó liquidez directamente en las mismas bóvedas usadas por el swap del router EVM `0xa7f77530…`. La transacción de depósito de Solana `2xFSzza7…` no contiene ningún programa de Rome. Solo los saldos mantenidos por contratos dependen del wrapper, así que usa el wrapper canónico del registro para pools y bóvedas (véase la [sección de PDA y wrapper](#every-address-has-a-pda-so-why-dont-the-wrappers-split-liquidity)). No midas la liquidez wSOL con `totalSupply`: lee 0 porque el mint nativo de SOL informa una oferta de 0.

### ¿Cómo muevo tokens y saldo de gas entre una dirección de MetaMask y una billetera de Solana?

* **Billetera de Solana a dirección de MetaMask, tokens:** Crea la cuenta de tokens si falta (la creación idempotente del programa de Token Asociado, con la PDA de autoridad externa de la dirección como propietaria), luego envíale una transferencia SPL simple. `HelperProgram.ata(address, mint)` devuelve su dirección. La transacción `2tBhefMJ…` hizo ambas cosas y movió 20 USDC.
* **Billetera de Solana a dirección de MetaMask, gas:** Financia tu propia dirección sintética con `fundSyntheticGas`. Luego envía una transferencia de valor nativo desde la dirección sintética a la dirección de MetaMask.
* **Dirección de MetaMask a billetera de Solana, tokens:** Llama a `transfer_spl(bytes32,uint64,bytes32)` en el precompilado Helper directamente desde la dirección EVM, con la cuenta de tokens existente del destinatario. Alternativamente, llama a `RomeBridgeWithdraw.bridgeOutToSolana`, que necesita una concesión y una cuenta de tokens existente del destinatario.
* **Dirección de MetaMask a billetera de Solana, gas:** Llama al precompilado de Withdraw, de pago `withdrawal(bytes32 to)` con el importe como `msg.value`. La billetera lo recibe como USDC en su cuenta de tokens USDC, que Rome crea si es necesario. `msg.value` debe ser un múltiplo de 10^12 wei. El destinatario debe ser una cuenta de billetera existente.

`transfer_spl_to_signer` llega a tu propia billetera solo en el carril de Solana firmado por la billetera. Desde MetaMask o a través del relay, el firmante es el pagador proxy de Rome, así que la llamada falla o los tokens van a Rome. Consulta el [Referencia de precompilados](https://docs.rome.builders/es/referencia/precompiles.md).

Una identidad solo puede gastar los tokens de la otra mediante una concesión explícita, `approve_spl` o un ERC-20 `approve`, como con cualquier otra dirección. Cada cuenta de token tiene una sola ranura de delegado. Consulta [Interop de tokens](https://docs.rome.builders/es/conceptos-basicos/token-interop.md#one-time-grant-per-wallet).

### ¿Mi dirección es la misma en cada cadena de Rome?

La dirección EVM es la misma en todas las cadenas porque proviene de la clave. Su nonce y su saldo de gas se mantienen por cadena. Sus cuentas de tokens se comparten entre cadenas del mismo programa de Rome y difieren entre programas y clústeres. Consulta el [mapeo de cuentas](#how-do-solana-and-evm-accounts-map).

### ¿Qué billetera funciona en el carril de Solana? ¿Phantom funciona?

Aún no en el carril de Solana. El carril de Solana usa transacciones Solana v1, y la billetera tiene que firmarlas. En devnet, Solflare sí; Phantom todavía no.

### ¿El explorador muestra qué carril usó una transacción?

Parcialmente. El [Vía explorador](https://docs.rome.builders/es/apps-en-rome/via.md) muestra si una clave EVM o una clave de Solana envió una llamada: `origen` es `ecdsa` ni `solana_unsigned`, y las llamadas con clave de Solana llevan `solanaSigner`. No distingue entre las rutas heredada, v1 y relay; las tres muestran `solana_unsigned`. Una llamada de relay es la que tiene un valor distinto de cero de `gasUsed` y un `gasRecipient`. Una recarga de gas hecha con `fundSyntheticGas` se muestra como `ecdsa` sin `solanaSigner`.

## A dónde ir después

* [Arquitectura](https://docs.rome.builders/es/primeros-pasos-1/architecture.md)
* [Modelo de ejecución](https://docs.rome.builders/es/conceptos-basicos/execution-model.md)
* [Interop de tokens](https://docs.rome.builders/es/conceptos-basicos/token-interop.md)
* [Llamar a Solana desde EVM](https://docs.rome.builders/es/guias-para-desarrolladores/call-solana-from-evm.md)
* [Llamar a EVM desde Solana](https://docs.rome.builders/es/guias-para-desarrolladores/call-evm-from-solana.md)
* [Crear una app de doble vía](https://docs.rome.builders/es/guias-para-desarrolladores/dual-lane-app.md)
* [Integra un programa de Solana](https://docs.rome.builders/es/guias-para-desarrolladores/integrate-solana-program.md)
* [Referencia de precompilados](https://docs.rome.builders/es/referencia/precompiles.md)
* [Referencia de JSON-RPC](https://docs.rome.builders/es/referencia/json-rpc.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/conceptos-basicos/how-solana-and-evm-meet.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.
