> 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/rome-academy/13-build-on-solgate.md).

# 13. Auf Solgate entwickeln

Entwickle auf Solgate, der Bridge und Nachrichtenroute zwischen Solana, Ethereum und AggLayer-Chains: Erfahre, was übertragen wird, wie Nachrichten fließen, was sie kosten und wie du von Hadrian zu Rubicon wechselst.

Rome vereint EVM und Solana zu einem Markt. Solgate ist die Brücke und Nachrichtenroute zwischen ihnen. Darüber gelangen Solana-Token zu Ethereum und AggLayer-Chains sowie EVM-Token zu Solana. Außerdem werden Nachrichten zwischen Contracts übertragen, und der Rome-Contract, der eine Nachricht empfängt, kann im selben Transaktionsaufruf ein Solana-Programm aufrufen. In dieser Lektion erfahren Sie, was übertragen wird, wie eine Nachricht fließt, worauf Sie bei einem Empfänger achten müssen und wie Sie jetzt auf Hadrian entwickeln und später auf Rubicon bereitstellen. [Lektion 10](https://docs.rome.builders/de/rome-academy/10-from-other-chains.md) behandelt die Rome Bridge, über die USDC eingebracht wird. Solgate ist die Route für andere Token und Nachrichten.

## Das lernen Sie

* Welche Token in welche Richtung übertragen werden und wie ein Token ohne vorhandenes Solana-Mint bridgefähig wird.
* Was „Verified“ und „Unverified“ bedeuten und wie Nutzer einen Token zu ihrer Wallet hinzufügen.
* Wie eine Nachricht von Ethereum zu Rome und weiter an ein Solana-Programm und zurück fließt.
* Die auf Hadrian und Sepolia gemessenen Zeiten und Kosten.
* Welche Regeln ein Empfänger-Contract einhalten muss und wofür Nachrichten nicht geeignet sind.
* Warum Solgate und worauf Sie sich in jeder Richtung verlassen.
* Wie Sie auf Hadrian starten und was sich auf Rubicon ändert.

## Bevor Sie beginnen

* Schließen Sie [10. Nutzer und Guthaben von anderen Chains herüberbringen](https://docs.rome.builders/de/rome-academy/10-from-other-chains.md)ab. Sie benötigen die Grundidee eines Bridge-Claims.
* Lesen Sie [5. Solana aus Solidity aufrufen](https://docs.rome.builders/de/rome-academy/05-call-solana-from-solidity.md) und [6. Token auf beiden Seiten](https://docs.rome.builders/de/rome-academy/06-tokens-on-both-sides.md)ab. Ein Empfänger, der Solana aufruft, verwendet das CPI-Precompile; ein Solana-Token auf Rome ist das Mint selbst.
* Halten Sie eine mit Guthaben versehene Hadrian-Wallet, eine EVM-Wallet mit Sepolia-ETH und eine Solana-Wallet mit Devnet-SOL bereit. Die Faucets sind in Schritt 7 aufgeführt.

## Die Lektion

### Schritt 1. Wissen, was übertragen wird

Solgate überträgt pro Chain die jeweils onchain erfasste Form eines Tokens. Wählen Sie zuerst die Richtung.

**Von Solana zu Ethereum und AggLayer-Chains**

| Token                                                                                                                                            | Wird übertragen?                                                                                               |
| ------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------- |
| SOL                                                                                                                                              | Ja, als „Wrapped SOL (Rome)“                                                                                   |
| Klassische SPL-Token, einschließlich Meme-Coins                                                                                                  | Ja. Wählen Sie im Testnetz das Mint aus oder fügen Sie es ein; bei der ersten Übertragung wird es aufgelistet. |
| Token-2022, dessen einzige zusätzliche Funktion das Einfrieren ist                                                                               | Im Testnetz. Im Mainnet noch nicht                                                                             |
| Token-2022 mit Transfergebühr                                                                                                                    | Wird nicht übertragen                                                                                          |
| Andere Token-2022 (Transfer-Hooks, permanenter Delegate)                                                                                         | Bleibt auf Solana und Rome, wo es weiterhin von Romes EVM verwendet wird                                       |
| Nicht übertragbare Mints, NFTs                                                                                                                   | Nein                                                                                                           |
| Token, die eine andere Bridge zu Solana gebracht hat, sofern der AggLayer ihre Ursprungs-Chain erreicht (z. B. ein über Wormhole gebridgtes ETH) | Wird nicht ein zweites Mal gebridgt. Bridgen Sie das Original von seiner Ursprungs-Chain.                      |
| USDC                                                                                                                                             | Wird über Circles CCTP übertragen, nicht über Solgate                                                          |

**Von Ethereum und AggLayer-Chains zu Solana**

| Token                                                                                          | Wird übertragen?                                                                                      |
| ---------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------- |
| ETH                                                                                            | Ja, als „Ether (Rome)“, mit 9 Dezimalstellen auf Solana                                               |
| Standard-ERC-20                                                                                | Ja, als „\<name> (Rome)“, ein klassisches SPL-Mint. Im Testnetz ist die Einrichtung genehmigungsfrei. |
| ERC-20 mit Transfergebühr                                                                      | Ja. Die Bridge verbucht den tatsächlich erhaltenen Betrag.                                            |
| Token, deren Herausgeber eine eigene Route zu Solana betreibt (CCTP von Circle und Ähnliches)  | Die Route des Herausgebers verwenden                                                                  |
| Berechtigungspflichtige Token (ERC-3643 und Ähnliches)                                         | Nur die eigene Route des Herausgebers                                                                 |
| Rebasing-Token                                                                                 | Nein. Die nicht rebasing-fähige Wrapper-Version bridgen                                               |
| Kopien, die eine andere Bridge erstellt hat, sobald der AggLayer ihre Ursprungs-Chain erreicht | Nicht ein zweites Mal bridgen                                                                         |

Regeln, die für alle Token gelten:

* Solgate führt pro Chain eine Form jedes Tokens. Formen, die andere Bridges erstellt haben, bleiben getrennt und werden nie zusammengeführt.
* Jeder Token, den Rome erstellt, heißt „\<origin name> (Rome)“ und behält das Symbol des Originals.
* Solana speichert die Token-Menge in 64 Bit. Daher hat ein Token mit mehr als 9 Dezimalstellen auf Solana 9. Beträge werden in ganzen Solana-Einheiten übertragen. Bruchbeträge unterhalb einer Einheit verbleiben als Deckung bei der Bridge.
* Der Solana-Mint, den Rome erstellt, hat keine Freeze Authority. Seine einzige Mint Authority ist der Token-Contract auf Rome.
* Auf Rome ist ein Solana-Token der Mint. Der Rome-Kontostand eines Wallets ist sein eigenes Solana-Tokenkonto, ohne eine zweite Wrapped-Kopie.
* Token, die auf einer Rome-Chain entstehen, werden derzeit nicht von Solgate übertragen.

Ein Token, der noch keinen Solana-Mint hat, lässt sich mit wenigen signierten Schritten bridgen. Im Testnet kann das jeder tun – mit einem EVM-Wallet oder einem Solana-Wallet. Im Mainnet listet Rome die Token.

1. **Auf einer EVM-Chain entstandener Token.** Sende ihn zuerst an Hadrian. Durch den ersten Claim dort wird die Rome-Kopie erstellt. Öffne dann **Token hinzufügen** und füge eine beliebige Form ein: ein Wort, die Adresse auf der Ursprungs-Chain, die Rome-Adresse oder einen Solana-Mint.
2. **Signiere die nummerierten Schritte.** Sie umfassen die Einrichtung, ein optionales Logo und den Abschluss. Mit einem Solana-Wallet zahlst du ausschließlich in SOL und benötigst nie Rome-Gas, da Rome's Relay den Abschluss für dich sendet. Die Karte zeigt die Gesamtkosten an, bevor du signierst. Hadrians Einrichtungsgebühr beträgt 1 USDC oder 0.06 SOL zuzüglich Netzwerkgebühren.
3. **Auf Solana entstandener Token.** Wähle den Mint auf der Bridge aus oder füge ihn ein. Beim ersten Senden wird er der Bridge hinzugefügt und gelistet – als einmalige Schritte.

Das Logo ist optional, kostenlos und erfordert eine zusätzliche Signatur. Die Datei muss kleiner als 256 KB sein und das PNG-Format verwenden, da Solana-Wallets SVG möglicherweise nicht anzeigen. Du kannst es später unter „Meine Token“ hinzufügen.

### Schritt 2: Informiere Nutzer darüber, was verifiziert ist, und ermögliche ihnen, den Token hinzuzufügen

Verifizierte Token stehen auf der verifizierten Liste von Rome. Bei allen anderen, die über den offenen Weg eingerichtet wurden, wird **Nicht verifiziert**angezeigt. Der **Token** Tab listet alle Token auf. Nutzer können nach Name, Symbol oder einer beliebigen Adresse suchen. Jede Zeile zeigt Logo, Kennzeichnung und Route und lässt sich aufklappen, um Adressen pro Chain mit Kopier- und Explorer-Links anzuzeigen, **Zum Wallet hinzufügen** und **Bridgen**. „Nur verifizierte“ ist standardmäßig aktiviert.

Kriterien für „Verifiziert“: ein echter Contract auf der Ursprungs-Chain, nachgewiesen durch einen Eintrag bei CoinGecko oder CoinMarketCap oder durch die Website des Herausgebers; ein Logo; und keine Nachahmung eines verifizierten Tokens.

Wallets und Explorer führen eigene Prüfungen durch. Im Solana-Mainnet ist die übliche Reihenfolge ein Eintrag bei CoinGecko oder CoinMarketCap, dann die Aktualisierung der Reputation durch Solscan und die Verifizierung durch Jupiter. Solflare weist automatisch eine eigene Kennzeichnung zu.

EVM-Wallets erhalten mit einem Klick die Option **Zum Wallet hinzufügen** (EIP-747) in den Token-Zeilen, unter „Meine Token“ und auf dem Empfangsbildschirm. Solana-Wallets lesen Name, Symbol und Logo des Tokens aus seinen On-Chain-Metadaten.

### Schritt 3: Einer Nachricht folgen

Jeder Contract auf Ethereum oder einer AggLayer-Chain kann eine Nachricht an einen Contract auf Rome und zurück senden. Der Zustand von Rome liegt auf Solana, daher kann der empfangende Rome-Contract im selben Transaktionsaufruf jedes Solana-Programm aufrufen – signiert von seiner eigenen PDA, einem Solana-Konto, für das nur dieser Contract signieren kann. Ein Solana-Programm kann auf dieselbe Weise über Rome eine Nachricht senden.

Messaging ist erforderlich, wenn der Absender ein Contract ist (eine DAO, ein Governance-Executor, ein Vault, ein Escrow oder ein Safe) oder wenn Solana auf einer EVM-Chain Aktionen ausführen muss. Eine Person mit einem EVM-Wallet benötigt es nicht, da dieselbe Adresse direkt auf Rome funktioniert.

```
Ethereum / AggLayer-Chain               Rome (EVM, Zustand auf Solana)                  Solana
Absender ─ bridgeMessage(rome, rcvr, …, data) ─► Rome-Komitee veröffentlicht den Exit-Root
                                          beliebige Person: claimMessage(proof, data)
                                          └► rcvr.onMessageReceived(origin, net, data)
                                               └► optionaler CPI-Aufruf über 0xFF..08,
                                                  signiert von der PDA des Empfängers ──────► beliebiges Programm

Solana-Programm ─ CPI-Aufruf an Romes EVM-Programm, signiert von seiner PDA ─► bridgeMessage(dest, rcvr, data)
                                          Romes Zertifikat wird auf Ethereum finalisiert ─► jeder kann auf dem Zielnetzwerk den Claim ausführen
```

Eingehend ruft der Sender `bridgeMessage`auf. Das Komitee von Rome übermittelt den Exit-Root von Ethereum an Rome. Danach kann jeder `claimMessage` mit dem Nachweis aufrufen, und die Bridge ruft `onMessageReceived` auf Ihrem Receiver auf. Ausgehend ruft ein Solana-Programm das EVM-Programm von Rome auf, das `bridgeMessage`aufruft. Romes Zertifikat wird auf Ethereum finalisiert, und jeder kann auf dem Zielnetzwerk den Claim ausführen.

### Schritt 4: Gemessene Zeiten auslesen

Diese Übertragungsstrecken liefen auf Hadrian und Sepolia.

| Strecke                                                  | Ergebnis                                                                                    | Zeit bis zum Claim                                   | Kosten auf Hadrian                                             |
| -------------------------------------------------------- | ------------------------------------------------------------------------------------------- | ---------------------------------------------------- | -------------------------------------------------------------- |
| Sepolia-Vertrag → Rome-Vertrag                           | Zugestellt                                                                                  | 133–158 s                                            | 0,096 $ für einen neuen Receiver, danach 0,0007 $              |
| Sepolia → Rome-Vertrag → Solana Memo-Programm, ein Claim | Memo wurde ausgeführt, die PDA des Receivers hat signiert                                   | 158 s                                                | 0,096 $ für einen neuen Receiver                               |
| ETH-Wert mit einer Nachricht nach Rome                   | Kommt als gewöhnlicher Wrapped-ETH-Kontostand an                                            | 396 s (während eines Testlaufs mit hoher Auslastung) | $0.19                                                          |
| Token und Nachricht in einer Sepolia-Transaktion         | 5 von 5 zugestellt, Token zuerst beansprucht                                                | Nicht erfasst                                        | $0.175 + $0.119                                                |
| Receiver lehnt ab, akzeptiert dann                       | Die Simulation der API lehnte den Claim ab, daher wurde nichts gesendet; er traf später ein | 412 s                                                | 0,0007 $ für den akzeptierten Claim                            |
| Rome-Vertrag → Sepolia-Vertrag                           | Zugestellt und beansprucht                                                                  | 317 s                                                | 0,0007 $ für das Senden; 446.636 Gas für den Claim auf Sepolia |
| Solana-Programm → Rome → ausgehend                       | In einer Solana-Transaktion gesendet; auf Sepolia noch nicht beansprucht                    | n. v.                                                | 5.000 Lamports + eine Rome-Gebühr (nicht erfasst)              |

Ein Sepolia `bridgeMessage` mit einer erzwungenen Aktualisierung des Exit-Roots verbrauchte 395K bis 400K Gas. Gas auf der Quell-Chain kommt zusätzlich zu den oben genannten Hadrian-Kosten hinzu.

Noch nicht ausgeführt: Mainnet, AggLayer-L2-Nachrichten, eine Solana-Wallet als Sender, aus Rome gesendeter Wert, Wert plus ein Solana-Aufruf, ein realistischer Governance-Receiver und ein iterativer Claim.

### Schritt 5: Einen sicheren Receiver schreiben

* **Prüfen Sie den Aufrufer und den Ursprung.** `msg.sender` muss die Bridge sein. `(originNetwork, originAddress)` muss der Absender sein, dem du vertraust.
* **Genau einmal gehört dir.** Ein rückgängig gemachter Claim bleibt weiterhin möglich und kann erneut versucht werden. Die Rolle zum Entfernen der Exit-Root der Bridge kann einen Claim zurücksetzen. Verwalte deine Nonce selbst.
* **Es gibt keine automatischen Claims.** Deine App betreibt einen Claimer, oder der Nutzer führt den Claim aus. Der Claimer zahlt die Gasgebühren des Empfängers.
* **Wert in** kommt als Wrapped ETH auf Rome an. **Wert out** wird ausschließlich als Wrapped ETH übertragen (`bridgeMessageWETH`, in Vielfachen von 1e9 Wei), und dieser Pfad wurde noch nicht ausgeführt. Rome-Gas-USDC wird über CCTP übertragen, niemals über den AggLayer.
* **Ein Empfänger, der Solana aufruft, akzeptiert Nachrichten mit Wert null.** Übertrage den Wert als separaten Token in derselben Quelltransaktion und prüfe im Empfänger, ob er angekommen ist.
* **Miss deinen Compute-Bedarf.** Eine Solana-Transaktion erlaubt etwa 1,35 Mio. CU, und die Gasschätzung lehnt Werte über etwa 1,25 Mio. ab. Der Claim mit Memo-CPI benötigte 813.199 CU und lässt etwa 0,44 bis 0,54 Mio. CU für weitere Solana-Arbeit übrig. Größere Instruktionen und höhere Account-Zahlen wurden noch nicht gemessen. Bei rechenintensiveren Vorgängen, etwa einem DEX-Swap oder einer Kreditaufnahme, parke die Nachricht und führe sie anschließend in einer zweiten Transaktion aus.
* **Halte Nachrichten klein.** Ein Claim für eine 16-Byte-Nachricht verursacht bereits etwa 2,4 KB Calldata.
* **Begrenze, was eine einzelne Nachricht von Rome freischalten kann** auf dem Ziel, etwa durch ein Limit oder eine Verzögerung. Ausgehende Nachrichten beruhen allein auf den Signern von Rome.

Nachrichten eignen sich nicht für Intents, schnelle Ausführungen, Liquidationen oder Preis-Feeds. Die Übertragung von Sepolia nach Rome dauerte 133 bis 412 s, und eine AggLayer-L2-Route benötigt zusätzlich die eigene Finalisierung dieser Chain. Nachrichten eignen sich auch nicht für umfangreiche Solana-Arbeit innerhalb eines einzelnen Claims oder zum Kauf von Solana-Token über Nachrichten.

### Schritt 6. Erfahre, warum Solgate – und worauf du dich verlässt

* **Die Abwicklung erfolgt über den AggLayer von Polygon auf Ethereum.** Rome verwendet die Bridge-Verträge des AggLayer von Polygon unverändert. Die ausgehenden Zertifikate von Rome werden auf Ethereum mit dem pessimistischen Proof des AggLayer abgewickelt.
* **Es gibt kein separates Bridge-Validatornetzwerk.** Beteiligt sind Ethereum, der AggLayer und die eigenen Schlüssel von Rome: eingehend ein 2-aus-3-Komitee, ausgehend die AggLayer-Signer von Rome.
* **Es ist ein einziger Markt.** Auf Rome ist ein Solana-Token derselbe Mint und keine Wrapper-Version davon. Das Rome-Guthaben einer Solana-Wallet liegt in ihrem eigenen Token-Account, und Rome-Verträge bewegen dieselben SPL-Token.
* **Es ist auf beiden Seiten programmierbar.** Eine EVM-Nachricht kann ein Solana-Programm in der Transaktion ausführen, in der sie ankommt. Ein Solana-Programm kann über Rome eine Nachricht versenden.
* **Im Testnetz ist die Einrichtung von jeder der beiden Wallets aus ohne Berechtigungen möglich.** Eine Solana-Wallet zahlt ausschließlich SOL. Aus einem EVM-Token wird ein klassischer SPL-Mint ohne Freeze Authority, der ausschließlich von seinem Vertrag auf Rome geprägt wird.
* **Pro Chain gibt es nur eine Form, keine Wrapper-Version eines Wrappers.** Rome kennzeichnet selbst erstellte Token mit „(Rome)“, lässt Token mit einer Issuer-Route auf dieser Route und überbrückt niemals erneut die Kopie eines anderen Bridge-Anbieters.
* **Es ist eine einzige Verbindung zum AggLayer.** Dieselbe vereinheitlichte Bridge verbindet Ethereum und alle AggLayer-Chains, die die App aufführt.
* **Vergleiche die Vertrauensmodelle.** Auch Wormhole, LayerZero, CCIP und andere verbinden Solana- und EVM-Chains – jeweils mit einem eigenen Vertrauensmodell. Vergleiche für deinen Anwendungsfall die folgende Tabelle mit deren Modellen.

| Richtung                                 | Worauf du dich verlässt                                                                                                                                                                                                                                              |
| ---------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Ethereum → Rome                          | Ethereum sowie ein 2-aus-3-Komitee, das die Exit-Root von Ethereum an Rome übermittelt. Sie gehört zur Safe von Rome und ist durch einen Timelock geschützt.                                                                                                         |
| AggLayer-Chain → Rome                    | Das Vorstehende sowie das auf Ethereum abgewickelte Zertifikat dieser Chain                                                                                                                                                                                          |
| Rome → Ethereum oder eine AggLayer-Chain | Die AggLayer-Signer von Rome. Der pessimistische Proof begrenzt jeden Token, der von einer anderen Chain stammt, auf die Menge, die eingegangen ist. Nachrichten und Token, deren AggLayer-Ursprung Rome ist (SOL und andere Solana-Token), beruhen auf den Signern. |

### Schritt 7. Starte auf Hadrian

Die App ist unter [solgate.testnet.romeprotocol.xyz](https://solgate.testnet.romeprotocol.xyz)zu finden. Sie bietet Bridge, Token hinzufügen, Token, Claim, Aktivitäten und Funktionsweise. Die aktuelle Chain-Liste ist `GET /v1/chains`.

| Chain            | AggLayer-Netzwerk | Chain-ID | Hinweise                                                                                                                   |
| ---------------- | ----------------- | -------- | -------------------------------------------------------------------------------------------------------------------------- |
| Rome Hadrian     | 74                | 200010   | RPC `https://hadrian.testnet.romeprotocol.xyz/`, Explorer `via-hadrian.testnet.romeprotocol.xyz`; Status auf Solana Devnet |
| Ethereum Sepolia | 0                 | 11155111 | Du beanspruchst es für dich                                                                                                |
| Katana Bokuto    | 37                | 737373   | Du beanspruchst es für dich                                                                                                |
| Billions-Testnet | 32                | 6913     | Du beanspruchst es für dich                                                                                                |

Test-Token:

* **Solana-Devnet-SOL.** faucet.solana.com. Eine Solana-Wallet benötigt in Solgate nichts Weiteres.
* **Hadrian-Gas (USDC).** Testnet-USDC vom Faucet von Circle (faucet.circle.com), mit dem Rome-Bridge-Testnet (bridge-api.devnet.romeprotocol.xyz) als Hadrian-Gas an deine EVM-Adresse übertragen. Wähle ein Quell-Testnet aus der Liste des Rome Bridge.
* **Sepolia-ETH.** Ein beliebiges öffentliches Sepolia-Faucet.
* **Sepolia-ERC-20-Token, die bereits auf Hadrian verifiziert wurden.** Token aus dem Sepolia-Faucet von Aave (DAI, USDT, WBTC, AAVE, EURS). Oder stelle eigene bereit und richte sie ein.

Verträge und Code zum Lesen:

* Rome-Hadrian-Bridge: `0x5366e5864cb9dba587a706d8dd48cfdc40b961af` (Netzwerk 74). Sepolia-Bridge: `0x528e26b25a34a4A5d0dbDa1d57D318153d2ED582` (Netzwerk 0).
* Polygon-Bridge: `github.com/agglayer/agglayer-contracts`. Lies `AgglayerBridge.sol` und `AgglayerBridgeL2.sol` (`bridgeMessage`, `bridgeMessageWETH`, `claimMessage`) sowie das `IBridgeMessageReceiver` Interface (`onMessageReceived`).
* Rom es Solana-Precompiles: `github.com/rome-protocol/rome-solidity`, `contracts/interface.sol`. CPI-Aufrufe an beliebige Programme erfolgen über `0xFF00…0008`, und das SPL-Token-Precompile befindet sich unter `0xff00…0005`.
* Token-Adressen je Chain: `GET /v1/tokens`. Chains: `GET /v1/chains`. Live-Schalter: `GET /v1/switches`.

Die Message-API ist auf Hadrian live.

| Rufe                                         | Verwende                                                                                                                                                                                                  |
| -------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `POST /v1/transfers` `{ networkId, txHash }` | Erfasse einen von dir geminten Transfer. `networkId` ist das Netzwerk, von dem er gesendet wurde                                                                                                          |
| `GET /v1/transfers?wallet=<address>`         | Deine Einträge                                                                                                                                                                                            |
| `GET /v1/transfers?tx=<hash>`                | Die Einträge eines Transfers, zuerst ein Token                                                                                                                                                            |
| `GET /v1/transfers/:id`                      | Ein Eintrag mit seinem Status: sent → certified → settled → ready\_to\_claim → claimed → received                                                                                                         |
| `GET /v1/transfers/:id/claim`                | Die Claim-Transaktion, zuerst simuliert. Ein Empfänger, der einen Revert auslösen würde, liefert `message_would_fail`zurück. Die Simulation erkennt keinen Claim, der Solanas Compute-Limit überschreitet |

### Schritt 8. Von Hadrian zu Rubicon wechseln

Rubicon ist die Rome-Mainnet-Chain mit Status auf Solana Mainnet, abgewickelt über das AggLayer auf Ethereum Mainnet. Solgate ist auf Rubicon unter [solgate.romeprotocol.xyz](https://solgate.romeprotocol.xyz)live, mit Ethereum, X Layer und Katana, und Rome listet die Token dort. Was du auf Hadrian entwickelst, lässt sich mit geänderten Chain-IDs und Adressen übertragen. Miss Zeiten und Kosten auf dem Mainnet erneut, denn die Werte von Hadrian stammen aus dem Testnet. Den allgemeinen Wechsel findest du unter [11. Auf Rubicon veröffentlichen](https://docs.rome.builders/de/rome-academy/11-ship-to-rubicon.md).

Auf dem Mainnet: Transfers in beide Richtungen und Claim auf Solana für SOL, ETH, USDT, WBTC und OKB, automatischer Claim von ETH-Einzahlungen von Ethereum an eine EVM-Wallet auf Rubicon, der Tab „Token“, Aktivitätsfilter und die Karte „Angekommen“. Message-Tracking, erlaubnisfreie Token-Einrichtung über beide Wallets und ein Listing-Prozess für auf Solana entstandene Token laufen auf dem Testnet und sind auf dem Mainnet noch nicht verfügbar. Siehe [Solgate verwenden](https://docs.rome.builders/de/apps-auf-rome/solgate/using.md).

Was sich auf dem Mainnet ändert:

* Echte Gasgebühren: USDC auf Rubicon (über die Rome Bridge übertragen) und ETH auf Ethereum.
* Die Ankunftszeiten richten sich nach der Abwicklung im Mainnet: Ethereum nach Solana etwa 120 Sekunden, Solana nach Ethereum etwa 6 Minuten, X Layer von Solana etwa 18 Minuten, Katana von Solana etwa 4 Minuten und Katana nach Solana etwa 65 Minuten. [Solgate verwenden](https://docs.rome.builders/de/apps-auf-rome/solgate/using.md#times) führt sie auf.
* Phantom und Solflare fügen Transaktionen im Mainnet eigene Anweisungen hinzu.
* Wallets und Block-Explorer führen eigene Token-Prüfungen durch (Schritt 2).
* Das Vertrauensmodell bleibt gleich, mit Rome's Mainnet-Komitee und Signatursatz.

Entwickle jetzt auf Hadrian. Veröffentliche auf Rubicon, wenn du bereit bist.

## Überprüfe dein Wissen

Führe einen kleinen Roundtrip auf Hadrian durch.

1. Stelle einen Test-ERC-20 auf Sepolia bereit, überbrücke einige Token zu Hadrian und führe dann **Token hinzufügen** mit einer EVM-Wallet aus. Lies den Gesamtbetrag auf der Karte, bevor du signierst.
2. Erstelle einen SPL-Mint auf Solana Devnet, wähle ihn mit einer Solana-Wallet in der Bridge aus, sende ihn an Ethereum Sepolia und führe dort den Claim aus.
3. Schreibe einen Empfänger mit den beiden Prüfungen und einem Nonce. Sende ihm von einem Sepolia-Contract eine Message und führe den Claim mit `GET /v1/transfers/:id/claim`.

Beantworte anschließend:

* Welche zwei Werte prüft ein Empfänger, bevor er einer Message vertraut?
* Ein Empfänger ruft Solana auf und muss außerdem einen Wert erhalten. Wie sendest du ihn?
* Warum eignen sich Messages nicht für eine Liquidation?

<details>

<summary>Antworten</summary>

* `msg.sender`, bei dem es sich um die Bridge handeln muss, und `(originNetwork, originAddress)`, bei dem es sich um den Absender handeln muss, dem du vertraust.
* Sende die Nachricht mit einem Wert von null. Sende den Wert als separaten Token in derselben Quelltransaktion und prüfe beim Empfänger, ob er angekommen ist.
* Die Übertragung von Sepolia nach Rome dauerte 133 bis 412 s, und eine AggLayer-L2-Route benötigt zusätzlich die eigene Abwicklungszeit dieser Chain. Eine Liquidation kann nicht so lange warten.

</details>

## Weiter

Ideen zum Umsetzen und wo du jeweils anfangen kannst, findest du unter [Solgate-Ideen](https://docs.rome.builders/de/apps-auf-rome/solgate/ideas.md). Die Referenzseiten sind [Entwickeln auf Solgate](https://docs.rome.builders/de/apps-auf-rome/solgate/builders.md) für Token und [Messaging auf Solgate](https://docs.rome.builders/de/apps-auf-rome/solgate/messaging.md) für Nachrichten.

[Zurück zur Kursübersicht](https://docs.rome.builders/de/rome-academy/academy.md)


---

# 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/rome-academy/13-build-on-solgate.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.
