> 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/introduccion/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 **fundación** paquetes sobre los que construyes, un generador de andamiaje, 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 vecinos responden preguntas distintas, y esta página enlaza con ambos en lugar de repetirlos:

* [Arquitectura](/es/introduccion/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 enruta según **desde dónde empiezas** (un contrato Solidity, un programa de Solana, desde cero, desde casa) a un único ejemplo lo más cercano posible 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

### Fundación — construye sobre esto

| Repo                                                            | Qué es                                                                                                                                                                                         | Úsalo cuando                                                       |
| --------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------ |
| [rome-registry](https://github.com/rome-protocol/rome-registry) | `@rome-protocol/registry` — proyección de solo lectura, generada, de hechos vivos de la cadena (ids, RPC, direcciones, mints de tokens, ids de programas, feeds de oráculo, 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 en TypeScript: `submitRomeTx` + dimensionamiento de tarifas, ambas vías, codificadores PDA/ATA + CPI, enlaces de precompile, un `/bridge` cliente. | Estás escribiendo código de app o frontend.                        |
| [rome-solidity](https://github.com/rome-protocol/rome-solidity) | Interfaces de precompilado en Solidity, envoltorios SPL/ERC-20 y adaptadores de oráculo: el conjunto 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 de fundación, 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. |

### Canton ZK EVM

| Repo                                                                                                                    | Qué es                                                                                                                           | Úsalo cuando                                                                                                                                    |
| ----------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
| [canton-zk-evm](https://github.com/rome-protocol/canton-zk-evm/blob/a84e84e439a5cc669c0ae61facf7c8c995d9d564/README.md) | Ostia, una versión temprana de un zkEVM de Canton que liquida bloques EVM probados y acciones de Canton en una sola transacción. | Estás ejecutando la demo local o estudiando su gateway y las comprobaciones de prueba. Ver [Canton ZK EVM](/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 carril: un pool nativo de Solana con un router EVM delgado.                                                      | Abriendo el otro carril; un ejemplo de **native-core** .   |
| [aerarium](https://github.com/rome-protocol/aerarium)                   | Préstamos de doble carril: un núcleo Comet en Solidity al que los usuarios de Solana acceden mediante un remitente sintético. | Abriendo el otro carril; un ejemplo de **Solidity-core** . |
| [cardo](https://github.com/rome-protocol/cardo)                         | Usuarios de EVM impulsando dApps de Solana (swap/stake/lend/perps) vía CPI.                                                   | Una app con CPI a Solana para estudiar paso a paso.        |
| [appia](https://github.com/rome-protocol/appia)                         | DeFi cross-VM centrado en posiciones; los usuarios acceden desde su cadena de origen.                                         | Una app **desde casa** .                                   |
| [rome-aave-v3-demo](https://github.com/rome-protocol/rome-aave-v3-demo) | Aave v3 supply/borrow/repay, desplegado sin cambios.                                                                          | Una app EVM completa funcionando 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 Compound III (Comet). | Forking de un protocolo EVM conocido. |
| [rome-aave-v3](https://github.com/rome-protocol/rome-aave-v3)                     | Fork de contratos de Aave v3.           | Forking 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 cadena + patrocinador de tarifas para el bridge en cadena. No guarda claves.        | Financiar una wallet, 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 vía la Chainlink `AggregatorV3Interface`. | Necesitas un feed de precios.                |

### Generador de andamiaje — 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` — genera una app de doble carril preconfigurada con el registry + SDK, con una comprobación financiada de ambos carriles. | Empezando una nueva app. |

## Cómo se componen

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

    CRA -->|genera, 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 vía AggregatorV3Interface| OG
    OG -.->|los adaptadores viven en| SOL
    CRA -.->|conecta| REG
    CRA -.->|conecta| SDK
```

La columna vertebral son tres fundaciones y un generador de andamiaje:

* [**rome-registry**](https://github.com/rome-protocol/rome-registry) es la única fuente de hechos vivos. [**rome-sdk-ts**](https://github.com/rome-protocol/rome-sdk-ts) es la ruta de escritura — y su `/bridge` subruta es el cliente que tu app usa 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 las dos primeras para una nueva app, de modo que un proyecto nuevo empiece ya leyendo el registry y escribiendo a través del SDK.

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

## Navega según lo que necesites

* **Un hecho vivo de la cadena** (id, address, mint, program id) → [rome-registry](https://github.com/rome-protocol/rome-registry). Nunca lo codifiques a mano.
* **Escribir código de app** (una escritura, una llamada CPI, un bridge) → [rome-sdk-ts](https://github.com/rome-protocol/rome-sdk-ts); referencia en [Rome SDK](/es/productos/rome-sdk.md).
* **Escribir contratos** → [rome-solidity](https://github.com/rome-protocol/rome-solidity); ver [Deploy Solidity Contracts](/es/guias-para-desarrolladores/deploy-solidity.md).
* **Llamar a un programa de Solana desde un contrato Solidity** → la precompile de CPI en [rome-solidity](https://github.com/rome-protocol/rome-solidity) (`interface.sol`); [cardo](https://github.com/rome-protocol/cardo) es un ejemplo trabajado.
* **Un ejemplo funcional** de un AMM, lending, CPI o app desde casa → las apps de referencia anteriores; el `AGENTS.md` de cada repo
* **ruta por punto de partida.** → [create-rome-app](https://github.com/rome-protocol/create-rome-app).
* **Una feed de precios** → [rome-oracle-gateway](https://github.com/rome-protocol/rome-oracle-gateway) (ver el [portal Oracle Gateway](/es/apps-en-rome/oracle-gateway.md)).
* **Usuarios en otra cadena** → [Desde casa](/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](/es/conceptos-basicos/choose-your-core.md).

## La capa de fundación, de cerca

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

El registry es **generado** a partir de la fuente interna de Rome: una allowlist emite solo lo que está pensado para ser público, **sustituye** los endpoints internos por sus equivalentes públicos, y **niega por defecto** todo lo demás; así que es seguro para publicar por diseño. Publica, por cadena, `chain.json` / `tokens.json` / `contracts.json` / `oracle.json` / `bridge.json` / `alts.json`y además los `programas` de Solana y los 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 programas 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`) — por ejemplo, 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 necesitas a un archivo JSON estático en tiempo de compilación e импórtalo en el cliente. (Eso 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 que cuyo `estado` es `live`. [Leer la lista de contratos](/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 [Contract Addresses](/es/referencia/contract-addresses.md) .

### rome-sdk-ts — la ruta de escritura, ambos carriles

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 calldata o tarifas a mano:

* **`submitRomeTx`** — la ruta de escritura del carril EVM: calcula el gas con `eth_estimateGas` (rellenado, con un límite de respaldo cuando la estimación revierte) y proporciona tarifas EIP-1559.
* **`submitRomeTxV1`** — lo mismo, para una **wallet de Solana** impulsando tu app EVM: una transacción Solana v1 por llamada, dos avisos 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 puras de Solana alrededor de una llamada (la fund leg, la creación de la cuenta token de la wallet antes de un sweep) 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 nuevo sintético (`create_pda`) en el primer uso.
* **Derivación de PDA/ATA, CPI `invoke`/`invoke_signed` codificadores, enlaces de precompile**y una **`/bridge`** subruta (`@rome-protocol/sdk/bridge`) — cliente de bridge que primero cotiza.

API completa + ejemplos: [Rome SDK](/es/productos/rome-sdk.md)y las guías [Llamar a Solana desde EVM](/es/guias-para-desarrolladores/call-solana-from-evm.md), [Llamar a EVM desde Solana](/es/guias-para-desarrolladores/call-evm-from-solana.md)y [Construir una app de doble carril](/es/guias-para-desarrolladores/dual-lane-app.md).

### rome-solidity — el conjunto 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 el remapeo `@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`es, así que la misma ruta de importación funciona con ambos.

Lo que importan tus contratos:

* **`contracts/interface.sol`** — las interfaces de precompile enlazadas 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`). Una familia **cacheada** optimizada para gas también vive aquí; un contrato usa una vía de forma consistente. Tabla completa de direcciones: [Contract Addresses](/es/referencia/contract-addresses.md).
* **Envoltorios SPL/ERC-20** — `SPL_ERC20` (basado en CPI) y `SPL_ERC20_cached` (la vía cacheada, usada en devnet); cualquier mint SPL ya es un ERC-20 a través de esto.
* **Adaptadores de oráculo** (`contracts/oracle/`— los adaptadores Pyth/Switchboard `rome-oracle-gateway` desplegados, se leen vía `IAggregatorV3Interface`.
* Ejemplos trabajados en `contracts/examples/`.

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

## Qué sigue

* [Elige tu núcleo](/es/conceptos-basicos/choose-your-core.md) — qué lado contiene tu lógica.
* [Inicio rápido](/es/introduccion/quickstart.md) — despliega tu primer contrato.
* [create-rome-app](https://github.com/rome-protocol/create-rome-app) — genera una app de doble carril.
* Cada repo's `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/introduccion/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.