> 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/entwicklerleitfaden/from-home.md).

# Von zu Hause aus: Rome von einer anderen Chain aus erreichen

Lass Nutzer auf einer anderen Chain deine Rome-App erreichen, ohne ihr Zuhause zu verlassen — Vermögenswerte hineinbringen, handeln und wieder herausnehmen.

Ihre Nutzer müssen nicht nach Rome wechseln. Von ihrer Heimat-Chain — einer L2 wie Arbitrum oder Monad oder Solana — bringen sie Vermögenswerte hinein, nutzen Ihre Rome-App und nehmen Vermögenswerte wieder heraus. Die Bridge ist On-Chain und durch die eigene Signatur des Nutzers autorisiert; Sie binden Ihre App über eine einzige API daran an.

## So funktioniert es

* **Eingehend (Home → Rome):** auf der USDC-Route des Gas-Tokens über CCTP, `settle_inbound_bridge_v2` Anweisung des Rome-Programms schreibt dem Nutzer gut, unter einer signierten **EIP-712** `SettleAuthorization`, sodass es keinen privilegierten Settler gibt. Die anderen eingehenden Routen verwenden diese Anweisung oder Signatur nicht. Wrapper-USDC, ETH über Wormhole und SOL landen direkt als Wrapper-Token im Konto des Nutzers. Solana-USDC auf einer Chain, deren Gas-Token USDC ist, benötigt noch eine weitere, vom Nutzer signierte Transaktion, um den Wrapper in Gas umzuwandeln. Das Angebot sagt Ihnen, welche Signaturen eine Route benötigt.
* **Ausgehend (Rome → Home):** `RomeBridgeWithdraw` (in [`rome-solidity`](https://github.com/rome-protocol/rome-solidity)) vernichtet den Vermögenswert auf Rome. Der Nutzer fordert ihn dann auf der Heimat-Chain mit seiner eigenen Transaktion ein.
* **Transport:** Circle **CCTP** für USDC und die **Wormhole** Token-Bridge für ETH. Solana-Home-Chains verwenden einfache SPL-Überweisungen hinein und eine Rome-Abhebung hinaus. Wormhole ist nur die eingehende Strecke für ETH. Eine generische Wormhole-Route existiert nur für ausgehend, und jeder darauf genutzte Vermögenswert muss zuerst von den Rome-Operatoren aktiviert werden.
* **Orchestrierung:** der Off-Chain- [`rome-bridge-api`](https://github.com/rome-protocol/rome-bridge-api) gibt ein Routing-Angebot aus, verifiziert die Transaktion auf der Quell-Chain und übernimmt die Settle-Gebühr. Es hält weder Guthaben noch Schlüssel. Es kann nur auslösen, was der Nutzer bereits signiert hat.

## Bauen Sie es

Die API ist auf dem Devnet öffentlich unter `https://bridge-api.devnet.romeprotocol.xyz`. `GET /v1/routes` listet jede aktive Route auf (Asset, Strecke, Richtung, Quell-Chain, Rome-Chain, Geschwindigkeiten). Die folgenden Aufrufe sind dieselben vier, die das SDK in `@rome-protocol/sdk/bridge` (`requestQuote`, `registerTransfer`, `getTransfer`, `reportStep`). Die CLI führt den gesamten Ablauf für Sie aus: `rome fund` und `rome bridge` für die Transfers und `rome verify --path from-home` für einen Rundlauf, wie auf der [Rome CLI](https://docs.rome.builders/de/produkte/rome-cli.md) Seite beschrieben.

### Vermögenswerte hineinbringen

1. **Lassen Sie sich die Route anbieten.** Senden Sie die Quell-Chain, den Vermögenswert, den Betrag und die Adressen des Nutzers. Chains werden als CAIP-2-IDs angegeben, etwa `eip155:84532`; `romeChainId` ist Ihre Rome-Chain. Die älteren Bezeichnungen `ethereum` und `solana` werden noch akzeptiert, sind aber veraltet, und die API kennzeichnet diese Antworten mit einem `Sunset` Header. Die vollständigen Anfrage- und Antwortformen stehen in der [API-Referenz](https://github.com/rome-protocol/rome-bridge-api/blob/main/docs/API.md).

   ```bash
   curl -X POST https://bridge-api.devnet.romeprotocol.xyz/v1/quote \

     -H 'Content-Type: application/json' \

     -d '{
       "asset": "USDC",
       "direction": "to-rome",
       "sourceChain": "eip155:84532",
       "romeChainId": "200010",
       "amount": "1000000",
       "sender": { "ethereum": "0xUSER" },
       "recipient": "0xUSER"
     }'
   ```

   Beträge sind als Ganzzahlen in Basiseinheiten in Strings angegeben (`"1000000"` ist 1 USDC). ETH-Beträge sind in wei und müssen ausgehend ein Vielfaches von 10.000.000.000 wei sein (der Wrapper hat 8 Dezimalstellen); die API lehnt feinere Beträge ab. Die Antwort listet die `Schritte`. `userSigns: true`, in Schrittreihenfolge: EVM-Transaktionen stehen in `unsignedTxs`, Solana-Anweisungen in `unsignedTx`. Signieren Sie sie genau so, wie sie zurückgegeben werden. Schritte ohne zu signierendes Material werden vom Sponsor ausgeführt, sobald Circle oder Wormhole die Übertragung bestätigt hat. Die ausgehende Einforderung ist die Ausnahme, unten beschrieben: Der Nutzer erstellt sie.
2. **Lassen Sie den Nutzer signieren.** Bei einem CCTP-Angebot sind das die USDC-Freigabe und das Burnen auf der Quell-Chain. Wenn das Angebot einen Eintrag in `signatureRequests`hat, signiert der Nutzer auch dieses EIP-712 `SettleAuthorization` sobald der Burn-Hash bekannt ist; tragen Sie den Burn-Hash ein und übergeben Sie das Ergebnis als `userSettleSig` im nächsten Aufruf. Nur die CCTP-Route des Gas-Tokens hat eine. Wormhole-ETH-, Wrapper-Intent-USDC- und Solana-Routen haben keine.
3. **Registrieren Sie die Übertragung.** `POST /v1/transfers` mit der `quoteId` und `step1TxHash`dem Hash der letzten Transaktion im ersten Schritt (dem Burn), innerhalb von 15 Minuten nach dem Angebot. Auf der Gas-Route fügen Sie die Settle-Signatur als `userSettleSig`. Die API lehnt ein vollständiges Quote-Objekt ab. Sie prüft, ob die Transaktion auf der Quell-Chain mit dem gespeicherten Angebot übereinstimmt, und gibt eine Transfer- `ID`.
4. **Abfragen** `GET /v1/transfers/{id}` alle paar Sekunden, bis `Ergebnis` ist `abgeschlossen`, und behandeln Sie `fehlgeschlagen` und `abgelaufen`. Der Nutzer ist dann auf Rome mit Guthaben ausgestattet und kann Ihre App verwenden. Eine vollständige Übertragung kann eine `Verschlechterung` Notiz mit einer `degradationReason`, enthalten. Prüfen Sie sie also, bevor Sie dem Nutzer mitteilen, dass das Gas- oder Wrapper-Guthaben angekommen ist.

Solana-Home-Chains folgen derselben Struktur mit anderen Schritten. Der Nutzer sendet eine SPL-Übertragung an das Token-Konto seines Rome-Kontos. SOL kommt nach genau dieser einen Übertragung als Wrapped SOL an. Auf einer Chain, deren Gas-Token USDC ist, wie Hadrian, benötigt USDC einen zweiten Schritt: eine Rome-Transaktion, die der Nutzer signiert und die den angekommenen Wrapper in natives Gas umwandelt. Jedes andere SPL-Token läuft über die `spl-solana-to-rome` Route, die das Mint in `splAsset`.

### Vermögenswerte wieder herausnehmen

Das Herausbridgen ist nicht der eingehende Ablauf in umgekehrter Reihenfolge. Es hat mehr als eine Signatur, und der Nutzer schließt es auf der Heimat-Chain ab. Lassen Sie sich dafür ein Angebot erstellen mit `direction` gesetzt auf `from-rome`. `sourceChain` benennt die Nicht-Rome-Seite als CAIP-2-ID, und der Burn geht an diese Chain. `destinationChainId` ist optional und muss damit übereinstimmen, wenn Sie ihn senden. Der ältere Name `ethereum` bedeutet weiterhin Ethereum Sepolia:

```bash
curl -X POST https://bridge-api.devnet.romeprotocol.xyz/v1/quote \

  -H 'Content-Type: application/json' \

  -d '{
    "asset": "USDC",
    "direction": "from-rome",
    "sourceChain": "eip155:84532",
    "destinationChainId": 84532,
    "romeChainId": "200010",
    "amount": "1000000",
    "sender": { "rome": "0xUSER" },
    "recipient": "0xUSER"
  }'
```

Für USDC über CCTP gibt das Angebot zwei Schritte zurück, und der Nutzer signiert beide:

1. **Auf Rome, zwei Transaktionen der Reihe nach.** Die erste gewährt `RomeBridgeWithdraw` Delegationsrechte über das wUSDC des Nutzers auf Solana (`approve_spl`). Die Gewährung deckt genau die Höhe dieses Burns ab, daher enthält das Angebot sie jedes Mal, und der Nutzer signiert sie vor jedem Burn. Die zweite verbrennt das wUSDC über `RomeBridgeWithdraw`, womit die CCTP-Übertragung gestartet wird. Registrieren Sie die Übertragung mit dem Hash des Burns. Der Burn verwendet wUSDC, den Token, den das Angebot bezeichnet als `burnToken`, nicht das native Gas-USDC. Guthaben, das als Gas angekommen ist, wird nicht verbrannt; bringen Sie USDC für einen Rundlauf daher mit `intent: "wrapper"`.
2. **Auf der Ziel-Chain die Einforderung.** Abfragen `GET /v1/transfers/{id}` bis Schritt 2 `bereit`. Danach trägt es die `Nachricht` und `Attestation`. Der Nutzer ruft `receiveMessage(message, attestation)` auf Circles Message-Transmitter auf der Ziel-Chain auf (das Angebot nennt den Transmitter und die CCTP-Domain). Hier wird nichts bezuschusst, daher benötigt der Nutzer Gas auf dieser Chain. Melden Sie den Claim-Hash mit `POST /v1/transfers/{id}/steps/2`.

ETH aus Rome über Wormhole wird heute weder auf Hadrian noch auf Rubicon angeboten. Hadrian führt ETH über Wormhole nur in Richtung Rome auf. Rubicon führt keine ETH-Route auf.

Die Abhebung an eine Solana-Adresse hat keinen Claim-Schritt. USDC ist eine einzelne Rome-Transaktion, die auf das Solana-Konto des Nutzers abhebt. SOL ist ein Rome-Schritt mit drei Transaktionen: dieselbe Delegationsgewährung über wSOL, optional die Erstellung des wSOL-Token-Kontos des Empfängers auf Solana (übersprungen, wenn es bereits existiert) und die Abhebung über `RomeBridgeWithdraw`.

**Ausgehende Übertragungen benötigen keinen Aktivierungsschritt.** Ein CCTP-Burn erstellt ein Message-Konto auf Solana, und dieses Konto benötigt Miete. Das eigene Solana-Konto des Bridge-Vertrags bezahlt diese Miete. Kurz vor seinem CPI-Aufruf ruft der Vertrag `swap_gas_to_lamports`: Der Solana-Fee-Payer der Transaktion legt die Lamports vor, und der Nutzer wird dafür im gleichen Burn-Transaktions-Gas belastet. Eine neue Wallet kann ihre erste ausgehende Übertragung ohne vorherige Einrichtung durchführen. `RomeBridgeWithdraw` liegt heute auf Hadrian und Rubicon bei Version 13.0.0. Ausgehende Angebote enthalten keinen Aktivierungs- oder Aufstockungsschritt, daher muss Ihre App das Konto des Nutzers vor dem ersten Angebot nicht prüfen. Eingehende Übertragungen benötigen ebenfalls keine Aktivierung. Der `rome` CLI (0.11.0) hat weiterhin eine eigene Prüfung. `rome bridge --to` (ohne `--dry-run`) liest die Lamports des External-Authority-Kontos des Nutzers auf Solana. Wenn es weniger als 15.000.000 enthält, bricht der Befehl ab und fordert Sie auf, `rome activate <chain>`, wodurch 2 USDC auf Hadrian über den `SimpleActivator` Vertrag bezahlt werden. `rome verify --path from-home` führt dieselbe Prüfung durch, bevor er beginnt. Der Vertrag benötigt diese Aktivierung nicht.

## Lesen Sie den Code

* [appia](https://github.com/rome-protocol/appia) — eine From-Home-App: Nutzer bringen USDC von ihrer Heimat-Chain mit und nutzen Rome-seitiges DeFi, ohne sie zu verlassen.
* [rome-bridge-api](https://github.com/rome-protocol/rome-bridge-api) — der Orchestrator (Angebot → Verifizieren → Bezuschussen).

## Was als Nächstes kommt

* [Finanzierung erhalten](https://docs.rome.builders/de/ressourcen/faucets.md) — derselbe Bridge-Pfad finanziert eine frische Dev-Wallet.
* [Solidity bereitstellen](https://docs.rome.builders/de/entwicklerleitfaden/deploy-solidity.md) — bringen Sie Ihre App auf Rome.


---

# 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/entwicklerleitfaden/from-home.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.
