> 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/academy.md).

# Rome Academy

Rome vereint EVM und Solana zu einem Markt. Ein Kurs mit dreizehn Lektionen: vom ersten Rome-Contract über eine App für EVM- und Solana-Wallets bis hin zu deiner eigenen Chain.

Rome macht EVM und Solana zu einem gemeinsamen Markt. In der Rome Academy lernst du, auf Rome zu entwickeln – vom einzelnen Contract bis zu deiner eigenen Chain. Du beginnst mit einem Contract auf dem Testnet, entwickelst eine App, die sowohl MetaMask-Nutzer als auch Nutzer von Solana-Wallets verwenden, veröffentlichst sie auf dem Mainnet und erhältst zum Abschluss einen Überblick darüber, wie du deine eigene Rome-Chain betreibst.

## Für wen der Kurs gedacht ist

Du kennst Solidity oder Solana, hast aber noch nie auf Rome entwickelt. Du musst nicht beides kennen. Der Kurs erklärt dir jeweils die Seite, mit der du noch nicht vertraut bist.

## Was du entwickeln wirst

Du stellst einen Contract bereit, integrierst Solana und entwickelst einen Vault für beide Wallet-Typen.

* **Ein Contract.** Du stellst einen Solidity-Contract auf Hadrian, dem öffentlichen Testnet, bereit und rufst ihn im Explorer auf.
* **Ein Contract, der mit Solana funktioniert.** Er ruft Solana-Programme auf und verarbeitet SPL-Token aus Solidity. Außerdem machst du ein Solana-Programm für EVM-Nutzer zugänglich.
* **Eine App für beide Wallet-Typen.** Ein bereitgestellter Contract dient EVM-Nutzern, die mit einem MetaMask-Schlüssel signieren, und Solana-Nutzern, die mit einem Solana-Wallet-Schlüssel signieren und keinen EVM-Schlüssel benötigen. Beide greifen auf denselben Contract, denselben Zustand und dieselben Gelder zu.
* **Eine veröffentlichte App.** Mit der Rome Bridge bringst du Nutzer und Gelder von anderen Chains herüber und betreibst die App auf Rubicon, dem Mainnet.
* **Eine eigene Chain.** Lektion 12 zeigt, was nötig ist, um deine eigene Rome-Chain mit eigener Chain-ID und eigenem Gas-Token zu betreiben.

[Was du entwickeln kannst](https://docs.rome.builders/de/rome-academy/02-what-you-can-build.md) ist die Lektion, die du zuerst lesen solltest, wenn du die Anwendungsfälle vor den technischen Details kennenlernen möchtest. [Ein gemeinsamer Markt](https://docs.rome.builders/de/erste-schritte-1/one-market.md) fasst die Idee hinter dem Kurs auf einer Seite zusammen.

## Die Lektionen

Jede Lektion verweist auf den Guide mit den Befehlen und dem Code. In der Lektion erfährst du, warum du etwas tust und in welcher Reihenfolge.

### Teil 1. Grundlagen

Lerne, wie Rome funktioniert, und stelle deinen ersten Contract auf Hadrian bereit.

| Lektion                                                                                                           | Was du machst                                                                             | Ungefähre Dauer |
| ----------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- | --------------- |
| [1. Was du auf Rome entwickelst](https://docs.rome.builders/de/rome-academy/01-what-you-are-building.md)          | Lerne, was Rome ist und wie eine App mit zwei Ausführungswegen aussieht                   | 20 Minuten      |
| [2. Was du entwickeln kannst](https://docs.rome.builders/de/rome-academy/02-what-you-can-build.md)                | Sieh dir die wichtigsten Anwendungsfälle an und wähle aus, welchen du umsetzen möchtest   | 20 Minuten      |
| [3. Dein erster Contract auf Hadrian](https://docs.rome.builders/de/rome-academy/03-first-contract-on-hadrian.md) | Lade eine Wallet mit Guthaben auf, stelle einen Contract bereit und finde ihn im Explorer | 45 Minuten      |
| [4. So führt Rome deinen Code aus](https://docs.rome.builders/de/rome-academy/04-how-rome-runs-your-code.md)      | Verfolge eine Transaktion von deiner Wallet zu Solana und zurück                          | 30 Minuten      |

### Teil 2. Zwei Welten

Rufe Solana-Programme auf, arbeite mit SPL-Token und entwickle eine App für EVM- und Solana-Wallets. Jede Lektion enthält ein ausgearbeitetes Beispiel.

| Lektion                                                                                                                                 | Was du machst                                                               | Ungefähre Dauer |
| --------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------- | --------------- |
| [5. Solana aus Solidity aufrufen](https://docs.rome.builders/de/rome-academy/05-call-solana-from-solidity.md)                           | Verwende die CPI- und Helper-Precompiles, um ein Solana-Programm aufzurufen | 60 Minuten      |
| [6. Token auf beiden Seiten](https://docs.rome.builders/de/rome-academy/06-tokens-on-both-sides.md)                                     | Arbeite mit SPL-Token über ihre ERC-20-Wrapper                              | 45 Minuten      |
| [7. Deine EVM-App für Solana-Wallets öffnen](https://docs.rome.builders/de/rome-academy/07-open-to-solana-wallets.md)                   | Ermögliche es einer Solana-Wallet, deinen Contract aufzurufen               | 60 Minuten      |
| [8. Dein Solana-Programm für EVM-Nutzer öffnen](https://docs.rome.builders/de/rome-academy/08-open-your-solana-program-to-evm-users.md) | Ermögliche es EVM-Wallets, ein Solana-Programm zu nutzen                    | 60 Minuten      |
| [9. Eine App mit zwei Ausführungswegen entwickeln](https://docs.rome.builders/de/rome-academy/09-build-a-dual-lane-app.md)              | Entwickle die App, die beide Wallet-Typen unterstützt                       | 90 Minuten      |

### Teil 3. Reichweite und Deployment

Praktische Lektionen, mit denen du deine App zu den Nutzern und ins Mainnet bringst.

| Lektion                                                                                                                  | Was du machst                                                            | Ungefähre Dauer |
| ------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------ | --------------- |
| [10. Nutzer und Gelder von anderen Chains einbinden](https://docs.rome.builders/de/rome-academy/10-from-other-chains.md) | Bringe Gelder über die Bridge ein und erreiche Nutzer auf anderen Chains | 45 Minuten      |
| [11. Auf Rubicon deployen](https://docs.rome.builders/de/rome-academy/11-ship-to-rubicon.md)                             | Führe dieselbe App im Mainnet aus                                        | 60 Minuten      |

### Teil 4. Der nächste große Schritt

Erfahre, was eine eigene Chain bedeutet und wann sie sinnvoll ist.

| Lektion                                                                                                 | Was du machst                                                   | Ungefähre Dauer |
| ------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------- | --------------- |
| [12. Eine eigene Chain starten](https://docs.rome.builders/de/rome-academy/12-launch-your-own-chain.md) | Erfahre, was eine eigene Rome-Chain ist und was dafür nötig ist | 30 Minuten      |

### Teil 5. Auf der Bridge entwickeln

Entwickle auf Solgate, der Route für Token und Nachrichten zwischen Solana und anderen Chains. Lies diese Lektion nach Lektion 10.

| Lektion                                                                                         | Was du machst                                                                            | Ungefähre Dauer |
| ----------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------- | --------------- |
| [13. Auf Solgate entwickeln](https://docs.rome.builders/de/rome-academy/13-build-on-solgate.md) | Verschiebe Token und sende Nachrichten zwischen Solana und Ethereum oder AggLayer-Chains | 60 Minuten      |

Die Zeitangaben gelten für Leser, die die Anleitungen der Reihe nach durcharbeiten. Plane zusätzliche Zeit für die Finanzierung und Wartezeiten bei Bridge-Transfers ein.

## Was du vor dem Start brauchst

* Node.js. Im [Quickstart](https://docs.rome.builders/de/erste-schritte-1/quickstart.md) ist die Version angegeben.
* MetaMask.
* Ab Lektion 7 eine Solana-Wallet, die Solana-v1-Transaktionen signiert. [Deinen Contract für Solana-Nutzer öffnen](https://docs.rome.builders/de/entwicklerleitfaden/open-to-solana-users.md) gibt an, welche Wallets derzeit funktionieren.
* Ein wenig Test-USDC auf Hadrian für die Gasgebühren. Lektion 3 zeigt, wie du es erhältst. Die Seite [Faucets](https://docs.rome.builders/de/ressourcen/faucets.md) führt alle Bezugsquellen auf.
* Einen Code-Editor und ein Terminal.

Gasgebühren im Mainnet werden mit echtem USDC bezahlt. In den Lektionen 1 bis 10 wird ausschließlich das Testnet verwendet. In Lektion 11 gibst du zum ersten Mal echtes Geld aus.

## Wo du Hilfe bekommst

* [Discord](https://discord.gg/vZ9rnCdNSB) für Entwickler-Support und den Austausch in der Community.
* [Telegram](https://t.me/+tdnr-M6kcngxYzhk) für Ankündigungen und Neuigkeiten.
* [GitHub](https://github.com/rome-protocol) für Quellcode und Issues. Erstelle ein Issue, wenn du einen Fehler findest oder eine Seite in dieser Dokumentation falsch oder unklar ist.
* [Community](https://docs.rome.builders/de/ressourcen/community.md) führt alle Kanäle auf.

Registriere, was du entwickelst, in der [Arena](https://arena.mainnet.romeprotocol.xyz/apps/new).

Beginne mit [Lektion 1](https://docs.rome.builders/de/rome-academy/01-what-you-are-building.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/academy.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.
