> 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/erste-schritte/ecosystem.md).

# Ökosystem & Repos

Jedes öffentliche Rome-Repo, was es ist und wie sie zusammenspielen — die Karte zur Orientierung an der Oberfläche.

Die öffentliche Oberfläche von Rome ist eine Reihe von Repositories: einige **Grundlage** Pakete, auf denen du aufbaust, ein Scaffolder, Referenz-Apps zum Lernen und zwei Dienste, die deine App aufruft. Diese Seite ist die Karte — was jedes Repo ist und wie sie zusammenpassen.

Zwei Nachbarn beantworten unterschiedliche Fragen, und diese Seite verlinkt auf beide, statt sie zu wiederholen:

* [Architektur](/de/erste-schritte/architecture.md) erklärt das **Protokoll** — wie die EVM in einem Solana-Programm läuft.
* Jedes Repo liefert eine **`AGENTS.md`** (z. B. [rome-sdk-ts/AGENTS.md](https://github.com/rome-protocol/rome-sdk-ts/blob/main/AGENTS.md)) die anhand von **womit du startest** (einem Solidity-Vertrag, einem Solana-Programm, Greenfield, von zu Hause) zum Beispiel führt, das deinem Fall am nächsten kommt.

Diese Seite ist die Ebene dazwischen: die **gesamte Oberfläche** und wie die Teile verbunden sind.

## Die Oberfläche auf einen Blick

### Grundlage — darauf baust du auf

| Repo                                                            | Was es ist                                                                                                                                                                 | Greif darauf zurück, wenn                                   |
| --------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------- |
| [rome-registry](https://github.com/rome-protocol/rome-registry) | `@rome-protocol/registry` — nur lesbare, generierte Projektion von Live-Chain-Fakten (IDs, RPC, Adressen, Token-Mints, Programm-IDs, Oracle-Feeds, ALTs).                  | Du brauchst einen echten Chain-Fakt — niemals hartcodieren. |
| [rome-sdk-ts](https://github.com/rome-protocol/rome-sdk-ts)     | `@rome-protocol/sdk` — der TypeScript-Schreibpfad: `submitRomeTx` + Gebührenbemessung, beide Lanes, PDA/ATA- und CPI-Encoder, Precompile-Bindings, einen `/bridge` Client. | Du schreibst App- oder Frontend-Code.                       |
| [rome-solidity](https://github.com/rome-protocol/rome-solidity) | Solidity-Precompile-Interfaces, SPL/ERC-20-Wrapper und die Oracle-Adapter — das Toolkit auf Vertragsseite.                                                                 | Du schreibst Verträge.                                      |

Die `@rome-protocol/…` Namen oben sind Paketnamen, aber die Pakete werden nicht auf npm veröffentlicht. Installiere sie von GitHub (die Befehle stehen in jedem Abschnitt unter [Die Grundlage im Detail](#the-foundation-layer-up-close)); die Importpfade in deinem Code bleiben gleich.

### Rome ZK EVM Rollups

| Repo                                                            | Was es ist                                                        | Greif darauf zurück, wenn                                               |
| --------------------------------------------------------------- | ----------------------------------------------------------------- | ----------------------------------------------------------------------- |
| [solana-zk-evm](https://github.com/rome-protocol/solana-zk-evm) | Dokumentation zu ZK-Rollup-Programmen, Node, Prover und Operator. | Du betreibst eine EVM-Chain, die auf Solana abgerechnet wird.           |
| [rome-zk-guest](https://github.com/rome-protocol/rome-zk-guest) | Batch-Gast-Quellcode, erstellt für den Genesis jeder Chain.       | Du erstellst einen Guest und forderst seinen Verifikationsschlüssel an. |

### Canton ZK EVM

| Repo                                                                                                                    | Was es ist                                                                                                                 | Greif darauf zurück, wenn                                                                                                                    |
| ----------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| [canton-zk-evm](https://github.com/rome-protocol/canton-zk-evm/blob/a84e84e439a5cc669c0ae61facf7c8c995d9d564/README.md) | Ostia, eine frühe Version einer Canton zkEVM, die bewiesene EVM-Blöcke und Canton-Aktionen in einer Transaktion abrechnet. | Du führst die lokale Demo aus oder studierst ihr Gateway und die Proof-Prüfungen. Siehe [Canton ZK EVM](/de/canton-zk-evm/canton-zk-evm.md). |

### Referenz-Apps — lernen am Beispiel

| Repo                                                                    | Was es ist                                                                                                | Greif darauf zurück, wenn                                 |
| ----------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- | --------------------------------------------------------- |
| [rome-dex](https://github.com/rome-protocol/rome-dex)                   | Dual-Lane-AMM — ein nativer Solana-Pool mit einem dünnen EVM-Router.                                      | Die andere Lane eröffnen; ein **native-core** Beispiel.   |
| [aerarium](https://github.com/rome-protocol/aerarium)                   | Dual-Lane-Lending — ein Solidity-Comet-Kern, den Solana-Nutzer über einen synthetischen Sender erreichen. | Die andere Lane eröffnen; ein **Solidity-Kern** Beispiel. |
| [cardo](https://github.com/rome-protocol/cardo)                         | EVM-Nutzer, die Solana-dApps (Swap/Staking/Lending/Perps) per CPI steuern.                                | Eine ausgearbeitete CPI-zu-Solana-App zum Studieren.      |
| [appia](https://github.com/rome-protocol/appia)                         | Positions-orientiertes Cross-VM-DeFi; Nutzer erreichen es von ihrer Heimat-Chain aus.                     | Eine **von zu Hause** App.                                |
| [rome-aave-v3-demo](https://github.com/rome-protocol/rome-aave-v3-demo) | Aave v3 Supply/Borrow/Repay, unverändert bereitgestellt.                                                  | Eine vollständige EVM-App, die unverändert läuft.         |

### Contract-Forks — bekannte Protokolle, auf Rome deployed

| Repo                                                                              | Was es ist                      | Greif darauf zurück, wenn                  |
| --------------------------------------------------------------------------------- | ------------------------------- | ------------------------------------------ |
| [compound-on-rome-comet](https://github.com/rome-protocol/compound-on-rome-comet) | Compound III (Comet) Geldmarkt. | Das Forken eines bekannten EVM-Protokolls. |
| [rome-aave-v3](https://github.com/rome-protocol/rome-aave-v3)                     | Aave-v3-Contract-Fork.          | Das Forken eines bekannten EVM-Protokolls. |

### Dienste — deine App ruft diese auf

| Repo                                                                        | Was es ist                                                                                        | Greif darauf zurück, wenn                       |
| --------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------- | ----------------------------------------------- |
| [rome-bridge-api](https://github.com/rome-protocol/rome-bridge-api)         | Orchestrator außerhalb der Chain + Gebührensponsor für die On-Chain-Bridge. Hält keine Schlüssel. | Ein Wallet aufladen oder ein von-zu-Hause-Flow. |
| [rome-oracle-gateway](https://github.com/rome-protocol/rome-oracle-gateway) | Solana-Preisfeeds (Pyth, Switchboard), über die Chainlink `AggregatorV3Interface`.                | Du brauchst einen Preisfeed.                    |

### Scaffold — hier anfangen

| Repo                                                                | Was es ist                                                                                                                                                          | Greif darauf zurück, wenn |
| ------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------- |
| [create-rome-app](https://github.com/rome-protocol/create-rome-app) | `npx github:rome-protocol/create-rome-app` — scaffoldet eine Dual-Lane-App, die bereits an Registry + SDK verdrahtet ist, mit einer finanzierten Both-Lane-Prüfung. | Eine neue App starten.    |

## Wie sie zusammenspielen

```mermaid
flowchart TD
    REG["rome-registry — live Chain-Fakten"]
    SDK["rome-sdk-ts — Writes, CPI, Bridge-Client"]
    SOL["rome-solidity — Precompile-Interfaces, SPL-Wrapper, Oracle-Adapter"]
    CRA["create-rome-app — Scaffolder"]
    APP["deine App — Frontend + Verträge"]
    BAPI["rome-bridge-api — Orchestrator außerhalb der Chain, hält keine Schlüssel"]
    OG["rome-oracle-gateway — Solana-Preisfeeds"]

    CRA -->|scaffoldet, vorverdrahtet| APP
    REG -->|Fakten, niemals hartcodiert| APP
    SDK -->|Schreibpfad & CPI| APP
    SOL -->|von deinen Verträgen importiert| APP
    APP -->|SDK /bridge-Client| BAPI
    APP -->|liest über AggregatorV3Interface| OG
    OG -.->|Adapter leben in| SOL
    CRA -.->|verdrahtet| REG
    CRA -.->|verdrahtet| SDK
```

Das Rückgrat besteht aus drei Grundlagen und einem Scaffolder:

* [**rome-registry**](https://github.com/rome-protocol/rome-registry) ist die einzige Quelle für Live-Fakten. [**rome-sdk-ts**](https://github.com/rome-protocol/rome-sdk-ts) ist der Schreibpfad — und sein `/bridge` Unterpfad ist der Client, den deine App verwendet, um mit `rome-bridge-api`. [**rome-solidity**](https://github.com/rome-protocol/rome-solidity) ist das, was deine Verträge (und die Forks) importieren; die Oracle-Adapter, die `rome-oracle-gateway` dort auch bereitgestellt werden. Die drei sind unabhängig voneinander — wähle die, die deine App braucht.
* [**create-rome-app**](https://github.com/rome-protocol/create-rome-app) verknüpft die ersten beiden für eine neue App, sodass ein neues Projekt bereits die Registry liest und über das SDK schreibt.

Die Referenz-Apps sind die Ausnahme, die man kennen sollte: **sie stammen aus der Zeit vor den extrahierten Paketen.** cardo nutzt das Registry-Paket; appia projiziert die Registry zur Build-Zeit in statisches JSON; und beide vendorn ihren Schreibpfad, statt das SDK zu importieren. Lies sie, um die Muster zu lernen — aber eine **neue** App sollte mit `create-rome-app` + den Paketen starten, nicht durch Klonen einer App.

## Navigiere nach dem, was du brauchst

* **Ein Live-Chain-Fakt** (ID, Adresse, Mint, Programm-ID) → [rome-registry](https://github.com/rome-protocol/rome-registry). Niemals hartcodieren.
* **App-Code schreiben** (ein Write, ein CPI-Aufruf, eine Bridge) → [rome-sdk-ts](https://github.com/rome-protocol/rome-sdk-ts); Referenz unter [Rome SDK](/de/produkte/rome-sdk.md).
* **Verträge schreiben** → [rome-solidity](https://github.com/rome-protocol/rome-solidity); siehe [Solidity-Verträge deployen](/de/entwicklerleitfaden/deploy-solidity.md).
* **Einen Solana-Programmaufruf aus einem Solidity-Vertrag heraus** → das CPI-Precompile in [rome-solidity](https://github.com/rome-protocol/rome-solidity) (`interface.sol`); [cardo](https://github.com/rome-protocol/cardo) ist ein ausgearbeitetes Beispiel.
* **Ein funktionierendes Beispiel** einer AMM-, Lending-, CPI- oder von-zu-Hause-App → die Referenz-Apps oben; das `AGENTS.md` jeder Repo routet nach Startpunkt.
* **Eine neue App scaffolden** → [create-rome-app](https://github.com/rome-protocol/create-rome-app).
* **Ein Preisfeed** → [rome-oracle-gateway](https://github.com/rome-protocol/rome-oracle-gateway) (siehe das [Oracle-Gateway-Portal](/de/apps-auf-rome/oracle-gateway.md)).
* **Nutzer auf einer anderen Chain** → [Von zu Hause](/de/entwicklerleitfaden/from-home.md) + [rome-bridge-api](https://github.com/rome-protocol/rome-bridge-api).
* **Entscheiden, welche Seite deine Logik beherbergt** → [Wähle deinen Kern](/de/kernkonzepte/choose-your-core.md).

## Die Grundlage im Detail

### rome-registry — Live-Fakten, konstruktionsbedingt öffentlich

Das Registry ist **generiert** aus Rome's interner Quelle: Eine Allowlist gibt nur das aus, was öffentlich sein soll, **ersetzt** interne Endpunkte durch ihre öffentlichen Entsprechungen und **verweigert standardmäßig** alles andere — also ist es konstruktionsbedingt öffentlich-sicher. Es veröffentlicht pro Chain `chain.json` / `tokens.json` / `contracts.json` / `oracle.json` / `bridge.json` / `alts.json`, plus Solana `Programme` und pro Protokoll-App-Bereitstellungen.

Installiere es von GitHub, an einen Release-Tag gepinnt: `npm install github:rome-protocol/rome-registry#v0.2.0`. Du liest es über Getter — `getChain`, `getTokens`, `getContracts`, `getOracle`, `getBridge`, `getAlts`, und `getPrograms(network)` (Programm-IDs sind nach Netzwerk und nicht nach Chain-ID geordnet). Das Paket ist reines ESM (derzeit keine gebündelten TypeScript-Typen).

Zwei Dinge, die du wissen solltest, bevor du es einbindest:

* **`getTokens()` gibt nicht zurück `assetRef`.** Um den Wrapper eines Tokens zu finden, vergleiche sein **mint** (`mintId`) — z. B. ist der Wrapper des Gas-Tokens der Eintrag, der sein Mint teilt.
* **Es liest JSON von der Festplatte (`node:fs`) — es ist nicht browser-sicher.** In einer Web-App projiziere die Werte, die du brauchst, zur Build-Zeit in eine statische JSON-Datei und importiere diese im Client. (Genau das tun `create-rome-app` und appia.)

Vertragsadressen werden als Liste von Versionen pro Vertrag zurückgegeben; wähle diejenige, deren `Status` ist `live`. [Die Vertragsliste lesen](/de/referenz/contract-addresses.md#reading-the-contracts-list) zeigt, wie das geht. Fakten, die deine App nicht live liest, erscheinen auch in der [Contract Addresses](/de/referenz/contract-addresses.md) Referenz.

### rome-sdk-ts — der Schreibpfad, beide Lanes

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

`@rome-protocol/sdk` (v0.4.0) kapselt alles, was ein Rome-Write braucht, damit du Calldata oder Gebühren nicht selbst zusammenbasteln musst:

* **`submitRomeTx`** — der Schreibpfad der EVM-Lane: berechnet Gas mit `eth_estimateGas` (aufgerundet, mit einer Fallback-Obergrenze, wenn die Schätzung fehlschlägt) und stellt EIP-1559-Gebühren bereit.
* **`submitRomeTxV1`** — dasselbe, für eine **Solana-Wallet** die deine EVM-App antreibt: eine Solana-v1-Transaktion pro Aufruf, zwei Wallet-Prompts. Der synthetische Sender hält nichts im Ruhezustand; `buildFundLeg`/`buildSweepLeg` Wert hinein und hinaus als ERC-20 bewegen (`wUSDC`), **nicht** nativ `msg.value`; die reinen Solana-Instruktionen rund um einen Aufruf (die Fund-Leg, die Erstellung des Wallet-Token-Kontos vor einem Sweep) laufen ebenfalls über `submitSolanaInstructionsV1` als v1-Transaktionen. `submitRomeTxSolanaLane` ist der frühere Pfad, der im Client eine legacy-Solana-Transaktion erstellt und beim ersten Gebrauch automatisch einen frischen synthetischen (`create_pda`) bereitstellt.
* **PDA/ATA-Ableitung, CPI `invoke`/`invoke_signed` Encoder, Precompile-Bindings**, und einen **`/bridge`** Unterpfad (`@rome-protocol/sdk/bridge`) — ein Bridge-Client mit Angebots-vor-Ausführung.

Vollständige API + Beispiele: [Rome SDK](/de/produkte/rome-sdk.md), und die Anleitungen [Solana aus EVM aufrufen](/de/entwicklerleitfaden/call-solana-from-evm.md), [EVM aus Solana aufrufen](/de/entwicklerleitfaden/call-evm-from-solana.md), und [Eine Dual-Lane-App bauen](/de/entwicklerleitfaden/dual-lane-app.md).

### rome-solidity — das Toolkit auf Vertragsseite

Installiere es von GitHub, nicht von npm. Mit npm oder Hardhat: `npm install github:rome-protocol/rome-solidity`. Mit Foundry: `forge install rome-protocol/rome-solidity`, dann füge das Remapping hinzu `@rome-protocol/rome-solidity/=lib/rome-solidity/` zu `foundry.toml` (unter `[profile.default]`, als `remappings = [...]`) damit `@rome-protocol/rome-solidity/contracts/interface.sol` aufgelöst wird. Der Paketname in `package.json` ist `@rome-protocol/rome-solidity`, sodass derselbe Importpfad für beide funktioniert.

Was deine Verträge importieren:

* **`contracts/interface.sol`** — die Precompile-Interfaces, an ihre Adressen gebunden: **CPI** `ICrossProgramInvocation` (`0xFF…08`), **Helper** `IHelperProgram` (`0xFF…09`, ATA/PDA-Erstellung, SPL-Übertragungen, Gas↔Lamports), **Abheben** `IWithdraw` (`0x42…16`), und **System** (`0xFF…07`). Eine gasoptimierte **gecachte** Familie lebt ebenfalls hier; ein Vertrag verwendet konsequent einen Track. Vollständige Adresstabelle: [Contract Addresses](/de/referenz/contract-addresses.md).
* **SPL/ERC-20-Wrapper** — `SPL_ERC20` (CPI-basiert) und `SPL_ERC20_cached` (der gecachte Track, verwendet auf devnet); jedes SPL-Mint ist über diese bereits ein ERC-20.
* **Oracle-Adapter** (`contracts/oracle/`) — die Pyth/Switchboard-Adapter `rome-oracle-gateway` deploys, gelesen über `IAggregatorV3Interface`.
* Ausgearbeitete Beispiele in `contracts/examples/`.

Der Solidity-SDK-Abschnitt von [Rome SDK](/de/produkte/rome-sdk.md) zeigt die Importmuster und die Precompile-Bindings im Code.

## Was als Nächstes kommt

* [Wähle deinen Kern](/de/kernkonzepte/choose-your-core.md) — welche Seite deine Logik beherbergt.
* [Schnellstart](/de/erste-schritte/quickstart.md) — deploye deinen ersten Vertrag.
* [create-rome-app](https://github.com/rome-protocol/create-rome-app) — scaffoldet eine Dual-Lane-App.
* Jedes Repo `AGENTS.md` — der nach Startpunkt sortierte Weg zum nächsten Beispiel.


---

# 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/erste-schritte/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.