> 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/entwicklerleitfaden/call-evm-from-solana.md).

# EVM von Solana aus aufrufen

Lass eine Solana-Wallet EVM-Verträge auf Rome steuern — kein Ethereum-Schlüssel. Die Wallet signiert, und ihre Transaktion geht an Solana.

Das Gegenteil von [Solana aus EVM aufrufen](https://docs.rome.builders/de/entwicklerleitfaden/call-solana-from-evm.md): Eine Solana-Wallet (zum Beispiel Solflare) ruft jeden EVM-Contract auf Rome direkt auf, mit **keinem Ethereum-Schlüssel**. So [Aerarium](https://docs.rome.builders/de/apps-auf-rome/apps.md) können Solana-native Nutzer dieselben Contracts wie EVM-Nutzer verwenden.

Der Weg mit einem Aufruf ist das SDKs `submitRomeTxV1`, wodurch der Proxy eine Solana-v1-Transaktion für den Aufruf zusammenstellt; diese Seite erläutert die Mechanik.

## Synthetische Adressen

Die EVM-Identität einer Solana-Wallet ist ihre **synthetische Adresse** — die letzten 20 Bytes des `keccak256` ihres 32-Byte-Solana-Public-Keys:

```
synthetic_evm_address = keccak256(solana_pubkey)[12:]
```

Dies ist die `msg.sender` wenn die Wallet einen Contract aufruft, sowie die stabile Identität, unter der sich ihr Nonce und Speicher befinden. Die Ableitung ist im Protokoll festgelegt, sodass eine Wallet immer derselben Adresse zugeordnet wird.

```javascript
import { syntheticAddress } from "@rome-protocol/sdk";
const from = syntheticAddress(solanaPubkey); // 0x… 20 Bytes
```

## Das Synthetische ist ein Durchlauf — es hält keine Tokens im Ruhezustand

Das verfügbare Guthaben eines Solana-nativen Nutzers befindet sich in seinem **Solana-Wallet** (als SPL-Tokens), das auf der EVM-Seite 1:1 als das des Tokens dargestellt wird **ERC20SPL-Wrapper** (z. B. `wUSDC`). Das Synthetische hält im Ruhezustand nichts, daher fließt der Wert *durch* es — jeder Schritt mit einer Solana-Wallet signiert:

1. **Bereitstellen (einmal).** Das External-Auth-PDA eines brandneuen Synthetischen existiert erst, wenn `create_pda` ausgeführt wird — und die folgenden Übertragungen werden von diesem PDA signiert. `submitRomeTxSolanaLane` stellt es bei der ersten Verwendung automatisch bereit (oder rufe `provisionSynthetic` für einen expliziten „Aktivieren“-Schritt auf; prüfe mit `isSyntheticProvisioned`). Mit `submitRomeTxV1`, prüfe `isSyntheticProvisioned` und übermittle `buildCreatePdaCall` einmal darüber.
2. **Finanzierungsabschnitt (Wallet → Synthetisches).** Verschiebe den Token aus dem ATA der Wallet in den des Synthetischen — der `ActivateAta` Schritt, erstellt von `buildFundLeg`. Jetzt `wrapper.balanceOf(synthetic)` liest dieses Guthaben, sodass das Synthetische es als gewöhnlichen ERC-20 ausgibt (`transfer` / `transferFrom`) — **nicht** als nativen `msg.value`, den es nicht hält.
3. **Der/die Aufruf(e) (`DoTxUnsigned`).** Das Synthetische führt die EVM-Transaktion(en) aus — z. B. `approve` anschließend ein Vault- `Deposit` das über Folgendes einzieht `transferFrom`.
4. **Rückführungsabschnitt (Synthetisches → Wallet).** Nachdem ein Withdraw / Borrow / Claim Tokens im Synthetischen hinterlässt, `buildSweepLeg` überträgt sie zurück an das eigene Wallet-ATA des Nutzers (`HelperProgram.transfer_spl`), sodass das Synthetische auf null saldiert wird.

Der nächste Abschnitt beschreibt, was das ältere `submitRomeTxSolanaLane` clientseitig erstellt. `submitRomeTxV1` lässt stattdessen den Proxy eine v1-Transaktion zusammenstellen, ohne Account-Ermittlung, ComputeBudget oder Treasure-Wallet in deinem Code; siehe [die External-V1-Endpunkte](#the-external-v1-endpoints) unten.

## Wie der Aufruf erstellt wird

`submitRomeTxSolanaLane` erledigt all dies. Die Mechanik:

1. **Erstelle eine unsignierte EIP-1559-Transaktion** mit `von` = die synthetische Adresse — keine secp256k1-Signatur.
2. **Accounts ermitteln** — rufe [`rome_emulateCallAccounts`](https://docs.rome.builders/de/referenz/json-rpc.md) mit den Daten des Aufrufs `von`, `zu`, `Daten`, **und `Wert`** (wenn der Aufruf zahlbar ist). Die Übergabe von `Wert` ist wichtig: Der Proxy emuliert den *tatsächlichen* Aufruf, sodass jeder wertabhängige Speicherschreibvorgang — z. B. ein neuer Mapping-Slot — angelegt und sein Solana-Account zurückgegeben wird. Lässt du ihn weg, fehlt dieser Account und die Transaktion schlägt fehl mit *„instruction modified data of a read-only account.“*
3. **Stelle die Solana-Transaktion zusammen:** zwei **ComputeBudget** -Instruktionen (Rome EVM benötigt ein erhöhtes CU-Limit von ≈1,35 M und einen großen Heap-Frame von ≈250 KB — die Solana-Standardwerte schlagen fehl) + die **`DoTxUnsigned`** Instruktion (das unsignierte RLP + die ermittelten Accounts) + die chain-spezifische **Treasure-Wallet** (die Ausführung zahlt ihr eine geringe Gebühr; die Ermittlung lässt sie aus, daher fügt das SDK sie an).
4. **Die Wallet signiert und übermittelt.** Die **Die Solana-Wallet signiert die Solana-Transaktion (Ed25519) und sendet sie an die Solana-RPC — nicht an den Proxy.** Die Solana-Laufzeit prüft die Signatur; on-chain leitet das Programm ab `msg.sender` aus diesem Signierer. Die Berechtigung ist die Solana-Signatur, nicht eine Ethereum-Signatur. (Der Proxy wird nur für die Emulation/Ermittlung in Schritt 2 verwendet.)

Das PDA des Nutzers (`["EXTERNAL_AUTHORITY", synthetic_address]`) besitzt seine Token-Accounts und signiert SPL-CPIs in seinem Namen — sodass ein Solana-Nutzer vollständig über seine Solana-Wallet bereitstellen, leihen, swappen und LP betreiben kann.

## Die External-V1-Endpunkte

`submitRomeTxV1` ist der Weg mit einem Aufruf: Es fordert den Proxy zu einer zusammengestellten v1-Transaktion auf, prüft sie, lässt die Wallet sie signieren und sendet sie an die Solana-RPC, wobei es über den Proxy weiterleitet, wenn der Aufruf nicht passt. Der Proxy stellt denselben Pfad wie RPC-Methoden bereit, sodass jeder Client ihn ohne das SDK verwenden kann (vollständige Liste in [JSON-RPC-Unterstützung](https://docs.rome.builders/de/referenz/json-rpc.md)):

* `rome_composeUnsignedAtomicV1(rlp, pubkey, signature)` — eine Solana-v1-Transaktion; die Wallet signiert sie und die App sendet sie an die Solana-RPC. Wird abgelehnt, wenn der Aufruf nicht in eine atomare Transaktion passt.
* `rome_composeUnsignedIterativeV1(rlp, pubkey, signature)` — jeder Abschnitt der Ausführung (atomar, falls passend, andernfalls die iterativen Abschnitte); die Wallet signiert jeden, `rome_submitSignedV1Plan` übermittelt sie. Die Limits für einen langen Plan stehen in [Weitergeleitete Aufrufe und lange Aufrufe](#relayed-calls-and-long-calls).
* `rome_relayUnsignedV1(rlp, pubkey, signature)` — eine Wallet-Signatur, der Zahler des Proxys führt die Abschnitte aus und gibt den EVM-Tx-Hash zurück; das Synthetische zahlt Rome-Gas, finanziere es daher einmal mit `rome_composeExternalDepositV1`.

**Die Autorisierungssignatur.** `rlp` ist der reine unsignierte EIP-1559-Body mit 9 Feldern. Die Wallet signiert mit ihrem Ed25519-Schlüssel entweder den rohen 32-Byte- `keccak256(0x02 ‖ rlp)` oder die lesbare Nachricht

```
Rome-Autorisierung\n0x<64 kleingeschriebene Hex-Zeichen dieses Hashs>
```

Beide werden akzeptiert; die lesbare Form wird von einer Wallet in ihrem `signMessage` -Prompt lesbar dargestellt. Das Programm berechnet den Hash aus dem Body, den es ausführt, erneut und verlangt, dass die signierte Nachricht exakt eine der beiden Formen ist. Daher kann eine Signatur über einen Body niemals einen anderen autorisieren, und der Nonce des Bodys verhindert Replay-Angriffe.

## Weitergeleitete Aufrufe und lange Aufrufe

Einige Aufrufe passen nicht in eine Solana-Transaktion. Dieser Abschnitt behandelt, was dann geschieht und welche Limits gelten.

### Wenn der atomare Composer ablehnt

`rome_composeUnsignedAtomicV1` lehnt einen Aufruf ab, der nicht in eine atomare Transaktion passt. `submitRomeTxV1` leitet den Aufruf dann über den Proxy mit derselben **gleichen** Autorisierungssignatur weiter, sodass die Wallet kein zweites Mal gefragt wird. Das Ergebnis enthält `route: "relay"` und keine Solana- `Signatur`. Übergib `relayOnRefusal: false` um die Ablehnung stattdessen als Fehler zu erhalten, oder rufe `relayV1` selbst auf, um gezielt weiterzuleiten.

Drei Dinge, die du über einen weitergeleiteten Aufruf wissen solltest:

* **Das Synthetische zahlt das Gas.** Auf dem Relay-Pfad übermittelt und bezahlt der Proxy die Solana-Transaktionen, und der Aufruf wird aus dem Guthaben des Synthetischen im nativen Gas-Token der Chain bezahlt. Das Guthaben muss mindestens betragen `gasLimit × maxFeePerGas`. `fundSyntheticGas(deps, amountWei)` füllt es aus dem eigenen Token-Account der Wallet für den Gas-Token der Chain auf (USDC auf Hadrian und Rubicon); die Wallet signiert eine einfache v1-Transaktion und benötigt etwas SOL für die Solana-Gebühr. `amountWei` wird in den 18-dezimaligen Wei der Chain angegeben und muss ein Vielfaches von 10^12 sein, andernfalls lehnt der Proxy es ab. Ohne das SDK `rome_composeExternalDepositV1` erstellt dieselbe Transaktion.
* **Ein Revert löst keinen Fehler aus.** Ein weitergeleiteter Aufruf, der auf der EVM-Seite revertiert, wird normal aufgelöst, mit `receipt.status === "0x0"`. Prüfe `receipt?.status === "0x1"` bevor du den Aufruf als abgeschlossen behandelst. `receipt` ist `null` falls der Beleg nicht rechtzeitig erschien.
* **`relayOnRefusal: false` ist eine im SDK getroffene Wahl, keine Sperre.** Der Proxy besitzt bereits die Autorisierungssignatur für diese Nutzlast und kann sie über jeden der beiden Wege ausführen, bis zu `gasLimit × maxFeePerGas`.

```javascript
const res = await submitRomeTxV1(deps, { to, data, value });
if (res.route === "relay" && res.receipt?.status !== "0x1") {
  // ein weitergeleiteter Aufruf, der revertiert, wird aufgelöst; er löst keinen Fehler aus
}
```

### Lange Aufrufe

Ein Aufruf, der mehr als eine Transaktion benötigt, läuft als iterative Sitzung: Das Programm führt so viele EVM-Schritte aus, wie in jede Solana-Transaktion passen, und speichert seinen Zustand dazwischen. Zwei Wege, ihn über eine Solana-Wallet auszuführen:

* **Leite ihn weiter.** `rome_relayUnsignedV1` nimmt eine Wallet-Signatur und der Zahler des Proxys sendet jeden Abschnitt. Das Synthetische zahlt das Gas, wie oben.
* **Signiere die Abschnitte selbst.** `rome_composeUnsignedIterativeV1` gibt jeden Abschnitt mit einem leeren Signatur-Slot zurück, die Wallet signiert jeden einzelnen, und `rome_submitSignedV1Plan` übermittelt sie der Reihe nach. Jeder Abschnitt ist eine separate Solana-Transaktion, die die Wallet signieren muss. Daher zeigt eine Wallet, die jeweils eine Transaktion signiert, zusätzlich zur Autorisierungssignatur für jeden Abschnitt eine Abfrage an. Die Wallet zahlt die Solana-Gebühr für jeden Abschnitt.

Die Limits:

| Limit                                                   | Wert              | Herkunft                                                                                                                          |
| ------------------------------------------------------- | ----------------- | --------------------------------------------------------------------------------------------------------------------------------- |
| Transaktionen in einem `rome_submitSignedV1Plan` Aufruf | 64                | Der Proxy lehnt einen längeren Plan ab                                                                                            |
| Abschnitte, die der iterative Composer plant            | 128               | Die Obergrenze im iterativen Composer des Rust-Rome-SDKs, die auch den Plan begrenzt `rome_composeUnsignedIterativeV1` zurückgibt |
| Iterationen in einer Sitzung                            | 160               | Das Rome-EVM-Programm; danach setzt die Sitzung ihre Ausführung nicht mehr fort, gibt ihre Account-Sperren frei und endet         |
| Größe und Accounts der Solana-Transaktion               | 4 KB, 64 Adressen | Jeder Abschnitt ist eine Solana-v1-Transaktion                                                                                    |

Die meisten realen Aufrufe werden in weitaus weniger Abschnitten als diesen Obergrenzen abgeschlossen. Das Limit von 64 Transaktionen bei einem von der Wallet signierten Plan ist dasjenige, auf das du zuerst stoßen wirst. Ein Aufruf, der mehr Abschnitte benötigt, kann nicht über Folgendes übertragen werden `rome_submitSignedV1Plan`.

Ein langer Aufruf kann keine CPIs des Legacy-Tracks durchführen. Ändernde Aufrufe an den Legacy-Precompiles (`0xff…08`, `0xff…09` und `0x42…16`) werden in einer iterativen Sitzung mit Folgendem abgelehnt `CpiProhibitedInIterativeTx`. Lesezugriffe auf den Solana-Zustand und die Cached-Track-Precompiles (`0xff…04`, `0xff…05`, `0xff…06`, `0xff…0b`) funktionieren. Ein Aufruf, der Legacy-Track-CPIs durchführt, muss in eine atomare Transaktion passen, unabhängig davon, welcher Pfad ihn sendet. Siehe [Beschränkungen](https://docs.rome.builders/de/kernkonzepte/constraints.md) und [Compute-Budget](https://docs.rome.builders/de/kernkonzepte/compute-budget.md).

## Referenzimplementierungen

* **Aerarium** — steuert Compound v3 (Supply / Borrow) von einer Solana-Wallet über `DoTxUnsigned`. Es ist die Referenz für den oben beschriebenen älteren Pfad für Legacy-Transaktionen, nicht für `submitRomeTxV1`.
* **Rome DEX** ist kein Beispiel für diese Seite: Seine Solana-Seite ist ein natives Solana-Programm, das die Wallet direkt signiert, und seine EVM-Seite teilt denselben Pool.

Aerarium benötigt keine zweite Wallet — die synthetische Adresse macht einen Solana-Schlüssel zu einem vollwertigen EVM-Account. Für das v1-Muster folge [Eine Dual-Lane-App bauen](https://docs.rome.builders/de/entwicklerleitfaden/dual-lane-app.md).

## Wie es weitergeht

* [Solana aus EVM aufrufen](https://docs.rome.builders/de/entwicklerleitfaden/call-solana-from-evm.md) — die andere Richtung, über CPI
* [Token-Interop](https://docs.rome.builders/de/kernkonzepte/token-interop.md) — wie Guthaben zwischen EVM und Solana geteilt werden


---

# 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/entwicklerleitfaden/call-evm-from-solana.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.
