> 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/01-what-you-are-building.md).

# 1. Was du auf Rome aufbaust

Rome macht EVM und Solana zu einem Markt. Wie ein Vertrag EVM- und Solana-Wallets bedient und die App, die Sie in diesem Kurs erstellen.

Rome macht aus EVM und Solana einen gemeinsamen Markt. Du schreibst Solidity und stellst den Vertrag mit Hardhat oder Foundry bereit – er läuft dann auf Solana. Diese Lektion vermittelt dir das Grundverständnis für die anderen zwölf. Du erstellst einen USDC-Tresor, der Einzahlungen von EVM- und Solana-Wallets entgegennimmt.

## Das lernst du

* Was Rome ist und warum sein Zustand Solana-Zustand ist.
* Die zwei Wallet-Wege: ein EVM-Schlüssel und ein Solana-Schlüssel, ein Vertrag.
* Was eine Dual-Lane-App ist und welches Beispiel du in Lektion 9 erstellst.
* Die beiden Netzwerke, die du verwendest: Hadrian zum Testen und Rubicon für den Produktivbetrieb.

## Bevor du loslegst

Dies ist die erste Lektion. Lies den [Kursüberblick](https://docs.rome.builders/de/rome-academy/academy.md) , damit du weißt, womit der Kurs endet. Mehr brauchst du nicht. Ein Wallet benötigst du noch nicht.

## Die Idee

EVM und Solana sind zwei Märkte. Rome macht daraus einen.

Rome führt EVM-Chains innerhalb von Solana aus, sodass jedes EVM-Protokoll es einmal bereitstellen und für Solana-Wallets öffnen kann. Ein Solidity-Vertrag auf Rome ruft Solana-Programme direkt auf, sodass EVM-Nutzer Kamino und Solana-DEXes nutzen können. Solgate verbindet Solana-Assets in beide Richtungen mit AggLayer-EVM-Chains – auf Mainnet und Testnet. Im Testnet ist die Registrierung von SPL-Token erlaubnisfrei. USDC verwendet CCTP.

Rome führt Solidity-Verträge aus, indem ein EVM-Interpreter in ein Solana-Programm eingebettet wird. Wenn du einen Vertrag bereitstellst, werden sein Code und sein Speicher zu Solana-Konten. Wenn jemand ihn aufruft, läuft der Interpreter innerhalb der Solana-Runtime. Ein Aufruf kann innerhalb derselben Transaktion jedes Solana-Programm erreichen. Schlägt ein Schritt fehl, wird die gesamte Transaktion rückgängig gemacht.

Der Zustand ist Solana-Zustand. Innerhalb von Rome lesen das SPL-Token eines Wallets und sein ERC-20-Wrapper dasselbe Tokenkonto. Daher wird zwischen ihnen nichts geprägt oder gesperrt.

Lies [Ein gemeinsamer Markt](https://docs.rome.builders/de/erste-schritte-1/one-market.md) für die Idee anhand von vier Funktionen und [Was ist Rome?](https://docs.rome.builders/de/erste-schritte-1/what-is-rome.md) für den vollständigen Überblick. Überfliege [Warum Rome?](https://docs.rome.builders/de/erste-schritte-1/why-rome.md) , wenn du den Vergleich mit anderen Ansätzen sehen möchtest.

## Die zwei Wege

Zwei Arten von Nutzern können denselben Vertrag aufrufen.

|                                | EVM-Weg                                               | Solana-Weg                                                          |
| ------------------------------ | ----------------------------------------------------- | ------------------------------------------------------------------- |
| Wallet                         | MetaMask oder ein beliebiges EVM-Wallet               | Ein Solana-Wallet                                                   |
| Schlüssel                      | Ein EVM-Schlüssel                                     | Ein Solana-Schlüssel                                                |
| Identität in deinem Vertrag    | Die übliche Adresse                                   | Eine synthetische Adresse, die vom Solana-Schlüssel abgeleitet wird |
| Wie der Aufruf übertragen wird | Signierte EVM-Transaktion, an den Rome-Proxy gesendet | Vom Wallet signierte Solana-Transaktion, an Solana gesendet         |

Auf beiden Wegen `msg.sender` ist eine gewöhnliche Adresse und der Vertrag ist derselbe. Solana-Nutzer benötigen keinen EVM-Schlüssel. Rome verknüpft die beiden Identitäten niemals. Ein MetaMask-Schlüssel und ein Solana-Schlüssel sind zwei verschiedene Konten – genau wie zwei MetaMask-Schlüssel.

[Wie Solana und die EVM auf Rome zusammenkommen](https://docs.rome.builders/de/kernkonzepte/how-solana-and-evm-meet.md) erklärt die synthetische Adresse, wer signiert und wer bezahlt. Darauf kommst du in Lektion 4 zurück. Lies vorerst die ersten beiden Abschnitte.

## Die App, die du erstellst

Eine Dual-Lane-App ist ein einzelner Solidity-Vertrag, den sowohl EVM- als auch Solana-Nutzer direkt verwenden. Das Beispiel in diesem Kurs ist ein kleiner Tresor. Nutzer zahlen USDC ein und heben es später wieder ab.

Der Vertrag ist ein gewöhnlicher ERC-20-Tresor. Er ruft Token mit `transferFrom` ab und gibt sie mit `transfer`zurück. Er enthält nichts Rome-spezifisches. Das USDC eines Solana-Nutzers erscheint auf der EVM-Seite als ERC-20-Wrapper dieses SPL-Tokens. Daher funktionieren dieselben beiden Aufrufe auf beiden Wegen.

Du erstellst ihn in Lektion 9. Die zugehörige Anleitung heißt [Eine Dual-Lane-App erstellen](https://docs.rome.builders/de/entwicklerleitfaden/dual-lane-app.md). In den Lektionen 3 bis 8 lernst du alles, was du dafür brauchst:

1. Deployment auf Hadrian (Lektion 3).
2. So führt Rome einen Aufruf aus (Lektion 4).
3. Solana-Programme aufrufen (Lektion 5).
4. Tokens und Wrapper (Lektion 6).
5. Der Solana-Wallet-Pfad (Lektion 7).
6. Die andere Richtung: Dein Solana-Programm wird von EVM-Wallets aus aufgerufen (Lektion 8).

In den Lektionen 10 und 11 bringst du die App zu echten Nutzern und echtem Geld. Lektion 12 gibt einen kurzen Überblick über den größeren Schritt: deine eigene Rome-Chain.

Die nächste Lektion, [Was du bauen kannst](https://docs.rome.builders/de/rome-academy/02-what-you-can-build.md), zeigt die Anwendungsfälle für dieses Muster.

## Die beiden Netzwerke

* **Hadrian** ist das öffentliche Testnet. Es wickelt Transaktionen auf Solana Devnet ab, und sein USDC ist Test-USDC. Hier entwickelst du zunächst alles.
* **Rubicon** ist das Mainnet. Es wickelt Transaktionen auf Solana Mainnet ab, und für Gas wird echtes USDC verwendet.

Beide Netzwerke zahlen Gas in USDC. Rubicon verwendet dieselbe EVM, sodass sich dieselben Contract-Artefakte auf beiden Netzwerken deployen lassen. Chain-IDs, RPC-URLs und Explorer-Links findest du unter [Hadrian](https://docs.rome.builders/de/netzwerke/hadrian.md) und [Rubicon](https://docs.rome.builders/de/netzwerke/rubicon.md). In den Lektionen verweisen wir darauf, statt die Informationen hier zu wiederholen.

## In Aktion erleben

Die Apps von Rome zeigen das Prinzip in der Praxis. [Apps auf Rome](https://docs.rome.builders/de/apps-auf-rome/apps.md) listet sie auf. Zwei davon solltest du dir jetzt ansehen:

* Rome DEX: ein Pool, mit dem sowohl EVM- als auch Solana-Wallets handeln können.
* Aerarium: ein Kreditmarkt, auf dem beide Nutzertypen einzahlen und Kredite aufnehmen können.

Öffne eine der Apps und sieh dir den Wallet-Verbindungsbildschirm an. Dort werden beide Wallet-Typen angeboten.

## Selbst überprüfen

Beantworte diese Fragen, ohne nachzusehen, und öffne dann die Antworten.

1. Wo liegt der Code eines Contracts, nachdem du ihn auf Rome deployt hast?
2. Ein Solana-Nutzer und ein MetaMask-Nutzer rufen deinen Vault auf. Was erhält der Vault jeweils als `msg.sender` ?
3. Auf welchem Netzwerk entwickelst du zuerst und warum?

<details>

<summary>Antworten</summary>

1. In Solana-Accounts, die dem Rome-EVM-Programm gehören. Der Contract wird innerhalb der Solana-Runtime ausgeführt.
2. Eine gewöhnliche Adresse. Beim MetaMask-Nutzer ist es seine EVM-Adresse. Beim Solana-Nutzer ist es eine synthetische Adresse, die aus seinem Solana-Schlüssel abgeleitet wird.
3. Hadrian. Sein USDC ist Test-USDC, Fehler kosten also nichts. Rubicon ist das Produktivnetzwerk und dort wird echtes USDC für Gas verwendet.

</details>

## Weiter

[2. Was du bauen kannst: Die relevanten Anwendungsfälle](https://docs.rome.builders/de/rome-academy/02-what-you-can-build.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/01-what-you-are-building.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.
