> 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-1/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 ein Satz von Repositories: einige **Grundlage** Pakete, auf denen du aufbaust, ein Scaffolder, Referenz-Apps zum Lernen und zwei Services, 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](https://docs.rome.builders/de/erste-schritte-1/architecture.md) erklärt das **Protokoll** — wie die EVM innerhalb eines Solana-Programms 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)) mit, das nach **dem, womit du startest** (einem Solidity-Vertrag, einem Solana-Programm, Greenfield, von zu Hause) zur einen Beispielreferenz leitet, die deinem Fall am nächsten kommt.

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

## Die Oberfläche auf einen Blick

### Grundlage — darauf aufbauen

| Repo                                                            | Was es ist                                                                                                                                                                     | Greif danach, wenn                                           |
| --------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------ |
| [rome-registry](https://github.com/rome-protocol/rome-registry) | `@rome-protocol/registry` — schreibgeschützte, generierte Projektion von Live-Chain-Fakten (IDs, RPC, Adressen, Token-Mints, Programm-IDs, Oracle-Feeds, ALTs).                | Du brauchst einen echten Chain-Fakt — niemals hart codieren. |
| [rome-sdk-ts](https://github.com/rome-protocol/rome-sdk-ts)     | `@rome-protocol/sdk` — der TypeScript-Schreibpfad: `submitRomeTx` + Fee-Größenbestimmung, 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-Wrappers 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 Grundlagenebene, im Detail](#the-foundation-layer-up-close)); die Importpfade in deinem Code bleiben gleich.

### Rome ZK-EVM-Rollups

| Repo                                                            | Was es ist                                                        | Greif danach, 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-Guest-Source, gebaut für den Genesis jeder Chain.           | Du baust einen Guest und fragst seinen Verifikationsschlüssel an. |

### Ostia (ZK EVM auf Canton)

| Repo                                                                                  | Was es ist                                                                                                                        | Greif danach, wenn                                                                                                                                                                                     |
| ------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| [canton-zk-evm](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/README.md) | Ostia, eine ZK EVM auf Canton: Jeder bewiesene EVM-Block wird zusammen mit seinen Canton-Aktionen in einer Transaktion verankert. | Du baust auf Ostia DevNet ([Explorer](https://ostia.devnet.romeprotocol.xyz/)) oder betreibst dein eigenes Ostia. Siehe [Canton ZK EVM](https://docs.rome.builders/de/canton-zk-evm/canton-zk-evm.md). |

### Referenz-Apps — anhand von Beispielen lernen

| Repo                                                                    | Was es ist                                                                                                | Greif danach, 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 ö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 öffnen; ein **Solidity-Core** -Beispiel. |
| [cardo](https://github.com/rome-protocol/cardo)                         | EVM-Nutzer, die Solana-dApps (Swap/Staking/Lending/Perps) per CPI ansteuern.                              | Eine ausgearbeitete CPI-zu-Solana-App zum Studieren.     |
| [appia](https://github.com/rome-protocol/appia)                         | Positions-first Cross-VM-DeFi; Nutzer greifen von ihrer Heimat-Chain darauf zu.                           | 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 bereitgestellt

| Repo                                                                              | Was es ist                      | Greif danach, wenn                            |
| --------------------------------------------------------------------------------- | ------------------------------- | --------------------------------------------- |
| [compound-on-rome-comet](https://github.com/rome-protocol/compound-on-rome-comet) | Compound III (Comet) Geldmarkt. | Einen bekannten EVM-Protokoll-Fork erstellen. |
| [rome-aave-v3](https://github.com/rome-protocol/rome-aave-v3)                     | Aave-v3-Contract-Fork.          | Einen bekannten EVM-Protokoll-Fork erstellen. |

### Services — deine App ruft diese auf

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

### Scaffold — hier anfangen

| Repo                                                                | Was es ist                                                                                                                                                                | Greif danach, 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 angeschlossen ist, mit einer geladenen Prüfung für beide Lanes. | Eine neue App starten. |

## Wie sie sich zusammensetzen

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

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

Das Rückgrat sind drei Grundlagen und ein 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) zu sprechen, ist das, was deine Verträge (und die Forks) importieren; die Oracle-Adapter, die `rome-oracle-gateway` dort ebenfalls 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) verbindet die ersten beiden für eine neue App, sodass ein frisches Projekt bereits die Registry liest und über das SDK schreibt.

Die Referenz-Apps sind die erwähnenswerte Ausnahme: **sie stammen aus der Zeit vor den extrahierten Paketen.** cardo verwendet das Registry-Paket; appia projiziert die Registry zur Build-Zeit in statisches JSON; und beide vendoren 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 das 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 hart codieren.
* **App-Code schreiben** (ein Write, ein CPI-Call, eine Bridge) → [rome-sdk-ts](https://github.com/rome-protocol/rome-sdk-ts); Referenz unter [Rome SDK](https://docs.rome.builders/de/produkte/rome-sdk.md).
* **Verträge schreiben** → [rome-solidity](https://github.com/rome-protocol/rome-solidity); siehe [Solidity-Verträge bereitstellen](https://docs.rome.builders/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; jedes Repo `AGENTS.md` leitet nach Startpunkt weiter.
* **Eine neue App scaffen** → [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](https://docs.rome.builders/de/apps-auf-rome/oracle-gateway.md)).
* **Nutzer auf einer anderen Chain** → [Von zu Hause](https://docs.rome.builders/de/entwicklerleitfaden/from-home.md) + [rome-bridge-api](https://github.com/rome-protocol/rome-bridge-api).
* **Entscheiden, welche Seite deine Logik hält** → [Wähle deinen Kern](https://docs.rome.builders/de/kernkonzepte/choose-your-core.md).

## Die Grundlagenebene, im Detail

### rome-registry — Live-Fakten, von Haus aus öffentlich

Die Registry wird **generiert** aus Romans 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 sie von Haus aus öffentlich sicher. Sie veröffentlicht pro Chain `chain.json` / `tokens.json` / `contracts.json` / `oracle.json` / `bridge.json` / `alts.json`, plus Solana `Programme` und pro Protokoll App-Deployments.

Installiere es von GitHub, auf einen Release-Tag festgenagelt: `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, nicht nach Chain-ID, sortiert). Das Paket ist schlicht ESM (derzeit keine gebündelten TypeScript-Typen).

Zwei Dinge solltest du wissen, bevor du es einbindest:

* **`getTokens()` gibt nicht `assetRef`.** Um den Wrapper eines Tokens zu finden, gleiche auf seinen **mint** (`mintId`) ab — z. B. ist der Wrapper des Gas-Tokens der Eintrag, der dessen 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.)

Contract-Adressen kommen als Liste von Versionen pro Vertrag zurück; wähle diejenige, deren `Status` ist `live`. [Das Lesen der Contract-Liste](https://docs.rome.builders/de/referenz/contract-addresses.md#reading-the-contracts-list) zeigt, wie es geht. Fakten, die deine App nicht live liest, erscheinen auch in der [Contract Addresses](https://docs.rome.builders/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 Fees nicht selbst zusammenbasteln musst:

* **`submitRomeTx`** — der EVM-Lane-Schreibpfad: berechnet Gas über `eth_estimateGas` (mit Auffüllung, plus einer Fallback-Obergrenze, wenn die Schätzung fehlschlägt) und liefert EIP-1559-Gebühren.
* **`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 im Ruhezustand nichts; `buildFundLeg`/`buildSweepLeg` Werte als ERC-20 hinein- und herausbewegen (`wUSDC`), **nicht** nativ `msg.value`; die einfachen Solana-Instruktionen rund um einen Aufruf (die Fund-Leg, die Erstellung des Wallet-Token-Accounts vor einem Sweep) laufen über `submitSolanaInstructionsV1` ebenfalls als v1-Transaktionen. `submitRomeTxSolanaLane` ist der frühere Pfad, der im Client eine Legacy-Solana-Transaktion baut und bei der ersten Nutzung 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 Angebotsanfrage zuerst.

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

### rome-solidity — das Toolkit auf Vertragsseite

Von GitHub installieren, nicht von npm. Mit npm oder Hardhat: `npm install github:rome-protocol/rome-solidity`. Mit Foundry: `forge install rome-protocol/rome-solidity`, dann das Remapping hinzufügen `@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`, also funktioniert derselbe Importpfad mit beiden.

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-Transfers, Gas↔Lamports), **Withdraw** `IWithdraw` (`0x42…16`), und **System** (`0xFF…07`). Eine gasoptimierte **zwischengespeicherte** Familie lebt ebenfalls hier; ein Vertrag verwendet konsequent einen Track. Vollständige Adresstabelle: [Contract Addresses](https://docs.rome.builders/de/referenz/contract-addresses.md).
* **SPL/ERC-20-Wrappers** — `SPL_ERC20` (CPI-basiert) und `SPL_ERC20_cached` (der zwischengespeicherte Track, auf Devnet verwendet); jeder SPL-Mint ist über diese bereits ein ERC-20.
* **Oracle-Adapter** (`contracts/oracle/`) — die Pyth/Switchboard-Adapter `rome-oracle-gateway` bereitgestellt, lesbar über `IAggregatorV3Interface`.
* Ausgearbeitete Beispiele in `contracts/examples/`.

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

## Was als Nächstes kommt

* [Wähle deinen Kern](https://docs.rome.builders/de/kernkonzepte/choose-your-core.md) — welche Seite deine Logik hält.
* [Schnellstart](https://docs.rome.builders/de/erste-schritte-1/quickstart.md) — dein erstes Contract deployen.
* [create-rome-app](https://github.com/rome-protocol/create-rome-app) — eine Dual-Lane-App scaffolden.
* Jedes Repo `AGENTS.md` — die Route vom Startpunkt zum nächstgelegenen 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-1/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.
