> 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/erste-schritte-1/architecture.md).

# Architektur

Wie Roms Komponenten zusammenspielen — EVM-Ausführung in einem Solana-Programm.

Rome bettet einen EVM-Bytecode-Interpreter in ein On-Chain-Programm auf Solana ein. In der EVM-Schlüssellane senden Nutzer signierte EVM-Transaktionen über Standard-Ethereum-JSON-RPC an den Rome Proxy. Der Proxy leitet sie an das Rome-EVM-Programm auf Solana weiter. Eine EVM-Transaktion kann mehrere Solana-Transaktionen erfordern, um Chunks in Holder-Konten zu schreiben oder iterative Ausführung auszuführen. In der v1-Solana-Schlüssellane erstellt der Proxy die Transaktion. Die Solana-Wallet signiert sie und sendet sie direkt an die Solana-RPC. Es gibt keine separate Ausführungsschicht, die synchron gehalten werden muss — EVM-Zustand *ist* Solana-Zustand.

## Systemübersicht

<figure><img src="https://511478552-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F671PKS8ZQSNqtoC8PGvz%2Fuploads%2Fgit-blob-4d7d386c95b500079204f3dea2103d9759c5de8f%2Farchitecture.svg?alt=media" alt="EVM wallet and Solana wallet connected to Rome Proxy with its emulator. The Solana cluster holds the Rome EVM program, per-chain state, external-authority PDA, token accounts, Solana programs and holder accounts. Hercules feeds blocks, receipts and logs back to the proxy."><figcaption></figcaption></figure>

## Komponenten

### Rome EVM-Programm (on-chain)

Der Kern von Rome — ein Solana-BPF-Programm mit einem vollständigen EVM-Bytecode-Interpreter (einem Fork von SputnikVM). Es:

* Empfängt signierte EVM-Transaktionen und unsignierte EIP-1559-Bodies als Solana-Instruktionen. Ein Solana-Schlüssel autorisiert einen unsignierten Body über die Signatur des Solana-Fee-Payers oder eine Ed25519-Verifizierer-Instruktion
* Führt Solidity-Bytecode innerhalb der Solana-Runtime aus
* Ordnet jede Ethereum-Adresse (H160) einer Balance-PDA pro Chain zu, die ihre Nonce, ihren nativen Kontostand und Code enthält. Separate Storage-PDAs sind der Balance-PDA zugeordnet. Jede Adresse hat außerdem eine programmabgeleitete Adresse für Berechtigungen über Solana-Aufrufe, genannt ihre **PDA mit externer Autorität**. Diese PDA wird von jeder Chain auf dem Programm gemeinsam genutzt. Sie besitzt die SPL-Token-Konten der Adresse und signiert ihre Cross-Program-Invocations (CPIs)
* Stellt Precompiles für Aufrufe in Solana bereit (CPI, System, Helper, Withdraw) zusätzlich zu Ethereum-Precompiles. Die Cached-Familie ergänzt SystemCached (`0xff…04`), SplCached (`0xff…05`), ASplCached (`0xff…06`) und WithdrawCached (`0xff…0b`). Die Factory deployt Wrapper auf diesem Cached-Pfad
* Speichert den EVM-Zustand (Kontostände, Nonce, Code, Storage) als Solana-Account-Daten
* Ein einziges Rome-EVM-Programm hostet viele Chain-IDs. Die Chain-ID ist Teil der Balance- und Storage-PDA-Adressen, nicht der externen Autoritäts-PDA

### Rome Proxy (JSON-RPC-Server)

Der Rome Proxy ist ein standardmäßiger Ethereum-JSON-RPC-Server. Nutzer verbinden sich mit `https://hadrian.testnet.romeprotocol.xyz/` für Hadrian (Testnetz) und `https://rubicon.mainnet.romeprotocol.xyz/` für Rubicon (Mainnet). Er übersetzt Ethereum-API-Aufrufe in Solana-Aktivitäten:

* `eth_sendRawTransaction` → sendet eine oder mehrere Solana-v1-Transaktionen: atomar `DoTx`, Holder-Chunks (`TransmitTx`) plus `DoTxHolder`, oder iterative Schritte. Ein gepoolter Zahler signiert und bezahlt SOL. Ein gepoolter Fee-Empfänger sammelt das Gas des Nutzers
* `eth_call` → führt den EVM-Interpreter nativ im Emulator auf live über RPC gelesenen Solana-Konten aus. Mollusk führt die Solana-Programme aus, die über CPI erreicht werden. Es führt auch das Rome-EVM-Programm aus, wenn der Proxy Recheneinheiten misst
* `eth_estimateGas` → simuliert zur Gas-Schätzung. Eine Gaseinheit ist ein Lamport Solana-Kosten. Die Schätzung liegt nie unter 21.000
* `eth_getBalance`, `eth_getCode`, `eth_getTransactionCount`, `eth_getStorageAt` → liest live Solana-Konten über den Emulator. `eth_getBlockByNumber`, Receipts und Logs kommen von Hercules

Es stellt außerdem Rome-Erweiterungen bereit: `rome_emulateTx`, `rome_emulateRegRollup`, `rome_mintId`, `rome_buildInfo` und `rome_getResources`. Solana-Wallet-Methoden umfassen `rome_emulateCallAccounts`, `rome_composeUnsignedAtomicV1`, `rome_composeUnsignedIterativeV1`, `rome_submitSignedV1Plan`, `rome_relayUnsignedV1`, `rome_composeExternalDepositV1` und `rome_sendUnsignedTransaction`Der Proxy stellt außerdem bereit `rome_solanaTxForEvmTx`.

### Hercules (Indexer)

Hercules beobachtet das Rome-EVM-Programm auf Solana und rekonstruiert Ethereum-kompatible Blöcke in PostgreSQL. Diese enthalten Transaktionen, Receipts, Logs und Zustandsänderungen. Auf den öffentlichen Chains läuft es im slot-synchronisierten Modus, sodass eine Blocknummer auf einen Solana-Slot abgebildet wird und derselbe Slot bei jedem Indexer denselben Block ergibt. Der Proxy liefert diese Blöcke an Wallets und Explorer.

Hercules indexiert bestätigte Blöcke. Es prüft jeden Block bei Finalität erneut und lädt ihn neu, wenn sich der Blockhash geändert hat. Der [Über den Explorer](https://docs.rome.builders/de/apps-auf-rome/via.md) liest die Hercules-Daten.

### Precompiles

Rome implementiert ecrecover, SHA-256, RIPEMD-160, identity, die BN254-Kurvenoperationen und blake2f mit Ethereum-Semantik, außer für Fehlerdaten von BN254 und blake2f. Ein fehlgeschlagener BN254- oder blake2f-Aufruf gibt Roms `Error(string)` Revert-Daten statt eines leeren Puffers zurück. Modexp (`0x05`) ist deaktiviert und führt zu einem Revert mit `"big_mod_exp-Aufruf ist deaktiviert"`. blake2f verweigert mehr als 1.000.000 Runden, was Ethereum erlaubt.

Nicht-EVM-Precompiles greifen in Solana ein: **CpiProgram** (`0xFF…08`, beliebige CPI), **System** (`0xFF…07`, PDA-Ableitung und Base58-Hilfsfunktionen), **HelperProgram** (`0xFF…09`, ATA/PDA-Erstellung, SPL-Transfers, Gas↔Lamports), und **Withdraw** (`0x42…16`). Die Cached-Familie ist **SystemCached** (`0xff…04`), **SplCached** (`0xff…05`), **ASplCached** (`0xff…06` und **WithdrawCached** (`0xff…0b`). Legacy-CPIs laufen sofort und nur in atomaren Transaktionen. Cached-CPIs werden während der Ausführung aufgezeichnet und beim Commit gesendet. Sie werden mit dem EVM zurückgesetzt. Sie können in iterativen Transaktionen ausgeführt werden. Siehe die [Contract Addresses](https://docs.rome.builders/de/referenz/contract-addresses.md) Referenz für die vollständige Tabelle.

## Ausführungsmodi

Rome führt eine EVM-Transaktion auf eine von zwei Arten aus:

### Atomar (VmAt)

Eine einzige Solana-Transaktion. Die gesamte EVM-Transaktion wird innerhalb des Compute-Budgets einer Solana-Transaktion ausgeführt (\~1,4 Mio. Compute Units). Wird für die meisten Operationen verwendet — Überweisungen, gewöhnliche Vertragsaufrufe, Swaps.

### Iterativ (VmIt)

Für Arbeit, die das Budget einer einzelnen Transaktion überschreitet. Die Ausführung wird auf mehrere Solana-Transaktionen aufgeteilt:

1. Jeder Schritt (eine Solana-Transaktion) führt so viele EVM-Opcodes aus, wie in sein Compute-Budget passen — die Schrittgröße ist adaptiv, nicht fest
2. Der VM-Zustand wird per Borsh serialisiert in ein `StateHolder` Konto zwischen den Schritten
3. Konten werden während der Ausführung für einige Sekunden per TTL gesperrt

Der Proxy weicht auf iterative Ausführung aus, wenn Compute Units, Heap oder Instruktionsanzahl nicht in eine einzelne Solana-Transaktion passen. Eine Sitzung ist auf 160 Iterationen begrenzt. Ein CPI des Legacy-Pfads wird in einer iterativen Transaktion abgelehnt, da er nicht über mehrere Schritte aufgeteilt werden kann. Cached-Track-CPIs sind erlaubt.

## Kontenzuordnung

Jede Ethereum-Adresse wird deterministisch einer Solana-Balance-PDA zugeordnet, die unter dem Rome-EVM-Programm aus der Chain-ID und der Adresse abgeleitet wird. Ihr nativer Gas-Saldo ist ein Feld in dieser PDA, ebenso wie Nonce und Vertragscode. Storage-Slots liegen in separaten Storage-PDAs. SPL-Salden liegen in Token-Konten, die der separaten externen Autoritäts-PDA gehören. Diese Autorität wird von jeder Chain auf demselben Programm gemeinsam genutzt.

## Zwei Wege hinein

* **EVM-Schlüssellane:** eine Wallet sendet eine mit secp256k1 signierte EVM-Transaktion an den Rome Proxy. Der Proxy übermittelt die Solana-Transaktionen.
* **Solana-Schlüssellane:** eine Wallet autorisiert einen unsignierten EIP-1559-Body mit ihrem Solana-Schlüssel. Für den direkten v1-Pfad erstellt der Proxy die Solana-Transaktion. Die Wallet signiert sie und sendet sie direkt an die Solana-RPC. Der Relay-Pfad verwendet stattdessen den Proxy zum Übermitteln. Der ältere Legacy-Pfad lässt die Wallet eine `DoTxUnsigned` Solana-Transaktion erstellen, signieren und bezahlen, und das Programm leitet den Absender vom Solana-Signer ab.

Ein Solana-Public-Key wird der synthetischen Adresse zugeordnet `keccak256(pubkey)[12:]`, den letzten 20 Bytes des Hashs. Siehe [Wie Solana und die EVM auf Rome zusammenkommen](https://docs.rome.builders/de/kernkonzepte/how-solana-and-evm-meet.md).

## Wer einen Aufruf in Solana signiert

Das Rome-EVM-Programm signiert eine CPI mit der externen Autoritäts-PDA des unmittelbaren Aufrufers des Precompiles. Ein Vertrag signiert als er selbst. Um die SPL-Token eines Nutzers auszugeben, benötigt der Vertrag eine SPL-Delegation dieses Nutzers. Der Nutzer gewährt sie mit `HelperProgram.approve_spl(spender, amount, mint)`. Ein direkter Aufruf von der EVM- oder synthetischen Adresse des Nutzers an das Precompile verwendet die externe Autoritäts-PDA des Nutzers.

## Holder-Konten

Solana-(v1)-Transaktionen sind auf 4 KB begrenzt, aber EVM-Transaktionen (insbesondere Vertragsbereitstellungen) können viel größer sein. Rome teilt große Transaktionen in 3.600-Byte-Chunks auf und schreibt sie sequenziell in **Holder-Konten** (bis zu 80 KB). Anschließend setzt es jede Transaktion zusammen und führt sie on-chain aus. Das Rome SDK verwaltet dies transparent. Die Signaturgebühr jedes Chunks wird dem Gas des Absenders belastet.

## Gas und Preisgestaltung

Jede Chain hat ihr eigenes Gas-Token: SOL oder ein SPL-Token. Die Preisquelle ist die Hermes-API, ein Meteora-DAMM-v1-Pool, ein Meteora-DAMM-v2-Pool oder ein fester Preis. Sie liefert die Umrechnung zwischen dem Gas-Token und SOL für die zugrunde liegenden Solana-Transaktionsgebühren.

* Eine Gaseinheit ist ein Lamport Solana-Kosten
* `eth_gasPrice` ist Gas-Token-Wei pro Lamport
* Der Absender zahlt dem Fee-Empfänger aus seinem nativen Gas-Saldo. Der Proxy-Zahler bezahlt SOL
* Ohne Fee-Empfänger, wie in der atomaren Solana-Wallet-Lane, wird kein EVM-Gas berechnet. Die Wallet bezahlt SOL direkt
* Der native Kontostand hat 18 Dezimalstellen. Er wird durch Gas-Token-SPL gedeckt, die in einer programminternen Wallet pro Chain gehalten werden

## Finalität

Rome verwendet Solanas Finalität. Das SDK wartet auf `bestätigt`und lädt ihn neu, wenn sich der Blockhash geändert hat. `finalized` erneut und lädt ihn neu, wenn sich der Blockhash geändert hat.

## Was als Nächstes kommt

* [Netzwerke](https://docs.rome.builders/de/netzwerke/networks.md) — verbinde dich mit Hadrian (Testnetz) und Rubicon (Mainnet)
* [Schnellstart](https://docs.rome.builders/de/erste-schritte-1/quickstart.md) — deploye deinen ersten Contract
* [Ausführungsmodell](https://docs.rome.builders/de/kernkonzepte/execution-model.md) — atomare vs. iterative Ausführung im Detail
* [Token-Interop](https://docs.rome.builders/de/kernkonzepte/token-interop.md)
* [Beschränkungen](https://docs.rome.builders/de/kernkonzepte/constraints.md)
* [Solana aus EVM aufrufen](https://docs.rome.builders/de/entwicklerleitfaden/call-solana-from-evm.md)
* [EVM aus Solana aufrufen](https://docs.rome.builders/de/entwicklerleitfaden/call-evm-from-solana.md)
* [Precompile-Referenz](https://docs.rome.builders/de/referenz/precompiles.md)
* [Wie Solana und die EVM auf Rome zusammenkommen](https://docs.rome.builders/de/kernkonzepte/how-solana-and-evm-meet.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/erste-schritte-1/architecture.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.
