> 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/04-how-rome-runs-your-code.md).

# 4. Wie Rome deinen Code ausführt

Wie aus einer Rome-Transaktion Solana-Transaktionen werden, warum die meisten Aufrufe atomar laufen und was sich ändert, wenn ein Aufruf zu groß ist.

Dein Solidity-Code läuft unverändert. Was sich ändert, ist der Ort, an dem er läuft: in einem Solana-Programm, unter Solanas Grenzen. Diese Lektion gibt dir das Bild, das du brauchst, um vorherzusagen, was ein Aufruf kostet und wann er fehlschlägt.

## Was du lernen wirst

* Der Weg, den eine Transaktion von deiner Wallet zu einem Solana-Validator und zurück zu einem EVM-Beleg nimmt.
* Der Unterschied zwischen atomarer und iterativer Ausführung und warum du atomar willst.
* Welche Solana-Grenzen deinen Solidity-Code betreffen: Compute, Größe, Anzahl der Accounts, Sperren.
* Wie du misst, was ein Aufruf wirklich kostet.

## Bevor du beginnst

* Abschluss [3. Dein erster Contract auf Hadrian](https://docs.rome.builders/de/rome-academy/03-first-contract-on-hadrian.md). Du brauchst einen bereitgestellten Vertrag und eine Transaktion, die du an ihn gesendet hast.
* Halte diesen Transaktions-Hash griffbereit. Du wirst ihn am Ende dieser Lektion im Explorer öffnen.

## Der Weg einer Transaktion

Du signierst eine gewöhnliche EVM-Transaktion und sendest sie mit `eth_sendRawTransaction`. Der Proxy leitet sie noch nicht weiter. Zuerst führt er den Aufruf off-chain in einem Emulator aus, der dieselbe EVM-Logik wie das On-Chain-Programm ausführt. Die Emulation sagt ihm drei Dinge: wie viel Gas der Aufruf braucht, welche Solana-Accounts der Aufruf berührt und ob der Aufruf in eine Solana-Transaktion passt.

Dann verpackt der Proxy deinen Aufruf als Solana-Instruktionen und sendet sie. Das Rome-EVM-Programm, ein normales Solana-Programm, interpretiert deinen Bytecode. Zustandsänderungen landen in Solana-Accounts. Ein Indexer liest das Ergebnis und erzeugt den EVM-Block und -Beleg, den deine Tools erwarten.

Jede EVM-Adresse wird einem Solana-Account zugeordnet, der dem Rome-Programm gehört. Der Saldo, der Nonce, der Code und der Speicher deines Vertrags sind alles Solana-Accounts. Deshalb muss der Proxy die Account-Liste kennen, bevor er sendet: Solana verlangt, dass jeder Account im Voraus benannt wird.

Lies den vollständigen Lebenszyklus in [Ausführungsmodell](https://docs.rome.builders/de/kernkonzepte/execution-model.md).

## Zuerst atomar

Die meisten Aufrufe laufen in einer Solana-Transaktion. Rome nennt das atomare Ausführung (VmAt). Sie ist ganz oder gar nicht: Wenn ein Schritt fehlschlägt, wird der gesamte Aufruf zurückgesetzt. Eine Überweisung, ein Swap und die meisten DeFi-Aufrufe passen hinein. Einige nicht: Für eine Aave-Ausleihe auf Hadrian waren mehr als eine Solana-Transaktion nötig.

Ein atomarer Aufruf hat ein Budget von etwa 1,4 Mio. Compute Units. Diese Grenzen prägen jeden Aufruf:

| Limit          | Was das für dich bedeutet                                                                                                                                      |
| -------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Compute        | Etwa 1,4 Mio. CU, die sich die EVM-Arbeit und jedes aufgerufene Programm teilen                                                                                |
| Accounts       | 64 Adressen, einschließlich der eigenen Accounts von Rome und allem, was deine CPIs berühren                                                                   |
| Größe          | 4 KB pro Solana-Transaktion; größere EVM-Payloads, etwa große Deployments, werden über ein Holder-Konto zwischengeschaltet, und das SDK übernimmt das für dich |
| Contract-Größe | 24 KB, wie auf Ethereum                                                                                                                                        |

Die vollständige Liste mit den Werten steht in [Beschränkungen](https://docs.rome.builders/de/kernkonzepte/constraints.md).

## Iterativ, wenn ein Aufruf zu groß ist

Wenn der Emulator feststellt, dass ein Aufruf nicht passt, führt Rome ihn iterativ aus (VmIt). Der Aufruf wird in Etappen aufgeteilt. Jede Etappe ist ihre eigene Solana-Transaktion und führt so viele Opcodes aus, wie ihr Compute-Budget erlaubt. Zwischen den Etappen wird der VM-Zustand in einem Holder-Konto gespeichert, und die nächste Etappe übernimmt ihn.

Iterative Ausführung funktioniert, hat aber ihren Preis:

* Eine Sitzung endet nach 160 Etappen. Danach gibt sie ihre Sperren frei und schreibt nichts fest.
* Die Sitzung sperrt ihre Balance- und Storage-Accounts für ein paar Sekunden; jede Etappe verlängert sie. Ein atomarer Schreibzugriff auf einen gesperrten Account wird mit `AccountLocked`abgewiesen, und der Client sendet erneut.
* Aufrufe, die auf dem Legacy-Pfad Solana-CPIs ausführen (die `CpiProgram` und `HelperProgram` Aufrufe aus Lektion 5) können überhaupt nicht iterativ ausgeführt werden. Sie müssen atomar passen.
* Auf dem Solana-Pfad fordert eine Wallet, die ihre eigenen Etappen signiert, den Nutzer einmal pro Etappe zur Bestätigung auf.

Daraus folgt die Designregel: Gestalte jede Benutzeraktion so, dass sie in eine atomare Transaktion passt. Wenn ein Ablauf größer ist, teile ihn lieber in zwei Benutzeraktionen auf, statt dich auf den iterativen Modus zu verlassen. Lektion 5 kommt darauf zurück, wenn du Solana-Programme aufrufst.

## Was du zahlst

Rome berechnet die Kosten eines Aufrufs in Solana-Lamports: Signaturgebühren, eine feste Gebühr, Miete für jeden Account, den der Aufruf erzeugt. Eine Gas-Einheit steht für einen Lamport Kosten. Der Gas-Preis wandelt das in den Gas-Token der Chain um, der auf Hadrian und Rubicon USDC ist.

Die Miete ist der Teil, der Leute überrascht. Die erste Überweisung an eine Adresse, die noch nie verwendet wurde, erzeugt Accounts und kostet deshalb weit mehr als eine wiederholte Überweisung. Rechne beim ersten Zugriff mit hohem Gas und danach mit normalem Gas. Die durchgerechneten Zahlen stehen in [Wie Solana und die EVM auf Rome zusammenkommen](https://docs.rome.builders/de/kernkonzepte/how-solana-and-evm-meet.md#gas-and-rent).

## Messen, nicht raten

EVM `gasUsed` ist kein verlässlicher Ersatz für Solana-Compute. Auf Rome ist eine Gas-Einheit ein Lamport Kosten, also `eth_estimateGas` dimensioniert dein Gas-Limit, sagt dir aber nichts über Compute Units. Lies Compute von der Solana-Seite aus. Via verlinkt die Solana-Transaktion aus ihrer Zeile „Abgewickelt in“, und der Solana-Explorer zeigt ihre Compute Units. Im Code erhältst du die Solana-Signaturen hinter einem EVM-Hash mit `rome_solanaTxForEvmTx`, rufst jede mit Solanas `getTransaction` und `maxSupportedTransactionVersion: 1`, und liest `computeUnitsConsumed`. Ein iterativer Aufruf hat pro Etappe eine Transaktion. [Compute-Budget](https://docs.rome.builders/de/kernkonzepte/compute-budget.md) hat typische Kosten pro Operation und die sparsamen Gewohnheiten, die sie senken: Konstanten für Programm-IDs, zwischengespeicherte PDA-Ableitungen, weniger Accounts.

Zwei Verhaltensweisen unterscheiden sich von Ethereum und sind jetzt wissenswert:

* Rome hat keinen Gaszähler pro Opcode. Das Gas, das du an einen `CALL` schickst, wird nicht durchgesetzt, und es gibt kein 2300-Gas-Stipendium. Schütze dich ausdrücklich vor Reentrancy.
* `block.number` ist der Solana-Slot und `block.timestamp` ist die Solana-Uhr.

## Prüfe dich selbst

Öffne deine Transaktion aus Lektion 3 im Hadrian-Explorer. Finde den Netzwerk-Link in [Hadrian](https://docs.rome.builders/de/netzwerke/hadrian.md) und die Explorer-Notizen in [Über den Explorer](https://docs.rome.builders/de/apps-auf-rome/via.md).

Beobachte zwei Dinge:

1. Die Solana-Transaktion, die deinen Aufruf abgewickelt hat, aus der Zeile „Abgewickelt in“.
2. Die Compute Units, die sie verbraucht hat, im Solana-Explorer.

Vergleiche diese Zahl mit dem 1,4-Mio.-Budget. Ein einfacher Aufruf verbraucht nur einen kleinen Teil davon.

Dann beantworte:

<details>

<summary>1. Warum emuliert der Proxy einen Aufruf, bevor er ihn sendet?</summary>

Solana braucht jeden Account im Voraus benannt, und der Proxy muss wissen, ob der Aufruf in eine Transaktion passt. Die Emulation findet die berührten Accounts, schätzt das Gas und entscheidet, ob atomar oder iterativ.

</details>

<details>

<summary>2. Ein Aufruf führt eine CPI auf dem Legacy-Pfad aus (die `CpiProgram`- und `HelperProgram`-Aufrufe aus Lektion 5) und braucht mehr als 1,4 Mio. CU. Was passiert?</summary>

Er kann nicht ausgeführt werden. CPIs auf dem Legacy-Pfad werden innerhalb einer iterativen Transaktion abgewiesen, also muss der Aufruf in eine atomare Transaktion passen. Teile die Arbeit in kleinere Benutzeraktionen auf.

</details>

<details>

<summary>3. Warum ist die erste Überweisung an eine neue Adresse teuer?</summary>

Rome erstellt dafür Solana-Accounts, und die Miete für diese Accounts wird dem Absender als Gas berechnet.

</details>

## Weiter

[5. Rufe Solana aus Solidity auf](https://docs.rome.builders/de/rome-academy/05-call-solana-from-solidity.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/04-how-rome-runs-your-code.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.
