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

# Oracle Gateway

Pyth- und Switchboard-Preisfeeds hinter Chainlinks AggregatorV3Interface.

Das Oracle Gateway stellt Solana-native Preisfeeds (Pyth, Switchboard V3) über Chainlinks `AggregatorV3Interface`, sodass nach Rome portierte Ethereum-Protokolle ihren bestehenden Oracle-Integrationscode beibehalten. **Oracle Gateway V2 ist auf Hadrian und Rubicon bereitgestellt**, obwohl das Registry Feed-Adressen nur für Hadrian auflistet, und ein Kundenportal die Registrierung übernimmt. Ein von Rome betriebener Keeper aktualisiert die gecachten und Book-Feeds, aber nicht jeder Feed ist in jedem Moment frisch — [welche Feeds heute antworten](#which-feeds-answer-today) ist unten erläutert. Die Adapter-, Factory- und Keeper-Modelle werden im [rome-oracle-gateway](https://github.com/rome-protocol/rome-oracle-gateway) Repo behandelt.

> **Vorschau.** Das Oracle Gateway wurde nicht auditiert. Das Portal sagt dasselbe: Nicht in Produktions-Value-Flows verwenden.

## Das Problem

Ethereum-DeFi erwartet Chainlinks `AggregatorV3Interface`:

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

Solanas Oracle-Anbieter (Pyth, Switchboard) haben unterschiedliche Datenformate. Ohne Anpassung bräuchte jedes portierte Protokoll eigenen Oracle-Code.

## Die Lösung

Oracle Gateway V2 setzt leichte Adapter-Contracts ein, die:

1. Preisdaten direkt aus Pyth- oder Switchboard-Accounts auf Solana lesen (Cross-State-Reads, kein CPI)
2. Die On-Chain-Daten parsen
3. Preise auf 8 Dezimalstellen normalisieren
4. die standardmäßige Chainlink `AggregatorV3Interface`

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

// Gleiche Schnittstelle wie Chainlink auf Ethereum
(, int256 price,,,) = IAggregatorV3Interface(ADAPTER).latestRoundData();
// price = SOL/USD mit 8 Dezimalstellen (z. B. 15000000000 = 150,00 $)
```

## Einen Feed in drei Schritten nutzen

1. **Die Adapter-Adresse aus der Registry auflösen** — niemals hart codieren:

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

Die Registry wird von GitHub installiert (`npm install github:rome-protocol/rome-registry#v0.2.0`). Die Feed-Keys tragen ein Suffix, das angibt, welche Adapterart dahintersteht; siehe [Feed-Keys in der Registry](#feed-keys-in-the-registry) bevor du einen auswählst.

2. **Lies sie** mit der Schnittstelle, die dein Protokoll bereits verwendet — `IAggregatorV3Interface(solUsd).latestRoundData()`. Ein veralteter oder nicht initialisierter Feed **revertiert** statt einen eingefrorenen Preis bereitzustellen.
3. **Mehrere Feeds auf einmal?** `BatchReader.getLatestPrices(adapters[])` (Hadrian, Registry v0.2.0: `0x2869f0a96572e7fb15036656e9a32fd17346499b`) — und `getFeedHealth(adapters[])` bevor du dich auf sie verlässt. Cachet-Adapter lassen jeden Konsumenten einfach ein normales `SLOAD`ausführen, sodass Multi-Feed-Transaktionen (eine Multi-Collateral-Anleihe, eine Portfoli Ansicht) günstig bleiben.

[cardo](https://github.com/rome-protocol/cardo) liest diese Feeds auf Hadrian. Da die Oberfläche genau `AggregatorV3Interface`, können Protokolle der Compound- und Aave-Klasse diese Feeds ohne Änderungen am Oracle-Code übernehmen — richte ihre Preis-Feed-Konfiguration auf die Adapter-Adressen aus.

## Adaptertypen

* **PythPullAdapter** — liest Pyth-Price-Accounts (Preis, Konfidenz, EMA, Veröffentlichungszeit).
* **SwitchboardV3Adapter** — liest Switchboard-Aggregator-Accounts (Preis, Zeitstempel; kein EMA).
* **CachedPyth- / CachedFeed-Adapter** — Cache-Track-Varianten für CU-effiziente Reads.
* **BookFeedAdapter** — eine schreibgeschützte, Chainlink-kompatible Ansicht über einen Eintrag eines `PriceBook` Contracts. Das Book enthält die Preise für alle registrierten Feeds und wird in Batches aktualisiert (die Aktualisierung ist permissionless); der Adapter jedes Feeds hält keinen eigenen Cache. Ein pausierter Eintrag führt sofort zu einem Revert mit `AdapterPaused`, statt darauf zu warten, veraltet zu werden.

Adapter werden als EIP-1167-Minimal-Proxy-Klone bereitgestellt: der `OracleAdapterFactory` klont die Pyth-, Switchboard- und Cache-Adapter, und jeder `PriceBook` klont seine eigene `BookFeedAdapter` wenn ein Feed registriert wird. Sie stellen neben `AggregatorV3Interface` (`latestPriceData`, `maxStaleness`, `oracleType`, und einen `metadata()` eine erweiterte Schnittstelle bereit (Oberfläche für Health Checks).

## Feed-Keys in der Registry

`getOracle(chainId).feeds` hat mehrere Keys pro Asset. Das Suffix im Key benennt die Adapterart:

| Schlüssel            | Adapterart                           | Wie es liest                                                                                              |
| -------------------- | ------------------------------------ | --------------------------------------------------------------------------------------------------------- |
| `SOL/USD`            | Direktes Pyth (`PythPullAdapter`)    | Parst bei jedem Aufruf das Pyth-Account.                                                                  |
| `SOL/USD-BOOK`       | `BookFeedAdapter`                    | Liest einen `PriceBook` Eintrag, den der Keeper aktualisiert.                                             |
| `SOL/USD-CACHED`     | Gecacht (umhüllt einen anderen Feed) | Liest einen gespeicherten Preis, den der Keeper aktualisiert.                                             |
| `SOL/USD-CACHEDPYTH` | Gecachtes Pyth (`CachedPythAdapter`) | Liest einen gespeicherten Preis, den der Keeper aktualisiert.                                             |
| `SOL/USD-SB`         | Switchboard (`SwitchboardV3Adapter`) | Parst bei jedem Aufruf das Switchboard-Account. Die Registry kennzeichnet diese Einträge `außer Betrieb`. |

Welchen du verwenden solltest, hängt von der Chain ab. Prüfe zuerst den nächsten Abschnitt.

### Welche Feeds heute antworten

Dies sind Ergebnisse von schreibgeschützten `latestRoundData()` Aufrufen auf den Feeds, die in Registry v0.2.0 aufgelistet sind, und die ausgeführt wurden, während diese Seite geschrieben wurde. Die Aktualität der Feeds ändert sich auf dem Devnet von Minute zu Minute, also behandle dies als Momentaufnahme und führe denselben Aufruf auf dem Feed aus, den du verwenden willst.

* **Hadrian.** Die direkten Feeds sind oft veraltet: Bei wiederholten Prüfungen sind die meisten von ihnen (BONK, BTC, ETH, JITOSOL, JTO, JUP, MSOL, USDC, USDT) jedes Mal mit `StalePriceFeed` fehlgeschlagen, und `SOL/USD` antworteten bei manchen Aufrufen und bei anderen nicht. Die `-BOOK` Feeds waren am zuverlässigsten und antworteten bei jedem Aufruf für jedes Asset außer JTO, dessen `-BOOK` Feed als veraltet zurückwies. Jeder `-CACHED` und `-CACHEDPYTH` Feed mit `UninitializedPriceFeed` zurückwies (nichts hat sie aktualisiert), und `SOL/USD-SB` mit `StalePriceFeed`zurückwies. Auf Hadrian solltest du den `-BOOK` Feed bevorzugen, und führe `latestRoundData()` auf dem Feed aus, den du auswählst, bevor du dich auf ihn verlässt.
* **Rubicon.** Die Registry listet keine Oracle-Feeds für Rubicon auf, daher behandelt diese Seite sie nicht. Die Factory ist dort bereitgestellt (siehe [Bereitgestellte Adressen](#deployed-addresses)) und ihre ersten Adapter antworten, aber die Feed-Adressen holst du aus der Factory (`adapterCount()` und `allAdapters(i)`) statt aus der Registry.

Ein Revert hier ist das vorgesehene Verhalten: Ein veralteter oder nicht initialisierter Feed schlägt laut fehl, statt einen alten Preis zurückzugeben. Behandle das in deinem Contract.

## Aktualität — der Oracle-Keeper

Adapter erzwingen ein `maxStaleness` Fenster: Wenn `block.timestamp - publishTime > maxStaleness`, führen Reads zu einem Revert. Auf Solana Mainnet betreibt Pyth Produktions-Keeper. Auf Solana Devnet (wo Hadrian läuft) sind Pyths Pushers Best-Effort, daher betreibt Rome seinen eigenen **Oracle-Keeper** Sidecar, um die zugrunde liegenden Pyth-Accounts frisch zu halten und die gecachten sowie Book-Feeds zu aktualisieren. Der Keeper deckt nicht zu jedem Zeitpunkt jeden Feed auf jeder Chain ab (siehe [welche Feeds heute antworten](#which-feeds-answer-today)).

Prüfe den Feed-Zustand mit `BatchReader.getFeedHealth` (das jeweils die `metadata()`jedes Adapters liest), nicht nur `latestRoundData` — ein Feed kann erreichbar, aber veraltet sein.

## Kundenportal

Registriere Feeds und konfiguriere Konsumenten pro Chain über das [Oracle-Gateway-Portal](https://oracle.testnet.romeprotocol.xyz/). Siehe die [Portal-Seite](/de/apps-auf-rome/oracle-gateway.md) für den Umfang.

## Bereitgestellte Adressen

Kanonische Chain-spezifische Adressen (Factories, Adapter-Implementierungen und die Live-Feeds) befinden sich in der [Registry](https://github.com/rome-protocol/rome-registry/tree/main/chains). Die wichtigsten Factories, aus den `live` Einträgen von Registry v0.2.0 (Version 5.0.0 auf Hadrian; die Rubicon-Adressen sind die auf der [Contract Addresses](/de/referenz/contract-addresses.md) Seite); siehe [Die Vertragsliste lesen](/de/referenz/contract-addresses.md#reading-the-contracts-list):

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

## Beschränkungen

* **Keine historischen Rundendaten** — `getRoundData(roundId)` führt zu einem Revert; nur `latestRoundData()` wird unterstützt.
* **Switchboard EMA wird nicht unterstützt** — EMA-Daten gibt es nur bei Pyth.
* **Pro Chain definierte Staleness** — `maxStaleness` wird pro Umgebung beim Start festgelegt: direkte (Pyth-Read-)Adapter haben standardmäßig \~60 Sekunden; gecachte Adapter standardmäßig 3600 Sekunden (wenn der Keeper sie aktualisiert, tut er das deutlich häufiger).
* **Parser-Offsets** werden gegen die aktuellen Pyth-/Switchboard-Layouts validiert; Layoutänderungen erfordern eine erneute Validierung.

## Wie es weitergeht

* [Oracle-Gateway-Portal](/de/apps-auf-rome/oracle-gateway.md) — Feeds registrieren, Konsumenten konfigurieren
* [Contract Addresses](/de/referenz/contract-addresses.md) — Precompiles und ketten-spezifische Adressen


---

# 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/de/produkte/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.