> 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/productos/rome-sdk.md).

# Rome SDK

Interfaces Solidity tipadas para llamar a programas de Solana desde contratos EVM, además del SDK en Rust detrás de los servicios fuera de cadena de Rome.

El SDK de Rome proporciona interfaces tipadas de Solidity para interactuar con programas de Solana desde contratos inteligentes EVM. Es el conjunto de herramientas para desarrolladores para crear aplicaciones entre runtimes en Rome.

## SDKs

Rome tiene SDKs para tres públicos: creadores de aplicaciones (TypeScript), desarrolladores de contratos (Solidity) y equipos que ejecutan sus propios servicios en Rome (Rust).

### SDK de TypeScript (`@rome-protocol/sdk`)

**Para desarrolladores de dApps y frontend** — el SDK con el que empiezan la mayoría de los creadores de aplicaciones. [`@rome-protocol/sdk`](https://github.com/rome-protocol/rome-sdk-ts) encapsula la ruta de escritura de Rome para que una app web envíe correctamente transacciones de Rome: `submitRomeTx` (la ruta de escritura correcta más el manejo de gas/comisiones), derivación de PDA/ATA, CPI `invoke` / `invoke_signed` codificadores, enlaces de precompilación y un `/bridge` subruta. Instalación primero desde el repositorio (publicación en npm pendiente):

```bash
npm install github:rome-protocol/rome-sdk-ts#v0.4.0
```

```typescript
import { submitRomeTx } from '@rome-protocol/sdk';
// Envía cualquier escritura de Rome EVM por la ruta de escritura correcta (gestiona la codificación de gas/comisiones).
```

La versión pública [rome-dex](https://github.com/rome-protocol/rome-dex) la app solo usa algunos de los ayudantes del SDK (derivación de PDA y de cuentas de token, el CPI `invoke` codificador y el margen de gas de 1.3x), y [cardo](https://github.com/rome-protocol/cardo) no depende de él. Tampoco llama `submitRomeTx` ni `submitRomeTxV1`, así que léelos para ver cómo una app llama a la precompilación CPI, no para la ruta de escritura del SDK.

**Ambos carriles, un solo SDK.** `submitRomeTx` es el carril EVM (MetaMask). Para el **carril de Solana** — una cartera de Solana controlando tu app EVM — `submitRomeTxV1` lo replica: el proxy compone una transacción Solana v1 para la llamada, la cartera firma dos veces con la misma clave (primero un mensaje de autorización legible, luego la transacción), y Rome ejecuta la llamada como una transacción EVM desde la identidad derivada del usuario, sin clave EVM. Una llamada que no cabe en una sola transacción es reenviada por el proxy con la misma firma de autorización, y `fundSyntheticGas` completa el gas nativo que gasta una llamada reenviada. Una llamada reenviada que revierte se resuelve con `receipt.status === "0x0"` en lugar de lanzar una excepción, así que compruébalo; la [llamadas reenviadas y llamadas largas](https://docs.rome.builders/es/guias-para-desarrolladores/call-evm-from-solana.md#relayed-calls-and-long-calls) sección tiene la regla del gas y los límites. El valor entra y sale a través de `buildFundLeg` / `buildSweepLeg` como un envoltorio ERC-20 (p. ej. `wUSDC`), no nativo `msg.value` — el remitente sintético no mantiene nada en reposo — y un sintético de primera vez se aprovisiona una sola vez, explícitamente, con `buildCreatePdaCall`. La versión anterior `submitRomeTxSolanaLane`, que construye una transacción Solana heredada en el cliente, sigue en el SDK. Véase [Crear una app de doble vía](https://docs.rome.builders/es/guias-para-desarrolladores/dual-lane-app.md) y [Llamar a EVM desde Solana](https://docs.rome.builders/es/guias-para-desarrolladores/call-evm-from-solana.md).

### SDK de Solidity (`@rome-protocol/rome-solidity`)

**Para desarrolladores de Solidity.** Proporciona las interfaces de precompilación, envoltorios ERC-20/SPL, derivación de PDA y utilidades de CPI. La publicación en npm está pendiente; hoy las consumes desde el [`rome-solidity`](https://github.com/rome-protocol/rome-solidity) repositorio público (dependencia de git o archivos copiados).

```solidity
import {ISystemProgram, ICrossProgramInvocation, IHelperProgram, IWithdraw}
    from "@rome-protocol/rome-solidity/contracts/interface.sol";
import {SPL_ERC20} from "@rome-protocol/rome-solidity/contracts/erc20spl/erc20spl.sol";
import {RomeEVMAccount} from "@rome-protocol/rome-solidity/contracts/rome_evm_account.sol";
```

### SDK de Rust (`rome-sdk`)

**Para equipos que ejecutan sus propios servicios en Rome.** Un espacio de trabajo de Rust que gestiona la composición de transacciones, la interacción con Solana, la fijación de precios del gas y la indexación de bloques. Proxy y Hercules se construyen sobre él. El código fuente está en [`rome-protocol/rome-sdk`](https://github.com/rome-protocol/rome-sdk). Envía transacciones Solana v1 (4 KB, hasta 64 cuentas).

**Construirlo.** El espacio de trabajo espera que los repositorios [`rome-sdk`](https://github.com/rome-protocol/rome-sdk), [`rome-evm`](https://github.com/rome-protocol/rome-evm) y [`mollusk`](https://github.com/rome-protocol/mollusk) se clonen uno al lado del otro, porque depende de los otros dos por ruta relativa. Esa es también la razón por la que la forma admitida de usarlo desde otro proyecto es una dependencia de ruta, no una dependencia git normal. Necesitas Rust 1.85 o posterior y acceso a la red para la primera compilación. `rome-evm` no tiene una característica de red predeterminada, así que cualquier compilación que lo compile necesita exactamente una de `ci`, `red de pruebas` ni `red principal`; usa `ci` para trabajo local, por ejemplo `cargo test -p rome-sdk --features ci`. El README del repositorio tiene los pasos completos y la tabla de características.

**Licencia.** El SDK de Rust tiene el código fuente disponible, pero no es de código abierto: todos los derechos están reservados y puede usarse para fines personales, no comerciales. El uso comercial necesita permiso por escrito de Rome Protocol; el `LICENSE` indica cómo solicitarlo.

## SDK de Solidity: qué incluye

### Interfaces de precompilación

Vincula una interfaz a su dirección de precompilación:

```solidity
ISystemProgram          constant System   = ISystemProgram(0xFF00000000000000000000000000000000000007);
ICrossProgramInvocation constant Cpi      = ICrossProgramInvocation(0xFF00000000000000000000000000000000000008);
IHelperProgram          constant Helper   = IHelperProgram(0xFF00000000000000000000000000000000000009);
IWithdraw               constant Withdraw = IWithdraw(0x4200000000000000000000000000000000000016);
// Ruta en caché: ISplCached 0xff…05, IAssociatedSplCached 0xff…06, ISystemCached 0xff…04, IWithdrawCached 0xff…0b
```

### Operaciones con tokens SPL

Usa `IHelperProgram` (`0xff…09`) para primitivas SPL firmadas por PDA del usuario:

```solidity
// Crear la ATA del llamador para un mint
Helper.create_ata(user, mint);

// Transferir SPL desde la PDA del llamador
Helper.transfer_spl(to, tokens, mint);
```

En la ruta en caché, las operaciones equivalentes están en `ISplCached` (`0xff…05`y `IAssociatedSplCached` (`0xff…06`). Véase `interface.sol` para todos los sobrecargos; un contrato usa una sola ruta de forma consistente.

### Derivación de PDA

```solidity
// Derivar la PDA de Solana de un usuario
bytes32 userPda = RomeEVMAccount.pda(msg.sender);

// Derivar una PDA con sal (para crear múltiples PDAs por usuario)
bytes32 pda = RomeEVMAccount.pda_with_salt(msg.sender, salt);

// Encontrar una PDA arbitraria
(bytes32 pda, uint8 bump) = SystemProgram.find_program_address(programId, seeds);
```

### Invocación entre programas

```solidity
// Llamar a cualquier programa de Solana
ICrossProgramInvocation.AccountMeta[] memory accounts = new ICrossProgramInvocation.AccountMeta[](2);
accounts[0] = ICrossProgramInvocation.AccountMeta(signerPda, true, true);
accounts[1] = ICrossProgramInvocation.AccountMeta(targetAccount, false, true);

CpiProgram.invoke(programId, accounts, instructionData);

// Llamar con firma de PDA
CpiProgram.invoke_signed(programId, accounts, data, seeds);

// Leer datos de la cuenta
(uint64 lamports, bytes32 owner, bool isSigner, bool isWritable, bool executable, bytes memory data)
    = CpiProgram.account_info(pubkey);
```

### ERC-20 sobre tokens SPL

```solidity
// Desplegar un envoltorio para cualquier mint SPL
ERC20SPLFactory factory = ERC20SPLFactory(FACTORY_ADDRESS);
address wrapper = factory.add_spl_token_with_metadata(splMint);

// Usar el envoltorio como un ERC-20 estándar
SPL_ERC20 token = SPL_ERC20(wrapper);
token.transfer(recipient, amount);
uint256 balance = token.balanceOf(user);
```

### Deserialización Borsh

```solidity
import {Convert} from "@rome-protocol/rome-solidity/contracts/convert.sol";

// Analizar datos de cuenta de Solana (formato Borsh little-endian)
(uint64 value, uint256 newOffset) = Convert.read_u64le(data, offset);
(bytes32 pubkey, uint256 newOffset2) = Convert.read_bytes32(data, offset);
```

### Metadatos de Metaplex

```solidity
import {MplTokenMetadataLib} from "@rome-protocol/rome-solidity/contracts/mpl_token_metadata/lib.sol";

// Cargar metadatos del token desde Metaplex
MplTokenMetadataLib.Metadata memory meta = MplTokenMetadataLib.load_metadata(
    mintPubkey, mplProgramId, cpiAddress
);
string memory name = meta.name;
string memory symbol = meta.symbol;
```

## SDK de Rust: arquitectura

El SDK de Rust es un espacio de trabajo de Cargo. Sus crates principales:

| Paquete             | Propósito                                                                                                                                                                             |
| ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `rome-sdk`          | API central: `Rome` struct, config, los tres tipos de transacción (`RheaTx`, `RemusTx`, `RomulusTx`)                                                                                  |
| `rome-evm-client`   | Cliente EVM para cadenas Rome, TxBuilder, ResourceFactory, integración con el emulador                                                                                                |
| `rome-solana`       | torre de Solana, cliente RPC, agrupación y seguimiento de transacciones                                                                                                               |
| `rome-utils`        | utilidades de RLP, hex, JSON-RPC y autenticación                                                                                                                                      |
| `rome-obs`          | observabilidad con OpenTelemetry (trazas, métricas, registros)                                                                                                                        |
| `rome-meteora`      | lectores de pools Meteora DAMM v1 y v2 para la fijación del precio del gas                                                                                                            |
| `rome-meta-hook`    | Cliente para el programa Meta-Hook Router: configuración de transfer-hook de Token-2022, resolución de cuentas adicionales, transferencias con estimaciones de presupuesto de cómputo |
| `rome-jito-bundler` | constructor de bundles de Jito para envío atómico de múltiples transacciones                                                                                                          |

### Tipos de transacción

```rust
// Una transacción EVM en una cadena Rome
let rhea = RheaTx::new(signed_eth_tx);
let mut tx = rome.compose_rollup_tx(rhea).await?;
let sig = rome.send_and_confirm(&mut *tx).await?;

// Varias transacciones EVM en diferentes cadenas Rome, atómicas en una transacción Solana
let remus = RemusTx::new(vec![tx1, tx2]);
let mut tx = rome.compose_cross_rollup_tx(remus).await?;

// Transacciones EVM más instrucciones nativas de Solana, atómicas en una transacción Solana
let romulus = RomulusTx::new(eth_txs, sol_ixs);
let mut tx = rome.compose_cross_chain_tx(romulus, signers).await?;
```

### Agrupación de recursos

El SDK agrupa pares de claves de Solana (pagadores) e índices de cuentas holder para el envío paralelo de transacciones:

```rust
let resource = resource_factory.get().await?;
let payer = resource.payer();       // par de claves de Solana
let holder = resource.holder();     // Índice de cuenta holder
// El recurso se devuelve automáticamente al pool en Drop
```

## Hoja de ruta del SDK

### Construido y funcionando

* Envoltorios de tokens SPL e interfaces de precompilación
* Swaps de Meteora DAMM v1 mediante CPI
* Oracle Gateway V1 + V2 (Pyth Pull, Switchboard V3)
* Ayudantes de System Program, deserialización Borsh
* Fábrica ERC20SPL + contratos puente

## Qué sigue

* [Despliega Solidity](https://docs.rome.builders/es/guias-para-desarrolladores/deploy-solidity.md) — despliega tu primer contrato usando el SDK
* [Llamar a Solana desde EVM](https://docs.rome.builders/es/guias-para-desarrolladores/call-solana-from-evm.md) — usa CPI para interactuar con programas de Solana
* [Direcciones de contrato](https://docs.rome.builders/es/referencia/contract-addresses.md) — direcciones de contratos del SDK desplegados


---

# 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/productos/rome-sdk.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.
