> 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 la de Chainlink `AggregatorV3Interface`por lo que los protocolos de Ethereum que se portan a Rome conservan su código de integración de oráculos existente. **Oracle Gateway V2 está desplegado en Hadrian y Rubicon**aunque el registro solo lista direcciones de feeds para Hadrian, y un portal para clientes gestiona el registro. Un keeper ejecutado en Rome actualiza los feeds en caché y los 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 fábrica y el modelo de keeper se cubren en el [rome-oracle-gateway](https://github.com/rome-protocol/rome-oracle-gateway) repositorio.

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

## El problema

DeFi de Ethereum espera la interfaz de Chainlink `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 precios 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 el 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 a 8 decimales (p. ej., 15000000000 = $150.00)
```

## Consume un feed en tres pasos

1. **Resuelve la dirección del adaptador desde el registro** — nunca la codifiques de forma fija:

```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 feed llevan un sufijo que indica qué tipo de adaptador hay detrás; consulta [Claves de feed 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 con caché hacen que cada consumidor lea un simple `SLOAD`, por lo que las transacciones con varios feeds (un préstamo multicolateral, una vista de cartera) siguen siendo baratas.

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

## Tipos de adaptador

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

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

## Claves de feed en el registro

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

| Clave                | Tipo de adaptador                    | Cómo lo 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 llamadas `latestRoundData()` de solo lectura sobre los feeds listados en registry v0.2.0, hechas mientras se escribía esta página. La frescura de los feeds cambia de minuto en minuto en devnet, así que trátalo como una instantánea y ejecuta la misma llamada en el feed que planeas 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) revirtió con `StalePriceFeed` cada vez, y `SOL/USD` respondió en algunas llamadas y no en otras. Los feeds `-BOOK` fueron los más fiables y respondieron en cada llamada para todos los activos excepto JTO, cuyo `-BOOK` feed revirtió por estar obsoleto. Cada `-CACHED` y `-CACHEDPYTH` feed revirtió con `UninitializedPriceFeed` (nada los ha refrescado), y `SOL/USD-SB` revirtió con `StalePriceFeed`. `-BOOK` feed, y ejecuta `latestRoundData()` en el feed que elijas antes de depender de él.
* **Rubicon.** El registro no lista feeds de oráculo para Rubicon, así que esta página no los cubre. La fábrica está desplegada allí (véase [Direcciones desplegadas](#deployed-addresses)) y sus primeros adaptadores responden, pero busca las direcciones de los feeds en la fábrica (`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 ruidosamente en lugar de devolver un precio antiguo. Manejalo en tu contrato.

## Frescura — el oracle-keeper

Los adaptadores imponen una `maxStaleness` ventana: si `block.timestamp - publishTime > maxStaleness`, las lecturas revierten. En Solana mainnet, Pyth ejecuta keepers de producción. En Solana devnet (donde vive Hadrian), los pushers de Pyth son de mejor esfuerzo, así que Rome ejecuta su propio **oracle-keeper** sidecar para mantener frescas las cuentas subyacentes de Pyth y para refrescar los feeds en caché y del libro. El keeper no cubre todos los feeds 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 `metadata()`de cada adaptador, `latestRoundData` — un feed puede ser accesible pero estar obsoleto.

## Portal para 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](https://docs.rome.builders/es/apps-en-rome/oracle-gateway.md) para ver qué cubre.

## Direcciones desplegadas

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

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

## Restricciones

* **No hay datos históricos de rondas** — `getRoundData(roundId)` revierte; solo `latestRoundData()` se admite.
* **EMA de Switchboard no compatible** — los datos EMA son solo de Pyth.
* **Obsolescencia por cadena** — `maxStaleness` se establece por entorno en la puesta en marcha: los adaptadores directos (de lectura Pyth) tienen un valor predeterminado de \~60 segundos; los adaptadores con caché tienen un valor predeterminado de 3600 segundos (cuando el keeper los refresca, 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 nueva validación.

## Qué sigue

* [portal Oracle Gateway](https://docs.rome.builders/es/apps-en-rome/oracle-gateway.md) — registra feeds, configura consumidores
* [Direcciones de contrato](https://docs.rome.builders/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.
