> 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/05-call-solana-from-solidity.md).

# 5. Rufe Solana aus Solidity auf

Nutze Roms CPI- und Helper-Precompiles, um Solana-Konten auszulesen, Token-Konten zu erstellen und Solana-Programme aus einem Solidity-Vertrag aufzurufen.

Auf Rome kann ein Solidity-Contract Solana-Konten lesen und Solana-Programme in derselben Transaktion aufrufen. Du wirst einen Solana-Token-Saldo lesen, ein Token-Konto erstellen und lernen, wie man einen Programmaufruf baut.

## Was du lernen wirst

* Was ein Precompile auf Rome ist und welche drei du am häufigsten verwenden wirst.
* Welche Signatur ein Solana-Programm sieht, wenn dein Contract es aufruft.
* Wie man Solana-State liest und aus Solidity ein Token-Konto erstellt.
* Die Regeln, die entscheiden, ob ein Solana-Aufruf funktioniert: deklarierte Konten, ein Track, nur atomar.

## Bevor du beginnst

* Abschluss [4. Wie Rome deinen Code ausführt](https://docs.rome.builders/de/rome-academy/04-how-rome-runs-your-code.md). Das atomare Budget und das 64-Konten-Limit spielen hier eine Rolle.
* Sorge dafür, dass dein Hadrian-Wallet aufgeladen ist und dein Deploy-Setup aus Lektion 3 funktioniert. Faucets sind aufgeführt in [Faucets](https://docs.rome.builders/de/ressourcen/faucets.md).
* Installiere die Rome-Solidity-Interfaces aus dem `rome-solidity` Repository, wie in [Solidity bereitstellen](https://docs.rome.builders/de/entwicklerleitfaden/deploy-solidity.md#using-the-rome-solidity-sdk).

## Precompiles sind die Tür

Ein Precompile ist eine feste Adresse, die nativen Code statt Bytecode ausführt. Ethereum hat einige, wie zum Beispiel `ecrecover`. Rome fügt Precompiles hinzu, deren Aufgabe es ist, Solana zu erreichen. Du rufst sie wie jeden anderen Contract über eine Schnittstelle auf.

Du wirst drei verwenden:

| Precompile    | Was es dir gibt                                                                                                      |
| ------------- | -------------------------------------------------------------------------------------------------------------------- |
| CpiProgram    | `invoke` und `invoke_signed` um jedes Solana-Programm aufzurufen, plus schreibgeschützte Ansichten von Solana-Konten |
| HelperProgram | Fertige Token- und Kontooperationen: ein Token-Konto erstellen, SPL-Token übertragen, Adressen ableiten              |
| System        | PDA-Ableitung und Base58-Konvertierung                                                                               |

Die Adressen befinden sich in [Precompile-Referenz](https://docs.rome.builders/de/referenz/precompiles.md) und [Vertragsadressen](https://docs.rome.builders/de/referenz/contract-addresses.md). Du musst sie nicht eintippen. Das Importieren von `interface.sol` von `rome-solidity` gibt dir fertige Konstanten mit den Namen `CpiProgram`, `HelperProgram` und `SystemProgram`.

## Wer signiert

Wenn dein Contract ein Precompile aufruft, sieht Solana die eigene Identität deines Contracts, nicht die des Users. Jede EVM-Adresse hat eine von Solana abgeleitete Programmadresse, ihr External-Authority-PDA. Sie besitzt die Token-Konten dieser Adresse und signiert in ihrem Namen.

Das ist dieselbe Regel, die du von ERC-20 kennst: Ein Contract kann die Vermögenswerte eines Users nicht bewegen, es sei denn, der User hat es erlaubt. Lektion 6 zeigt, wie der User das auf Rome erlaubt. Die Regel und die drei Möglichkeiten, die Position eines Users zu halten, sind in [Integrieren Sie ein Solana-Programm](https://docs.rome.builders/pages/efd1c176728a1a4534ac7d3a596931b458c2e34f#id-1.-every-evm-address-has-one-solana-identity).

## Schritt 1: Lesen, bevor du schreibst

Beginne mit Lesezugriffen. Sie ändern keinen Zustand und funktionieren in atomarer und iterativer Ausführung. Lies, bevor du mutierst: Sobald ein gecachter Aufruf ausgeführt wurde, werden Legacy-Track-Lesezugriffe für den Rest der Transaktion abgelehnt.

```solidity
import "@rome-protocol/rome-solidity/contracts/interface.sol";

contract SolanaPeek {
    // Das Token-Konto, das Rome für den Aufrufer und den Gas-Mint der Chain verwendet
    function myTokenAccount() external view returns (bytes32) {
        return HelperProgram.ata(msg.sender, SystemProgram.mint_id());
    }

    // Der Kontostand des Aufrufers in diesem Konto
    function myBalance() external view returns (uint64) {
        return HelperProgram.user_balance(msg.sender, SystemProgram.mint_id());
    }
}
```

Solana-Adressen sind `bytes32` hier und keine 20-Byte-Adressen. Die anderen Lesezugriffe, `account_info`, `account_data_at` und `account_u64_at`, ermöglichen dir, jedes Solana-Konto zu prüfen. Siehe [Kontodaten lesen](https://docs.rome.builders/de/entwicklerleitfaden/call-solana-from-evm.md#reading-account-data).

## Schritt 2: Verwende einen Helper

Für häufige Aufgaben brauchst du keine selbst gebaute Instruktion. Der Helper erstellt Token-Konten, bewegt SPL-Token und Lamports und konvertiert zwischen Gas und Lamports. Die Signaturen sind in `contracts/interface.sol`, und ein ausgearbeiteter Contract ist in [Lamports übertragen](https://docs.rome.builders/de/entwicklerleitfaden/call-solana-from-evm.md#transfer-lamports).

```solidity
function createMyAta() external {
    HelperProgram.create_ata(msg.sender, SystemProgram.mint_id());
}
```

Ein Contract, der den Helper aufruft, handelt als er selbst. Die Token, die er bewegt, gehören ihm selbst und nicht dem User.

## Schritt 3: Rufe jedes Solana-Programm auf

Für ein Programm, das die Helpers nicht abdecken, erstellst du die Kontenliste und die Instruktionsbytes selbst und rufst `invoke`. Jedes Konto ist ein Pubkey plus zwei Flags, signer und writable. Die Instruktionsdaten sind alles, was das Zielprogramm erwartet, normalerweise Borsh.

Der vollständige Contract ist in [Benutzerdefinierte Solana-Programme aufrufen](https://docs.rome.builders/de/entwicklerleitfaden/call-solana-from-evm.md#calling-custom-solana-programs). `invoke_signed` fügt gesalzene Sub-PDAs hinzu, wenn das Ziel mehr als einen Signer von deinem Contract benötigt. Um die Adresse eines PDAs innerhalb von Solidity zu erhalten, verwende `find_program_address` auf dem System-Precompile; siehe [PDA-Ableitung](https://docs.rome.builders/de/entwicklerleitfaden/call-solana-from-evm.md#pda-derivation).

## Die Regeln, die entscheiden, ob es funktioniert

* **Deklariere jedes Konto.** Solana benötigt die vollständige Kontenliste, bevor der Aufruf ausgeführt wird. Der Proxy findet sie, indem er deine Transaktion zuerst emuliert, daher muss jedes Konto aus Eingaben ableitbar sein, die der Contract hat. Die Gesamtzahl muss innerhalb des 64-Adressen-Limits bleiben.
* **Bleib atomar.** Ein Aufruf, der eine Legacy-Track-CPI ausführt, kann nicht iterativ laufen. Er muss in eine einzige atomare Transaktion passen, also beschränke jede Aktion auf eine Token-Bewegung und eine CPI.
* **Wähle einen Track.** Rome hat zwei Familien von Precompiles, die Solana-Zustand ändern: Legacy (`CpiProgram`, `HelperProgram`, `Withdraw`) und Cached (die `...Cached` Menge). Eine Transaktion verwendet eine Familie. Nur der Legacy-Track kann ein benutzerdefiniertes Programm aufrufen. Lies die Tabelle in [Integrieren Sie ein Solana-Programm](https://docs.rome.builders/pages/efd1c176728a1a4534ac7d3a596931b458c2e34f#id-4.-one-track-per-contract-and-per-transaction).
* **Halte die Tiefe flach.** Dein Aufruf eines Solana-Programms verwendet CPI-Ebenen, und ebenso jedes Programm, das es seinerseits aufruft. Das Tiefenlimit von Solana ist niedrig. [Beschränkungen](https://docs.rome.builders/de/kernkonzepte/constraints.md#cpi-constraints) erklärt die Ebenen.
* **Keine Aufrufe zurück nach Rome.** Eine CPI kann das Rome-Programm weder benennen noch aufrufen. Sie kann den Solana-Fee-Payer nur in einer einfachen System-Transfer-Instruktion benennen.

## Prüfe dich selbst

Füge `createMyAta` zu `SolanaPeek` und deploye es auf Hadrian. Dann:

1. Rufe `myTokenAccount` und `myBalance` mit einem Leseaufruf von deiner Wallet-Adresse aus.
2. Sende eine Transaktion, die aufruft `createMyAta`.
3. Öffne die Transaktion im Hadrian-Explorer. Siehe [Über den Explorer](https://docs.rome.builders/de/apps-auf-rome/via.md).

Du solltest die Solana-Instruktion hinter deinem Aufruf und ihre Compute Units sehen. Ein Aufruf, der Solana erreicht, zeigt im Explorer ein Solana-Programm und nicht nur einen EVM-Aufruf.

<details>

<summary>1. Ein Contract ruft auf <code>HelperProgram.transfer_spl</code>. Dessen Token werden bewegt?</summary>

Die des Contracts selbst. Der Signer ist das External-Authority-PDA des Contracts. Um die Token eines Users zu bewegen, muss der User zuerst ein Recht gewähren.

</details>

<details>

<summary>2. Warum muss ein Aufruf, der <code>invoke</code> in eine einzige atomare Transaktion passen?</summary>

Legacy-Track-CPIs werden innerhalb einer iterativen Transaktion abgelehnt. Wenn der Aufruf mehr als eine Solana-Transaktion benötigt, schlägt er fehl.

</details>

<details>

<summary>3. Auf welche Lesezugriffe kannst du dich in jedem Ausführungsmodus verlassen?</summary>

Die schreibgeschützten Ansichten: `account_info`, `account_data_at`, `account_u64_at`, `account_lamports`, `pdas_batch_derive` und die Helper-Lesezugriffe wie `user_balance`. Sie haben keine Seiteneffekte. Führe sie vor jeder gecachten Mutation in derselben Transaktion aus.

</details>

## Weiter

[6. Token auf beiden Seiten](https://docs.rome.builders/de/rome-academy/06-tokens-on-both-sides.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/05-call-solana-from-solidity.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.
