> 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/oracle-gateway.md).

# Oracle Gateway

Fuentes de precios de Pyth y Switchboard detrás de la interfaz AggregatorV3Interface de Chainlink.

El Oracle Gateway expone feeds de precios nativos de Solana (Pyth, Switchboard V3) a través de Chainlink `AggregatorV3Interface`, por lo que los protocolos de Ethereum que se portan a Rome conservan su código existente de integración con oráculos. **Oracle Gateway V2 está desplegado en Hadrian y Rubicon**, aunque el registro solo enumera direcciones de feeds para Hadrian, y un portal de clientes gestiona el registro. Un keeper ejecutado por Rome actualiza los feeds en caché y del libro, pero no todos los feeds están frescos en todo momento — [qué feeds responden hoy](#which-feeds-answer-today) se explica a continuación. Los adaptadores, la factory y el modelo de keeper se cubren en el [rome-oracle-gateway](https://github.com/rome-protocol/rome-oracle-gateway) repositorio.

> **Vista previa.** Oracle Gateway no ha sido auditado. El portal dice lo mismo: no lo uses en flujos de valor de producción.

## El problema

Ethereum DeFi espera la `AggregatorV3Interface`:

```solidity
(, int256 price,,,) = priceFeed.latestRoundData();
```

Los proveedores de oráculos de Solana (Pyth, Switchboard) tienen formatos de datos diferentes. Sin adaptación, cada protocolo portado necesitaría código de oráculo personalizado.

## La solución

Oracle Gateway V2 despliega contratos adaptadores ligeros que:

1. Leen datos de precio directamente desde cuentas de Pyth o Switchboard en Solana (lecturas entre estados, no CPI)
2. Analizan los datos en cadena
3. Normalizan los precios a 8 decimales
4. Exponen la interfaz estándar de Chainlink `AggregatorV3Interface`

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

// Misma interfaz que Chainlink en Ethereum
(, int256 price,,,) = IAggregatorV3Interface(ADAPTER).latestRoundData();
// price = SOL/USD con 8 decimales (por ejemplo, 15000000000 = $150.00)
```

## Consume un feed en tres pasos

1. **Resuelve la dirección del adaptador a partir del registro** — nunca la codifiques a mano:

```ts
import { getOracle } from "@rome-protocol/registry";
const solUsd = getOracle(200010).feeds["SOL/USD"].address;
// Hadrian, registry v0.2.0: 0x567384ee000ca0418c386A73eC2b7466f9f99D6b
```

El registro se instala desde GitHub (`npm install github:rome-protocol/rome-registry#v0.2.0`). Las claves de los feeds llevan un sufijo que indica qué tipo de adaptador hay detrás; consulta [las claves de los feeds en el registro](#feed-keys-in-the-registry) antes de elegir uno.

2. **Léelo** con la interfaz que tu protocolo ya usa — `IAggregatorV3Interface(solUsd).latestRoundData()`. Un feed obsoleto o no inicializado **revierte** en lugar de servir un precio congelado.
3. **¿Varios feeds a la vez?** `BatchReader.getLatestPrices(adapters[])` (Hadrian, registry v0.2.0: `0x2869f0a96572e7fb15036656e9a32fd17346499b`) — y `getFeedHealth(adapters[])` antes de depender de ellos. Los adaptadores en caché hacen que cada consumidor lea un simple `SLOAD`, así que las transacciones con varios feeds (un préstamo con varios colaterales, una vista de cartera) siguen siendo baratas.

[cardo](https://github.com/rome-protocol/cardo) lee estos feeds en Hadrian. Como la superficie es exactamente `AggregatorV3Interface`, los protocolos de clase Compound y Aave pueden usar estos feeds sin cambios en el código del oráculo — apunta su configuración de feeds de precios a las direcciones de los adaptadores.

## Tipos de adaptadores

* **PythPullAdapter** — lee cuentas de precio de Pyth (precio, confianza, EMA, hora de publicación).
* **SwitchboardV3Adapter** — lee cuentas agregadoras de Switchboard (precio, marca temporal; sin EMA).
* **Adaptadores CachedPyth / CachedFeed** — variantes con seguimiento en caché para lecturas eficientes en CU.
* **BookFeedAdapter** — una vista de solo lectura compatible con Chainlink sobre una entrada de un `PriceBook` contrato. El libro guarda los precios de todos sus feeds registrados y se actualiza por lotes (la actualización es sin permisos); el adaptador de cada feed no mantiene su propia caché. Una entrada pausada revierte de inmediato con `AdapterPaused`, en lugar de esperar a volverse obsoleta.

Los adaptadores se despliegan como clones proxy mínimos EIP-1167: el `OracleAdapterFactory` clona los adaptadores de Pyth, Switchboard y los adaptadores en caché, y cada `PriceBook` clona el suyo propio `BookFeedAdapter` cuando se registra un feed. Exponen una interfaz ampliada junto con `AggregatorV3Interface` (`latestPriceData`, `maxStaleness`, `oracleType`y una `metadata()` la superficie usada para comprobaciones de estado).

## las claves de los feeds en el registro

`getOracle(chainId).feeds` tiene varias claves por activo. El sufijo de la clave nombra el tipo de adaptador:

| Clave                | Tipo de adaptador                    | Cómo lee                                                                                        |
| -------------------- | ------------------------------------ | ----------------------------------------------------------------------------------------------- |
| `SOL/USD`            | Pyth directo (`PythPullAdapter`)     | Analiza la cuenta de Pyth en cada llamada.                                                      |
| `SOL/USD-BOOK`       | `BookFeedAdapter`                    | Lee una `PriceBook` entrada que el keeper actualiza.                                            |
| `SOL/USD-CACHED`     | En caché (envuelve otro feed)        | Lee un precio almacenado que el keeper actualiza.                                               |
| `SOL/USD-CACHEDPYTH` | Pyth en caché (`CachedPythAdapter`)  | Lee un precio almacenado que el keeper actualiza.                                               |
| `SOL/USD-SB`         | Switchboard (`SwitchboardV3Adapter`) | Analiza la cuenta de Switchboard en cada llamada. El registro marca estas entradas `retiradas`. |

Cuál consumir depende de la cadena. Revisa primero la siguiente sección.

### Qué feeds responden hoy

Estos son resultados de `latestRoundData()` llamadas de solo lectura sobre los feeds enumerados en registry v0.2.0, realizadas mientras se escribía esta página. La frescura de los feeds cambia de minuto a minuto en devnet, así que trátalo como una instantánea y ejecuta la misma llamada en el feed que piensas usar.

* **Hadrian.** Los feeds directos suelen estar obsoletos: en comprobaciones repetidas, la mayoría de ellos (BONK, BTC, ETH, JITOSOL, JTO, JUP, MSOL, USDC, USDT) revertían con `StalePriceFeed` cada vez, y `SOL/USD` respondieron en algunas llamadas y no en otras. `-BOOK` feeds fueron los más fiables y respondieron en cada llamada para cada activo excepto JTO, cuyo `-BOOK` feed revirtió por estar obsoleto. `-CACHED` y `-CACHEDPYTH` feed revirtió con `UninitializedPriceFeed` (nada los ha actualizado), y `SOL/USD-SB` revirtió con `StalePriceFeed`. `-BOOK` En Hadrian, prefiere el `latestRoundData()` feed, y ejecuta
* **Rubicon.** El registro no enumera feeds de oráculo para Rubicon, así que esta página no los cubre. La factory está desplegada allí (véase [Direcciones desplegadas](#deployed-addresses)) y sus primeros adaptadores responden, pero busca las direcciones de los feeds en la factory (`adapterCount()` y `allAdapters(i)`) en lugar de en el registro.

Un revert aquí es el comportamiento diseñado: un feed obsoleto o no inicializado falla de forma explícita en lugar de devolver un precio antiguo. Manéjalo en tu contrato.

## Frescura — el oracle-keeper

Los adaptadores aplican una `maxStaleness` ventana: si `block.timestamp - publishTime > maxStaleness`, las lecturas revierten. En la mainnet de Solana, Pyth ejecuta keepers de producción. En la devnet de Solana (donde vive Hadrian), los pushers de Pyth son de mejor esfuerzo, así que Rome ejecuta su propio **oracle-keeper** sidecar para mantener actualizadas las cuentas subyacentes de Pyth y para refrescar los feeds en caché y los feeds del libro. El keeper no cubre cada feed en cada cadena en todo momento (véase [qué feeds responden hoy](#which-feeds-answer-today)).

Comprueba la salud del feed con `BatchReader.getFeedHealth` (que lee la `metadata()`metadata() `), no solo` latestRoundData

## Portal de clientes

Registra feeds y configura consumidores por cadena a través del [portal Oracle Gateway](https://oracle.testnet.romeprotocol.xyz/). Consulta la [página del portal](/es/apps-en-rome/oracle-gateway.md) para ver qué cubre.

## Direcciones desplegadas

Las direcciones canónicas por cadena (factories, implementaciones de adaptadores y los feeds activos) están en el [registro](https://github.com/rome-protocol/rome-registry/tree/main/chains). Fábricas principales, a partir de las `live` entradas del registro v0.2.0 (versión 5.0.0 en Hadrian; las direcciones de Rubicon son las de la [Contract Addresses](/es/referencia/contract-addresses.md) página); véase [Leer la lista de contratos](/es/referencia/contract-addresses.md#reading-the-contracts-list):

| Contrato             | Hadrian                                      | Rubicon                                      |
| -------------------- | -------------------------------------------- | -------------------------------------------- |
| OracleAdapterFactory | `0x52b008771fc95b4674a4f3533570b3d223f27f68` | `0x6a1340dd86c3951b6f13d9001b3951d56a2fe581` |
| BatchReader          | `0x2869f0a96572e7fb15036656e9a32fd17346499b` | `0x580dc0ecb226530ee8a90b57e0f0cd2555fb4f0f` |

## Restricciones

* **Sin datos históricos de rondas** — `getRoundData(roundId)` revierten; solo `latestRoundData()` se admite.
* **EMA de Switchboard no compatible** — los datos de EMA son solo de Pyth.
* **La obsolescencia por cadena** — `maxStaleness` se establece por entorno al arrancar: los adaptadores directos (lectura de Pyth) usan por defecto \~60 segundos; los adaptadores en caché usan por defecto 3600 segundos (cuando el keeper los actualiza, lo hace con mucha más frecuencia que eso).
* **Desplazamientos del analizador** se validan frente a los diseños actuales de Pyth/Switchboard; los cambios de diseño requieren una nueva validación.

## Qué sigue

* [portal Oracle Gateway](/es/apps-en-rome/oracle-gateway.md) — registra feeds, configura consumidores
* [Contract Addresses](/es/referencia/contract-addresses.md) — precompiles y direcciones por cadena


---

# 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/oracle-gateway.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.