> 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/primeros-pasos-1/ecosystem.md).

# Ecosistema y repos

Cada repositorio público de Rome, qué es y cómo se compone: el mapa para navegar la superficie.

La superficie pública de Rome es un conjunto de repositorios: unos pocos **base** paquetes sobre los que construyes, un generador de andamios, apps de referencia de las que aprender, y dos servicios a los que llama tu app. Esta página es el mapa: qué es cada repo y cómo encajan entre sí.

Dos vecinas responden a preguntas diferentes, y esta página enlaza a ambas en lugar de repetirlas:

* [Arquitectura](https://docs.rome.builders/es/primeros-pasos-1/architecture.md) explica el **protocolo** — cómo se ejecuta la EVM dentro de un programa de Solana.
* Cada repo incluye un **`AGENTS.md`** (p. ej., [rome-sdk-ts/AGENTS.md](https://github.com/rome-protocol/rome-sdk-ts/blob/main/AGENTS.md)) que dirige, según **desde dónde empiezas** (un contrato de Solidity, un programa de Solana, desde cero, desde casa) al ejemplo más cercano a tu caso.

Esta página es el nivel intermedio: la **superficie completa** y cómo se conectan las piezas.

## La superficie de un vistazo

### Base — construye sobre estos

| Repo                                                            | Qué es                                                                                                                                                                                             | Úsalo cuando                                                      |
| --------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------- |
| [rome-registry](https://github.com/rome-protocol/rome-registry) | `@rome-protocol/registry` — proyección generada y de solo lectura de hechos sobre la cadena en vivo (ids, RPC, direcciones, acuñaciones de tokens, ids de programas, feeds de oráculos, ALTs).     | Necesitas un hecho real de la cadena; nunca lo codifiques a mano. |
| [rome-sdk-ts](https://github.com/rome-protocol/rome-sdk-ts)     | `@rome-protocol/sdk` — la ruta de escritura de TypeScript: `submitRomeTx` + dimensionamiento de tarifas, ambas vías, codificadores PDA/ATA + CPI, enlaces de precompilación, un `/bridge` cliente. | Estás escribiendo código de app o frontend.                       |
| [rome-solidity](https://github.com/rome-protocol/rome-solidity) | Interfaces de precompilación de Solidity, envoltorios SPL/ERC-20 y los adaptadores de oráculo — el kit de herramientas del lado del contrato.                                                      | Estás escribiendo contratos.                                      |

Los `@rome-protocol/…` nombres anteriores son nombres de paquetes, pero los paquetes no se publican en npm. Instálalos desde GitHub (los comandos están en cada sección bajo [La capa base, de cerca](#the-foundation-layer-up-close)); las rutas de importación en tu código siguen siendo las mismas.

### Rollups ZK EVM de Rome

| Repo                                                            | Qué es                                                               | Úsalo cuando                                                        |
| --------------------------------------------------------------- | -------------------------------------------------------------------- | ------------------------------------------------------------------- |
| [solana-zk-evm](https://github.com/rome-protocol/solana-zk-evm) | Programas de rollup ZK, nodo, probador y documentación del operador. | Estás ejecutando una cadena EVM que se liquida en Solana.           |
| [rome-zk-guest](https://github.com/rome-protocol/rome-zk-guest) | Fuente del guest por lotes compilada para el génesis de cada cadena. | Estás construyendo un guest y solicitando su clave de verificación. |

### Ostia (ZK EVM en Canton)

| Repo                                                                                  | Qué es                                                                                                               | Úsalo cuando                                                                                                                                                                                                  |
| ------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [canton-zk-evm](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/README.md) | Ostia, una ZK EVM en Canton: cada bloque EVM probado se confirma con sus acciones de Canton en una sola transacción. | Estás construyendo sobre Ostia DevNet ([explorador](https://ostia.devnet.romeprotocol.xyz/)) o ejecutando tu propio Ostia. Ver [Canton ZK EVM](https://docs.rome.builders/es/canton-zk-evm/canton-zk-evm.md). |

### Apps de referencia — aprende con ejemplos

| Repo                                                                    | Qué es                                                                                                                      | Úsalo cuando                                            |
| ----------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------- |
| [rome-dex](https://github.com/rome-protocol/rome-dex)                   | AMM de doble vía — un pool nativo de Solana con un router EVM ligero.                                                       | Abriendo la otra vía; un ejemplo de **native-core** .   |
| [aerarium](https://github.com/rome-protocol/aerarium)                   | Préstamos de doble vía — un núcleo Comet de Solidity al que los usuarios de Solana acceden mediante un remitente sintético. | Abriendo la otra vía; un ejemplo de **Solidity-core** . |
| [cardo](https://github.com/rome-protocol/cardo)                         | Usuarios de EVM que operan dApps de Solana (swap/stake/lend/perps) mediante CPI.                                            | Una aplicación CPI-a-Solana completa para estudiar.     |
| [appia](https://github.com/rome-protocol/appia)                         | DeFi entre VM, centrada en posiciones; los usuarios acceden a ella desde su cadena de origen.                               | Una app **desde casa** .                                |
| [rome-aave-v3-demo](https://github.com/rome-protocol/rome-aave-v3-demo) | Suministro/préstamo/reembolso de Aave v3, desplegado sin cambios.                                                           | Una app EVM completa ejecutándose tal cual.             |

### Forks de contratos — protocolos conocidos, desplegados en Rome

| Repo                                                                              | Qué es                                     | Úsalo cuando                       |
| --------------------------------------------------------------------------------- | ------------------------------------------ | ---------------------------------- |
| [compound-on-rome-comet](https://github.com/rome-protocol/compound-on-rome-comet) | Mercado monetario de Compound III (Comet). | Fork de un protocolo EVM conocido. |
| [rome-aave-v3](https://github.com/rome-protocol/rome-aave-v3)                     | Fork de contratos de Aave v3.              | Fork de un protocolo EVM conocido. |

### Servicios — tu app llama a estos

| Repo                                                                        | Qué es                                                                                                        | Úsalo cuando                                  |
| --------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------- | --------------------------------------------- |
| [rome-bridge-api](https://github.com/rome-protocol/rome-bridge-api)         | Orquestador fuera de la cadena + patrocinador de tarifas para el puente en cadena. No guarda claves.          | Financiar una cartera, o un flujo desde casa. |
| [rome-oracle-gateway](https://github.com/rome-protocol/rome-oracle-gateway) | Feeds de precios de Solana (Pyth, Switchboard) expuestos a EVM mediante el Chainlink `AggregatorV3Interface`. | Necesitas un feed de precios.                 |

### Andamio — empieza aquí

| Repo                                                                | Qué es                                                                                                                                                                       | Úsalo cuando             |
| ------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------ |
| [create-rome-app](https://github.com/rome-protocol/create-rome-app) | `npx github:rome-protocol/create-rome-app` — crea un andamiaje para una app de doble vía, preconectada con el registro + SDK, con una comprobación financiada en ambas vías. | Empezando una app nueva. |

## Cómo se compone

```mermaid
flowchart TD
    REG["rome-registry — hechos de la cadena en vivo"]
    SDK["rome-sdk-ts — escrituras, CPI, cliente de puente"]
    SOL["rome-solidity — interfaces de precompilación, envoltorios SPL, adaptadores de oráculo"]
    CRA["create-rome-app — generador de andamios"]
    APP["tu app — frontend + contratos"]
    BAPI["rome-bridge-api — orquestador fuera de la cadena, no guarda claves"]
    OG["rome-oracle-gateway — feeds de precios de Solana"]

    CRA -->|crea andamiaje, preconfigurado| APP
    REG -->|hechos, nunca codificados a mano| APP
    SDK -->|ruta de escritura y CPI| APP
    SOL -->|importado por tus contratos| APP
    APP -->|SDK /cliente de bridge| BAPI
    APP -->|lee mediante AggregatorV3Interface| OG
    OG -.->|los adaptadores viven en| SOL
    CRA -.->|conecta| REG
    CRA -.->|conecta| SDK
```

La columna vertebral son tres bases y un generador de andamios:

* [**rome-registry**](https://github.com/rome-protocol/rome-registry) es la única fuente de hechos en vivo. [**rome-sdk-ts**](https://github.com/rome-protocol/rome-sdk-ts) es la ruta de escritura — y su `/bridge` subruta es el cliente que usa tu app para hablar con `rome-bridge-api`. [**rome-solidity**](https://github.com/rome-protocol/rome-solidity) es lo que importan tus contratos (y los forks); los adaptadores de oráculo que `rome-oracle-gateway` también se despliegan allí. Los tres son independientes entre sí: elige los que necesite tu app.
* [**create-rome-app**](https://github.com/rome-protocol/create-rome-app) une los dos primeros para una app nueva, de modo que un proyecto fresco empiece ya leyendo el registro y escribiendo a través del SDK.

Las apps de referencia son la excepción que vale la pena conocer: **preceden a los paquetes extraídos.** cardo consume el paquete del registro; appia proyecta el registro a JSON estático en tiempo de compilación; y ambos empaquetan su propia ruta de escritura en lugar de importar el SDK. Léelas para aprender los patrones — pero una app **nueva** debería empezar desde `create-rome-app` + los paquetes, no clonando una app.

## Navega según lo que necesites

* **Un hecho de cadena en vivo** (id, dirección, mint, id de programa) → [rome-registry](https://github.com/rome-protocol/rome-registry). Nunca lo codifiques.
* **Escribir código de app** (una escritura, una llamada CPI, un puente) → [rome-sdk-ts](https://github.com/rome-protocol/rome-sdk-ts); referencia en [Rome SDK](https://docs.rome.builders/es/productos/rome-sdk.md).
* **Escribir contratos** → [rome-solidity](https://github.com/rome-protocol/rome-solidity); consulta [Desplegar contratos de Solidity](https://docs.rome.builders/es/guias-para-desarrolladores/deploy-solidity.md).
* **Llamar a un programa de Solana desde un contrato de Solidity** → la precompilación CPI en [rome-solidity](https://github.com/rome-protocol/rome-solidity) (`interface.sol`); [cardo](https://github.com/rome-protocol/cardo) es un ejemplo completo.
* **Un ejemplo funcional** de un AMM, lending, CPI o app desde casa → las apps de referencia anteriores; cada `AGENTS.md` repo dirige según el punto de partida.
* **Crear el andamiaje de una app nueva** → [create-rome-app](https://github.com/rome-protocol/create-rome-app).
* **Un feed de precios** → [rome-oracle-gateway](https://github.com/rome-protocol/rome-oracle-gateway) (ver el [portal Oracle Gateway](https://docs.rome.builders/es/apps-en-rome/oracle-gateway.md)).
* **Usuarios en otra cadena** → [Desde casa](https://docs.rome.builders/es/guias-para-desarrolladores/from-home.md) + [rome-bridge-api](https://github.com/rome-protocol/rome-bridge-api).
* **Decidir qué lado contiene tu lógica** → [Elige tu núcleo](https://docs.rome.builders/es/conceptos-basicos/choose-your-core.md).

## La capa base, de cerca

### rome-registry — hechos en vivo, públicos por diseño

El registro es **generado** a partir de la fuente interna de Rome: una allowlist emite solo lo destinado a ser público, **sustituye** los endpoints internos por sus equivalentes públicos, y **rechaza por defecto** todo lo demás — así que es seguro para uso público por diseño. Publica, por cadena, `chain.json` / `tokens.json` / `contracts.json` / `oracle.json` / `bridge.json` / `alts.json`, además de programas de `Solana` y despliegues de apps por protocolo.

Instálalo desde GitHub, fijado a una etiqueta de versión: `npm install github:rome-protocol/rome-registry#v0.2.0`. Lo lees mediante getters — `getChain`, `getTokens`, `getContracts`, `getOracle`, `getBridge`, `getAlts`, y `getPrograms(network)` (los ids de programa se indexan por red, no por id de cadena). El paquete es ESM puro (hoy no incluye tipos TypeScript empaquetados).

Dos cosas que debes saber antes de integrarlo:

* **`getTokens()` no devuelve `assetRef`.** Para encontrar el wrapper de un token, haz coincidir su **mint** (`mintId`) — p. ej., el wrapper del token de gas es la entrada que comparte su mint.
* **Lee JSON desde disco (`node:fs`) — no es seguro para navegador.** En una app web, proyecta los valores que necesites a un archivo JSON estático en tiempo de compilación e impórtalo en el cliente. (Esto es exactamente lo que `create-rome-app` y appia hacen.)

Las direcciones de contrato se devuelven como una lista de versiones por contrato; elige la cuya `estado` es `live`. [Leer la lista de contratos](https://docs.rome.builders/es/referencia/contract-addresses.md#reading-the-contracts-list) muestra cómo. Los hechos que tu app no lee en vivo también aparecen en la referencia de [Direcciones de contrato](https://docs.rome.builders/es/referencia/contract-addresses.md) .

### rome-sdk-ts — la ruta de escritura, ambas vías

Instala desde GitHub: `npm install github:rome-protocol/rome-sdk-ts#v0.4.0`.

`@rome-protocol/sdk` (v0.4.0) envuelve todo lo que necesita una escritura de Rome para que no tengas que construir a mano calldata ni tarifas:

* **`submitRomeTx`** — la ruta de escritura de la vía EVM: dimensiona el gas a partir de `eth_estimateGas` (con relleno, y un techo de respaldo cuando la estimación revierte) y suministra tarifas EIP-1559.
* **`submitRomeTxV1`** — lo mismo, para una **cartera de Solana** que impulsa tu app EVM: una transacción Solana v1 por llamada, dos solicitudes de firma. El remitente sintético no guarda nada en reposo; `buildFundLeg`/`buildSweepLeg` mueve valor dentro y fuera como un ERC-20 (`wUSDC`), **no** nativo `msg.value`; las instrucciones Solana simples alrededor de una llamada (la pierna de financiación, la creación de la cuenta de token de la cartera antes de una barrida) pasan por `submitSolanaInstructionsV1` también como transacciones v1. `submitRomeTxSolanaLane` es la ruta anterior, que construye una transacción Solana heredada en el cliente y aprovisiona automáticamente un sintético nuevo (`create_pda`) en el primer uso.
* **Derivación de PDA/ATA, CPI `invoke`/`invoke_signed` codificadores, enlaces de precompilación**, y una **`/bridge`** subruta (`@rome-protocol/sdk/bridge`) — cliente de bridge con cotización primero.

API completa + ejemplos: [Rome SDK](https://docs.rome.builders/es/productos/rome-sdk.md), y las guías [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), y [Crear una app de doble vía](https://docs.rome.builders/es/guias-para-desarrolladores/dual-lane-app.md).

### rome-solidity — el kit de herramientas del lado del contrato

Instálalo desde GitHub, no desde npm. Con npm o Hardhat: `npm install github:rome-protocol/rome-solidity`. Con Foundry: `forge install rome-protocol/rome-solidity`, luego añade la reasignación `@rome-protocol/rome-solidity/=lib/rome-solidity/` a `foundry.toml` (bajo `[profile.default]`, como `remappings = [...]`) para que `@rome-protocol/rome-solidity/contracts/interface.sol` se resuelva. El nombre del paquete en `package.json` es `@rome-protocol/rome-solidity`, así que la misma ruta de importación funciona con ambos.

Lo que importan tus contratos:

* **`contracts/interface.sol`** — las interfaces de precompilación vinculadas a sus direcciones: **CPI** `ICrossProgramInvocation` (`0xFF…08`), **Helper** `IHelperProgram` (`0xFF…09`, creación de ATA/PDA, transferencias SPL, gas↔lamports), **Withdraw** `IWithdraw` (`0x42…16`), y **System** (`0xFF…07`). También vive aquí una familia optimizada para gas de **caché** ; un contrato usa una vía de forma consistente. Tabla completa de direcciones: [Direcciones de contrato](https://docs.rome.builders/es/referencia/contract-addresses.md).
* **envoltorios SPL/ERC-20** — `SPL_ERC20` (basado en CPI) y `SPL_ERC20_cached` (la vía en caché, usada en devnet); cualquier mint SPL ya es un ERC-20 a través de estos.
* **Adaptadores de oráculo** (`contracts/oracle/`) — los adaptadores Pyth/Switchboard `rome-oracle-gateway` se despliegan, se leen mediante `IAggregatorV3Interface`.
* Ejemplos completos en `contracts/examples/`.

La sección de SDK de Solidity de [Rome SDK](https://docs.rome.builders/es/productos/rome-sdk.md) muestra los patrones de importación y los enlaces de precompilación en código.

## Qué sigue

* [Elige tu núcleo](https://docs.rome.builders/es/conceptos-basicos/choose-your-core.md) — qué lado contiene tu lógica.
* [Inicio rápido](https://docs.rome.builders/es/primeros-pasos-1/quickstart.md) — despliega tu primer contrato.
* [create-rome-app](https://github.com/rome-protocol/create-rome-app) — crea el andamiaje de una app de doble vía.
* De cada repositorio `AGENTS.md` — la ruta por punto de partida al ejemplo más cercano.


---

# 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/primeros-pasos-1/ecosystem.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.
