> 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/08-open-your-solana-program-to-evm-users.md).

# 8. Öffne dein Solana-Programm für EVM-Nutzer

Lass MetaMask-Nutzer ein Programm aufrufen, das du bereits auf Solana betreibst, über einen schlanken Solidity-Vertrag und das CPI-Precompile, ohne Portierung und ohne zweite Kopie deines Zustands.

Du hast ein funktionierendes Solana-Programm. Seine Nutzer halten Solana-Wallets. Rome ermöglicht einem zweiten Publikum den Zugriff darauf, nämlich Menschen, die eine EVM-Wallet wie MetaMask besitzen, ohne dass du das Programm in Solidity neu schreiben musst.

## Was du lernen wirst

* Warum du ein Solana-Programm für EVM-Nutzer öffnen würdest, und was du beibehältst.
* Wie ein EVM-Aufruf dein Programm erreicht: ein schlanker Solidity-Vertrag und das CPI-Precompile.
* Was dein Programm als Signer und als Konten sieht.
* Wie die Tokens eines EVM-Nutzers dein Programm erreichen und wieder zurückkommen.
* Die Grenzen, um die du herumdesignen musst: ein Track, eine atomare Transaktion, das Kontenlimit.

## Der Anwendungsfall

Diese Lektion dient einem Anwendungsfall von [Was du bauen kannst](https://docs.rome.builders/de/rome-academy/02-what-you-can-build.md): einer bestehenden Solana-Anwendung, die mehr Nutzer haben will. Ein Lending-Markt, ein AMM, ein Vault, ein Prognosemarkt oder ein Privacy-Programm passen alle dazu.

Das EVM-Publikum ist groß und hat bereits Wallets, Tools und Gewohnheiten. Wenn du dein Programm nach Solidity portierst, pflegst du zwei Codebasen und teilst deinen Zustand auf. Auf Rome behältst du ein Programm und einen Zustand. EVM-Nutzer erreichen es über einen kleinen Solidity-Vertrag, und Solana-Nutzer rufen es weiterhin nativ auf. Beide handeln gegen dieselben Konten und dieselbe Liquidität. [Wähle deinen Kern](https://docs.rome.builders/de/kernkonzepte/choose-your-core.md) nennt diese Form (b), einen nativen Solana-Kern mit einem schlanken CPI-Router.

[rome-dex](https://github.com/rome-protocol/rome-dex) ist die Referenz: ein nativer Solana-Pool mit einem EVM-Router davor.

## Bevor du beginnst

* Abschluss [7. Öffne deine EVM-App für Solana-Wallets](https://docs.rome.builders/de/rome-academy/07-open-to-solana-wallets.md), die gleiche Idee von der anderen Seite.
* Wissen [5. Rufe Solana aus Solidity auf](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). Diese Lektion setzt sie zusammen.
* Stelle sicher, dass dein Programm auf dem Solana-Devnet deployed ist. Hadrian wickelt dort ab, daher muss das Programm auf diesem Cluster existieren. Siehe [Hadrian](https://docs.rome.builders/de/netzwerke/hadrian.md).

## Der Ablauf in Kürze

### Schritt 1: Setze einen schlanken Vertrag vor dein Programm

Der Vertrag ist ein Adapter. Er enthält keine Geschäftslogik. Er prüft den Aufrufer, baut deine Instruction und ruft das CPI-Precompile mit `invoke_signed`. Alles andere bleibt in deinem Solana-Programm. Die Aufrufmechanik steht in [Solana aus EVM aufrufen](https://docs.rome.builders/de/entwicklerleitfaden/call-solana-from-evm.md#calling-custom-solana-programs), und die Schnittstelle ist `contracts/interface.sol` im öffentlichen [rome-solidity](https://github.com/rome-protocol/rome-solidity) Repo behandelt.

Dein Adapter hat drei Möglichkeiten, die Position eines Nutzers zu halten. Der Leitfaden vergleicht sie in [Drei Möglichkeiten, die Position eines Nutzers zu halten](https://docs.rome.builders/pages/efd1c176728a1a4534ac7d3a596931b458c2e34f#id-2.-three-ways-to-hold-a-users-position):

| Form                               | Was es ist                                                                  | Passt zu                                                       |
| ---------------------------------- | --------------------------------------------------------------------------- | -------------------------------------------------------------- |
| Adapter-Vertrag                    | Zieht die Tokens des Nutzers ein und ruft dein Programm als sich selbst auf | Eine wiederverwendbare Front für ein Programm mit Einzahlungen |
| Der Nutzer ruft das Precompile auf | Die eigene Autorität des Nutzers signiert, kein Vertrag                     | Einmalige Genehmigungen und einfache Programme                 |
| Verwahrungsfreier Router           | Hält nie Tokens, sondern verwendet die Delegation des Nutzers               | Swaps und andere Einmalaktionen                                |

Wähle den Adapter für ein Vault- oder Lending-Programm und den Router für einen Swap.

### Schritt 2: Verstehe, wen dein Programm sieht

Jede EVM-Adresse hat eine Solana-Identität, ihr PDA mit externer Autorität, abgeleitet unter dem Rome-Programm. Wenn ein Vertrag das Precompile aufruft, signiert Rome mit der Autorität dieses Vertrags. Dein Programm sieht einen 32-Byte-Public-Key, der als Signer markiert ist. Es sieht niemals eine 20-Byte-EVM-Adresse und niemals den Nutzer.

Der Nutzer ist also nicht der Signer. Um Nutzer voneinander zu unterscheiden, übergibt der Adapter einen nutzerspezifischen Wert in den Instruction-Daten oder bittet Rome, zusätzlich mit einem gesalzenen Sub-PDA zu signieren, das von der Adresse des Nutzers abgeleitet ist. Dein Programm hält dann eine Position pro Sub-PDA. Die Signer-Regeln stehen in [Jede EVM-Adresse hat eine Solana-Identität](https://docs.rome.builders/pages/efd1c176728a1a4534ac7d3a596931b458c2e34f#id-1.-every-evm-address-has-one-solana-identity).

Schreibe dein Programm so, dass es auf jede Autorität reagiert, die signiert. Dann dient es gleichermaßen einer Solana-Wallet und einem Adapter.

### Schritt 3: Bewege die Tokens des Nutzers

Auf Rome ist das USDC eines Nutzers ein SPL-Token, der von zwei Seiten gesehen wird, wie Lektion 6 gezeigt hat. Das Guthaben des Nutzers liegt in einem Token-Konto, das seiner Autorität gehört. Damit ein Adapter es ausgeben kann, erteilt der Nutzer dem Adapter vor der Einzahlung eine SPL-Delegation. Der Adapter zieht die Tokens in ein Token-Konto ein, das ihm gehört, und ruft dann dein Programm auf. Auf dem Rückweg zahlt dein Programm an das eigene Token-Konto des Nutzers aus, und der Nutzer sieht es sofort als ERC-20-Guthaben.

Hier sind zwei Fallen wichtig:

* Ein ERC-20 `transferFrom` an einen Vertrag schreibt nur im Escrow-Hauptbuch des Wrappers gut. Der Vertrag bekommt kein Token-Konto, von dem aus er ausgeben kann. Verwende die Delegation, nicht den Wrapper.
* Ein Token-Konto hat nur einen Delegate. Deine Genehmigung verdrängt die Genehmigung des Wrappers, und die normalen Token-Überweisungen des Nutzers stoppen, bis er dem Wrapper erneut eine Genehmigung erteilt. Prüfe `isEnabled` nach deinem Ablauf.

Der vollständige Ablauf steht in [Tokens rein, Tokens raus](https://docs.rome.builders/pages/efd1c176728a1a4534ac7d3a596931b458c2e34f#id-3.-tokens-in-tokens-out).

### Schritt 4: Bleibe innerhalb der Grenzen

* **Ein Track.** Ein benutzerdefinierter Programmaufruf ist eine CPI im Legacy-Track. Eine Transaktion darf ihn nicht mit Aufrufen im Cached-Track mischen, also halte den Cached-Wrapper aus dieser Transaktion heraus.
* **Nur atomar.** Eine CPI im Legacy-Track kann nicht in einer iterativen Transaktion ausgeführt werden. Der gesamte Aufruf muss in eine Solana-Transaktion passen, etwa 1,4 Mio. Compute Units, 64 Adressen und 4 KB. Dein Programm teilt sich dieses Compute-Budget mit dem Rome-Programm.
* **Konten im Voraus.** Rome emuliert den Aufruf und nimmt jedes Konto, das es berührt, in die Solana-Transaktion auf. Jedes Konto muss aus Eingaben ableitbar sein, die der Adapter hat. Ein neues Konto muss trotzdem benannt sein.
* **Geringe Tiefe.** Dein Programm läuft eine Ebene unter Rome. Jedes Programm, das es aufruft, verwendet eine weitere Ebene.
* **Die Miete zahlt der Nutzer.** Konten, die deine Instruction erstellt, werden über das Gas des Nutzers bezahlt.

Beschränke jede Aktion auf eine Token-Bewegung und eine CPI in dein Programm. Teile alles Größere in zwei Nutzertransaktionen auf. Die Grenzen stehen in einer Tabelle in [Beschränkungen](https://docs.rome.builders/de/kernkonzepte/constraints.md).

## Ein durchgerechnetes Beispiel

Angenommen, dein Programm ist ein Vault. Ein Solana-Nutzer zahlt USDC ein und hebt es später wieder ab. Du willst, dass MetaMask-Nutzer dasselbe tun.

1. Du deployest einen Adapter, der deine Programm-ID und den USDC-Mint kennt. In seinem Konstruktor erstellt er seine eigene Solana-Identität und ein Token-Konto dafür.
2. Ein MetaMask-Nutzer sendet eine Transaktion, die dem Adapter eine SPL-Delegation auf sein USDC gewährt.
3. Der Nutzer ruft `Deposit`. Der Adapter zieht das USDC in sein eigenes Token-Konto und ruft dann dein Programm mit seiner eigenen Autorität und einem gesalzenen Sub-PDA für diesen Nutzer als Signer auf.
4. Dein Programm verschiebt das USDC in seinen Vault und speichert die Position unter dem Sub-PDA.
5. Die Genehmigung des Adapters hat die des Wrappers verdrängt, also liest deine App `isEnabled` im Wrapper für den Nutzer. Sie gibt `false`zurück, und der Nutzer sendet `approve_spl` für den Wrapper erneut. Die nächste Einzahlung braucht eine neue Genehmigung für den Adapter.
6. Der Nutzer ruft `withdraw`. Der Adapter lässt dein Programm direkt aus dem Vault an das Token-Konto des Nutzers auszahlen. Der Saldo erscheint in MetaMask als ERC-20-Token.

Deine Solana-Nutzer haben den Adapter nie berührt. Sie rufen den Vault direkt auf und sehen dieselben Summen. Die passende Solidity-Skizze steht in [Eine Einzahlung und eine Auszahlung in Solidity](https://docs.rome.builders/pages/efd1c176728a1a4534ac7d3a596931b458c2e34f#id-7.-a-deposit-and-a-withdraw-in-solidity).

Teste zuerst auf Hadrian. `eth_call` und `eth_estimateGas` führt dieselbe Emulation aus, die der Proxy zum Senden verwendet, sodass eine CPI, die dort fehlschlägt, aus demselben Grund auf der Kette fehlschlägt, und der Revert den Fehler deines Programms trägt. Lies nach einem Senden die Solana-Seite der Transaktion mit `rome_solanaTxForEvmTx`. Siehe [Testen](https://docs.rome.builders/pages/efd1c176728a1a4534ac7d3a596931b458c2e34f#id-8.-testing).

## Prüfe dich selbst

Nimm ein kleines Programm von dir oder das in rome-dex und notiere ohne Code:

1. Den Signer, den dein Programm sieht, wenn ein Adapter es aufruft.
2. Die Konten, die eine Einzahlung benennt.
3. Die Anzahl der Token-Bewegungen und CPIs in dieser Einzahlung.

Deploye dann deinen Adapter auf Hadrian, fülle das Token-Konto des Nutzers auf, sende die SPL-Genehmigung an den Adapter und führe die Einzahlung durch `eth_estimateGas` mit der Adresse des Nutzers als `von`. Die Schätzung sollte erfolgreich sein. Wenn sie fehlschlägt, nennt die Revert-Daten den Solana-Fehler.

<details>

<summary>1. Ein MetaMask-Nutzer zahlt über deinen Adapter ein. Wer signiert für dein Programm?</summary>

Der PDA mit externer Autorität des Adapters, plus jeder gesalzenen Sub-PDA, den der Adapter angibt. Nicht der Nutzer. Die Rechte des Nutzers stammen aus der SPL-Delegation, die er erteilt hat.

</details>

<details>

<summary>2. Warum das USDC des Nutzers nicht mit dem Wrapper- <code>transferFrom</code>?</summary>

Die Tokens würden im Escrow-Konto des Wrappers landen und in seinem Hauptbuch verbucht werden. Der Adapter hätte kein eigenes Token-Konto, das er an dein Programm weiterreichen könnte.

</details>

<details>

<summary>3. Deine Einzahlung wächst, bis sie zehn CPIs verursacht, und Rome führt sie iterativ aus. Was passiert?</summary>

Sie schlägt fehl. Eine CPI im Legacy-Track wird in einer iterativen Transaktion abgelehnt. Reduziere die Aktion auf eine Token-Bewegung und eine CPI oder teile sie in zwei Transaktionen auf.

</details>

## Weiter

[9. Baue eine Dual-Lane-App](https://docs.rome.builders/de/rome-academy/09-build-a-dual-lane-app.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/08-open-your-solana-program-to-evm-users.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.
