> 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/kernkonzepte/how-solana-and-evm-meet.md).

# Wie Solana und die EVM sich auf Rome treffen

Wie Solana-Wallets Solidity-Verträge aufrufen, EVM-Adressen Solana-Programme aufrufen und Rome Identität, Token, Gebühren und Ausführungsgrenzen handhabt.

Diese Seite erklärt, wie Aufrufe zwischen Solana und der EVM auf Rome übergreifen. Sie behandelt, wer signiert, wo sich Token befinden, wer zahlt und welche Solana-Regeln Solidity-Verträge beeinflussen.

Sofern nicht anders angegeben, stammen die Zahlen und Transaktionen auf dieser Seite von Hadrian (Testnet) vom 19. Oktober 2026.

## Was ist eine synthetische Adresse?

Eine synthetische Adresse ist die EVM-Identität eines Solana Public Keys. Rome berechnet sie als die letzten 20 Bytes von `keccak256` des Public Keys: `keccak256(pubkey)[12..32]`. Das Mapping ist fest. Es heißt synthetisch, weil niemand dafür einen secp256k1-Schlüssel besitzt: MetaMask kann dafür nicht signieren, und nur der Solana-Schlüssel kann Aufrufe von ihr autorisieren.

Beim Contract-Aufruf auf oberster Ebene sind sowohl `msg.sender` und `tx.origin` die synthetische Adresse. Rome speichert die EVM-Nonce unter dieser Adresse. Der Contract kann diese Identität über diese Felder nicht von einem MetaMask-Nutzer unterscheiden.

## Wie ruft ein Solana-Nutzer einen Solidity-Vertrag auf?

Die Wallet autorisiert einen unsigned EIP-1559-Aufruf über einen von zwei Pfaden. Der v1-Pfad ist der aktuelle Weg. Der Legacy-Pfad ist der ältere Weg: Die Wallet signiert und bezahlt die Solana-Transaktion, die `DoTxUnsigned`enthält, und das Rome-EVM-Programm leitet daraus die synthetische Adresse des Solana-Signierers ab.

Im v1-Pfad signiert die Wallet eine lesbare Nachricht, die `Rome-Autorisierung`, einen Zeilenumbruch und den Call-Hash als `0x` enthält, gefolgt von 64 Kleinbuchstaben-Hexziffern. Die Transaktion trägt diese Signatur in einer Ed25519-Verifikationsanweisung an Index 0. Das Rome-EVM-Programm leitet die synthetische Adresse aus dem Schlüssel ab, der den Aufruf autorisiert hat.

Der Rome Proxy setzt die v1-Transaktion zusammen. Die Wallet signiert sie dann und sendet sie an Solana. Auf dem Relay-Pfad übermittelt der Rome Proxy die Transaktion und bezahlt SOL, und die synthetische Adresse zahlt Gas aus ihrem nativen Guthaben in dem Gas-Token der Chain (USDC auf Hadrian und Rubicon).

Wenn die Wallet direkt zahlt, kostet der v1-Pfad 15.000 Lamports: eine Signaturgebühr von 5.000 Lamports, 5.000 Lamports für die Ed25519-Verifikationssignatur und eine Treasury-Abgabe von 5.000 Lamports. Der ältere Legacy- `DoTxUnsigned` Pfad hat keine Ed25519-Anweisung und kostet 10.000 Lamports. Beide Wege zahlen außerdem Miete für alle erstellten Accounts. Kein direkter Weg berechnet EVM-Gas. Eine Legacy-Pfad-Transaktion auf Hadrian kostete die Wallet 10.000 Lamports und meldete `gasUsed = 0` und `effectiveGasPrice = 0`.

Des SDKs `submitRomeTxV1` folgt diesen Schritten:

1. Lese die Nonce der synthetischen Adresse mit `eth_getTransactionCount`, schätze das Gas und baue den unsigned Aufruf.
2. Bitte die Wallet, die lesbare `Rome-Autorisierung` Nachricht zu signieren.
3. Fordere eine Transaktion von `rome_composeUnsignedAtomicV1`.
4. an.
5. Verifiziere den zurückgegebenen Zahler, die Call-Bytes, die Ed25519-Autorisierung, die zulässigen Programme und das Fehlen einer Prioritätsgebühr.
6. Bitte die Wallet, die v1-Transaktion zu signieren, sie an Solana zu senden und den Rome Proxy nach dem EVM-Beleg abzufragen. `rome_relayUnsignedV1` weiter, unter Verwendung derselben Autorisierungssignatur.

Verwenden Sie `fundSyntheticGas` um das native Guthaben zu finanzieren, das für ein Relay oder `msg.value`. Es legt den Gas-Token aus dem Token-Konto der Wallet ein und schreibt dem nativen Guthaben der synthetischen Adresse gut. Native Guthaben verwenden 18 Dezimalstellen.

Um Token in einem Vertrag zu verwenden, finanziert das SDK die synthetische Adresse, ruft den Vertrag auf und gibt alle verbleibenden Token zurück. `buildFundLeg` verwendet `ActivateAta` um Token von der Wallet in das Token-Konto der synthetischen Adresse zu verschieben. Der Solidity-Aufruf verwendet diese Token über einen Wrapper. `buildSweepLeg` verwendet `transfer_spl` um die verbleibenden Token an die Wallet zurückzusenden.

Die Wallet muss das Signieren von Solana-v1-Transaktionen unterstützen. Solflare unterstützt dies auf dem Solana-Devnet; Phantom noch nicht. Jeder Aufruf prüft und inkrementiert die EVM-Nonce unter der synthetischen Adresse, um Replay zu verhindern.

Siehe [EVM aus Solana aufrufen](https://docs.rome.builders/de/entwicklerleitfaden/call-evm-from-solana.md), [Eine Dual-Lane-App bauen](https://docs.rome.builders/de/entwicklerleitfaden/dual-lane-app.md), und [Rome SDK](https://docs.rome.builders/de/produkte/rome-sdk.md).

## Wie ruft ein EVM-Nutzer oder ein Vertrag ein Solana-Programm auf?

Jede EVM-Adresse hat eine von Solana abgeleitete Programmadresse, die ihre Token-Konten besitzt und Aufrufe an Solana-Programme signieren kann. Das ist ihre PDA mit externer Autorität. Das Rome-EVM-Programm leitet sie aus dem Seed `EXTERNAL_AUTHORITY` gefolgt von der EVM-Adresse ab. Die Seeds enthalten keine Chain-ID, daher teilen sich Chains, die vom selben Rome-EVM-Programm gehostet werden, diese Autorität.

Ein Nutzer oder Vertrag ruft das CPI-Precompile unter `0xFF…08` mit der Ziel-Programm-ID, der Account-Liste und den Instruction-Bytes auf. CPI bedeutet Cross-Program Invocation. Das Precompile ruft das Solana-Programm innerhalb derselben Solana-Transaktion auf.

`invoke` signiert für die externe Autoritäts-PDA des Aufrufers, wenn die Account-Liste sie als Signer markiert. `invoke_signed` unterstützt auch PDAs, die mit Salts abgeleitet werden. Jede gesaltete PDA muss in der Account-Liste als Signer erscheinen.

Die Methoden `account_info`, `account_data_at`, `account_u64_at`, `account_lamports`, und `pdas_batch_derive` sind nur schreibgeschützte Hilfsfunktionen. Sie rufen kein Solana-Programm auf.

Das Precompile lehnt Aufrufe ab, die auf das Rome-EVM-Programm selbst zielen. Es lehnt auch eine Account-Liste ab, die die Program-ID des Rome-EVM-Programms enthält. Eine CPI darf den Solana-Fee-Payer nicht benennen, außer in einer einfachen System- `Transfer` Anweisung.

Ein Swap mit RomeDexRouter 2.0.0 auf Hadrian verlief in diesen Schritten:

1. Der Router rief `HelperProgram.create_ata` auf, um sicherzustellen, dass das Ausgabe-Token-Konto des Nutzers existierte.
2. Er leitete die Eingabe- und Ausgabe-Token-Konten des Nutzers ab und markierte seine eigene PDA mit externer Autorität als Signer.
3. Er rief `CPI.invoke` mit dem Solana-Swap-Programm, der Account-Liste und den Swap-Instruction-Bytes auf.
4. SPL Token verschob Token vom Konto des Nutzers in den Pool und gab Ausgabe-Token an das andere Konto des Nutzers zurück. Die PDA des Routers signierte als der SPL-Delegate des Nutzers. Der Router hielt keine Token.
5. Der Router prüfte den empfangenen Betrag mit `CPI.account_u64_at(dstAta, 64)`.
6. Der Beleg meldete 10.001 Gas: `5,000 + 5,000 + 1 = 10,001` Lamports Solana-Kosten. Diese Kosten waren die Signaturgebühr, die Treasury-Abgabe und die Prioritätsgebühr. Der Rome Proxy zahlte SOL, und der Nutzer zahlte Gas in USDC.

Siehe [Solana aus EVM aufrufen](https://docs.rome.builders/de/entwicklerleitfaden/call-solana-from-evm.md), [Integrieren Sie ein Solana-Programm](https://docs.rome.builders/de/entwicklerleitfaden/integrate-solana-program.md), und der [Precompile-Referenz](https://docs.rome.builders/de/referenz/precompiles.md).

## Wer signiert, wenn ein Vertrag ein Solana-Programm aufruft?

Rome signiert mit der PDA mit externer Autorität des unmittelbaren Aufrufers des Precompiles. Ein Vertrag signiert daher als er selbst. Nur ein Aufruf, der direkt von der eigenen EVM- oder synthetischen Adresse des Nutzers an das Precompile gesendet wird, signiert mit der PDA des Nutzers.

Damit ein Router oder Adapter die Token eines Nutzers bewegen kann, ruft der Nutzer `approve_spl(spender, amount, mint)`auf. Dadurch wird die PDA mit externer Autorität des Vertrags als SPL-Delegate des Token-Kontos des Nutzers gesetzt. Das ist Romans Version von ERC-20 `approve`.

Unter `DELEGATECALL`, verweigert das Precompile die nackte PDA mit externer Autorität als Signer. Gesaltete Autoritäten beziehen den laufenden Vertrag in ihre Ableitung unter `DELEGATECALL`.

## Jede Adresse hat eine PDA, also warum spalten die Wrapper nicht die Liquidität?

Für eine Wallet ist ein Wrapper eine Ansicht ihrer SPL-Token. `balanceOf` liest das echte Token-Konto der Wallet auf Solana. `totalSupply` liest den Supply des Mint.

Die drei wUSDC-Wrapper auf Hadrian (Testnet), 9.0.0 (`0xbce339ba…`), 8.0.0 (`0xae287c43…`), und Mai 2026 (`0x9fd4d58d…`), zeigen für jede Wallet denselben Saldo. Alle drei geben den Supply des Mints von `totalSupply`.

Ein Solana-nativer Inhaber und ein EVM-Inhaber nutzen Konten desselben Mints. Die Solana-Wallet besitzt ihr Token-Konto direkt. Die PDA mit externer Autorität der EVM-Adresse besitzt ihr Token-Konto. `ActivateAta` und `transfer_spl` verschieben Token zwischen diesen Konten. Beide Inhaber handeln gegen dieselben Solana-Pool-Konten und Reserven.

Von Verträgen gehaltene Salden brauchen eine andere Behandlung. An einen Vertrag gesendete Token liegen im Escrow-Konto des Wrappers. Der Wrapper verfolgt den Saldo des Vertrags. Ein Paar im UniswapV2-Stil auf Hadrian hatte über Wrapper 9.0.0 einen Saldo von 9.600.566 und über Wrapper 8.0.0 einen von 0. Verwende für Pools, Vaults und Lending-Markets den kanonischen Wrapper aus dem Registry.

Jedes Token-Konto hat einen SPL-Delegate-Slot. Das Erteilen einer Berechtigung an einen Router oder eine Bridge ersetzt die Gewährung des Wrappers. Nach einer Wrapper-Rotation muss der Nutzer dem neuen Wrapper mit `approve_spl`erneut Berechtigung erteilen. Erteile dem Wrapper erneut Berechtigung, wenn ein anderer Delegate ihn ersetzt hat.

Jede Factory erlaubt einen Wrapper pro Mint. Wrapper aus verschiedenen Factories können trotzdem dieselben Token-Konten der Wallet lesen. Siehe [Token-Interop](https://docs.rome.builders/de/kernkonzepte/token-interop.md).

## Wie umgeht Rome die unterschiedlichen Semantiken von Solana und der EVM?

| Unterschied                                              | Was Rome tut                                                                                                                                                                                                                                              |
| -------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Im Voraus deklarierte Accounts statt dynamischer Zugriff | Emuliert zuerst den Aufruf und verwendet die berührten Accounts als Account-Liste der Solana-Instruction.                                                                                                                                                 |
| Compute- und Größenlimits einer Transaktion              | Verwendet atomare (VmAt-)Ausführung, wenn der Aufruf passt. Holder-Accounts tragen größere Payloads, und iterative (VmIt-)Ausführung teilt die Arbeit über Transaktionen auf.                                                                             |
| Account-Locks über Legs hinweg                           | Erneuert Locks auf Balance- und Storage-Accounts in jedem Leg. Locks halten 3 Sekunden oder 4 Sekunden, wenn die Transaktion mehr als 28 Accounts nennt. Ein atomarer Write auf ein gesperrtes Konto schlägt mit `AccountLocked`.                         |
| Gas-Token und Gebühren                                   | Zählt Solana-Kosten in Lamports und konvertiert sie mit dem Gaspreis der Transaktion in Gas-Token-Gebühren. Vom Wallet bezahlte Aufrufe zahlen SOL direkt.                                                                                                |
| Blöcke und Slots                                         | Verwendet den Solana-Slot für `block.number` und die Solana-Clock für `block.timestamp`.                                                                                                                                                                  |
| Finalität                                                | Bestätigt auf Solana `bestätigt`. Hercules prüft indizierte Blöcke erneut bei `finalized`.                                                                                                                                                                |
| Signaturen                                               | Verifiziert EVM-Signaturen mit `secp256k1_recover`. Solana-Autorisierung verwendet Ed25519. Beide erzeugen einen 20-Byte-EVM-Sender.                                                                                                                      |
| Miete                                                    | Finanziert die Erstellung und das Wachstum von Solana-Accounts über den Fee-Payer. Belastet den EVM-Sender über Gas, wenn ein Fee-Empfänger vorhanden ist.                                                                                                |
| Dezimalstellen und Integer-Breite                        | Verwendet 18 Dezimalstellen für native Gas-Guthaben. Die Umrechnung in SPL-Einheiten muss exakt sein und in `u64`passen. Wrapper verwenden die Dezimalstellen des Mints und lehnen Beträge über dem `uint64` Maximum ab.                                  |
| Reentrancy und Gas-Metering                              | Hat keinen Gaszähler für EVM-OpCodes. Das 2.300-Gas-Stipendium beschränkt Aufrufe nicht, daher benötigen Verträge explizite Reentrancy-Guards.                                                                                                            |
| CPI-Tiefe                                                | Führt das Rome-EVM-Programm auf Tiefe 1 und ein CPI-Ziel auf Tiefe 2 aus. Solana erlaubt Verschachtelung bis Tiefe 5.                                                                                                                                     |
| Atomarität von Solana-Nebeneffekten                      | Führt Legacy-CPIs sofort aus und bricht die gesamte Transaktion ab, wenn ihr Frame später revertiert. Zwischengespeicherte Aufrufe werden während der Ausführung aufgezeichnet und beim Commit gesendet. Sie werden verworfen, wenn ihr Frame revertiert. |
| `SELFDESTRUCT` und unbekannte OpCodes                    | Deaktiviert `SELFDESTRUCT`. Es und andere nicht implementierte OpCodes brechen die gesamte Transaktion mit `IncompatibleVersionEVM`.                                                                                                                      |
| Nonces                                                   | Speichert und prüft eine EVM-Nonce pro Sender in seiner Balance-PDA. Die Gas-Schätzung überspringt die Nonce-Prüfung.                                                                                                                                     |

### Accounts

Der Emulator führt den Aufruf vor der Übermittlung gegen Solana-Accounts aus. Er zeichnet jedes berührte Konto auf und ob es schreibbar sein muss. Diese Menge wird zur Account-Liste der Solana-Instruction. Ein erforderliches Konto, das in der Liste fehlt, lässt den On-Chain-Aufruf fehlschlagen.

Ein zeitabhängiger Zweig kann sich zwischen Emulation und Ausführung ändern. Wenn diese Änderung dazu führt, dass der Aufruf sein Compute-Budget überschreitet, setzt der Rome Proxy beim nächsten Block einmal neu zusammen.

### Transaktionsgröße und Compute

Atomare (VmAt-)Ausführung passt in eine einzige Solana-Transaktion, mit etwa 1,4 Millionen Compute-Einheiten und höchstens 64 Accounts. Der Aufruf muss außerdem in die Heap- und Instruction-Trace-Limits passen.

Eine Solana-v1-Transaktion umfasst höchstens 4.096 Bytes. Für größere EVM-Transaktions-Payloads schreibt der Rome Proxy 3.600-Byte-Chunks in ein `TxHolder` Halterkonto mit einer maximalen Größe von 80.000 Bytes. Die Signaturgebühr jedes Chunks wird als Gas berechnet.

Iterative (VmIt-)Ausführung speichert den VM-Zustand in einem `StateHolder` Halterkonto zwischen den Legs. Eine Sitzung erlaubt höchstens 160 Iterationen. Der Planer erzeugt höchstens 128 Legs, mit einem Opcode-Limit von mindestens 500 pro Leg. Legacy-CPIs erfordern atomare Ausführung. Zwischengespeicherte Aufrufe unterstützen iterative Ausführung.

### Gas und Miete

Eine Rome-Gas-Einheit entspricht einem Lamport Solana-Kosten. Zu den Kosten gehören Signaturgebühren, die Treasury-Abgabe von 5.000 Lamports, Prioritätsgebühren und Miete abzüglich Rückerstattungen. `eth_gasPrice` meldet Gas-Token-Wei pro Lamport. Wenn ein Fee-Empfänger vorhanden ist, belastet Rome den Sender `Lamports × tx.gasPrice` aus dem nativen Guthaben.

Der Solana-Fee-Payer finanziert die Miete, wenn Rome Balance- und Storage-Accounts erstellt oder vergrößert. Diese Kosten werden dem EVM-Sender als Gas berechnet, wenn ein Fee-Empfänger vorhanden ist. Eine erste Überweisung an eine nie verwendete Adresse kostet daher etwa 1 Million Gas. `eth_estimateGas` gibt niemals weniger als 21.000 zurück.

### Blöcke, Zeit und Finalität

`block.number` ist der Solana-Slot. `block.timestamp` ist der Unix-Zeitstempel der Solana-Clock. Rome erfasst beides, wenn es den VM-Zustand erstellt, und behält es über iterative Legs hinweg bei.

`blockhash(n)` ist `keccak256(bytes32(n))` innerhalb der letzten 256 Slots und außerhalb davon null. Es hat keine Entropie. `block.coinbase` ist der Fee-Empfänger, oder null, wenn es keinen gibt.

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.

### Reverts, Reentrancy und CPI

Legacy-CPIs werden sofort ausgeführt. Wenn ein Frame, der eine CPI ausgeführt hat, später revertiert, bricht Rome die gesamte Transaktion ab. Solidity- `try/catch` kann diesen Revert nicht abfangen. Zwischengespeicherte Aufrufe werden während der Ausführung aufgezeichnet und beim Commit gesendet. Ein revertierter Frame verwirft seine aufgezeichneten Aufrufe. Sobald eine Transaktion über einen Pfad geschrieben hat, werden Writes über den anderen Pfad verweigert. Nach einem zwischengespeicherten Write werden auch die Legacy-Read-Hilfsfunktionen verweigert: die Account-Reads von CpiProgram und `pdas_batch_derive`, und die von HelperProgram `user_balance`, `allowance_of` und `mint_info`.

Rome hat keinen Gaszähler für EVM-OpCodes. `gasleft()` gibt das Gaslimit zurück, oder `U256::MAX` wenn es keinen Fee-Empfänger gibt. Das Gas, das an `CALL` oder `CREATE` übergeben wird, wird nicht erzwungen. Verwende explizite Reentrancy-Guards statt dich auf das 2.300-Gas-Stipendium zu verlassen.

Die Instruction-Stack-Tiefe von Solana ist 5. Das Rome-EVM-Programm läuft auf Tiefe 1, also läuft sein Ziel auf Tiefe 2 und kann bis Tiefe 5 verschachteln. Der Hadrian-Swap führte das Swap-Programm auf Tiefe 2 und SPL Token auf Tiefe 3 aus. Eine ausstehende Solana-Änderung (SIMD-0268) würde die Tiefe von 5 auf 9 erhöhen. Sie war am 19. Oktober 2026 weder auf Devnet noch auf Mainnet aktiv. Eine CPI zurück in das Rome-EVM-Programm wird abgelehnt.

Siehe [Ausführungsmodell](https://docs.rome.builders/de/kernkonzepte/execution-model.md), [Beschränkungen](https://docs.rome.builders/de/kernkonzepte/constraints.md), [Compute-Budget](https://docs.rome.builders/de/kernkonzepte/compute-budget.md), und [Bekannte Einschränkungen](https://docs.rome.builders/de/sicherheit/known-limitations.md).

## Häufige Fragen

### Sind MetaMask und Phantom auf Rome dasselbe Konto?

Nein. Ein MetaMask-Schlüssel und ein Solana-Schlüssel ergeben zwei verschiedene EVM-Adressen, und Rome verknüpft sie nie. Der MetaMask-Schlüssel liefert seine übliche Ethereum-Adresse. Der Solana-Schlüssel liefert seine [synthetische Adresse](#what-is-a-synthetic-address), `keccak256(pubkey)[12..32]`: `2PMoUv…` wird zu `0x45b64dae…`. Beim Aufruf auf oberster Ebene sind `msg.sender` und `tx.origin` die Signieradresse, einschließlich der synthetischen Adresse auf dem Relay-Pfad.

Unterschiedliche Schlüssel verursachen die Trennung: Zwei MetaMask-Schlüssel sind ebenfalls zwei Konten. Die Kurven bedeuten nur, dass keiner der Schlüssel für die Adresse des anderen signieren kann. Es gibt keine Verknüpfungsfunktion. `ActivateAta` finanziert nur die eigene synthetische Adresse des Signierers. Eine `Einzahlung` Anweisung kann jede EVM-Adresse mit nativen Gas gutschreiben, bezahlt aus dem Gas-Token-Konto des Signierers. Der Proxy baut nur Einzahlungen zur eigenen synthetischen Adresse des Signierers. Nichts davon macht aus zwei Schlüsseln ein Konto. Ein Pool sieht zwei Inhaber, aber beide handeln gegen dieselben Reserven; siehe [Wird Liquidität geteilt](#is-liquidity-shared-between-solana-and-evm-users-or-split).

### Wie werden Solana- und EVM-Konten gemappt?

Rome mappt jeden Solana-Schlüssel auf eine feste [synthetische EVM-Adresse](#what-is-a-synthetic-address). Jede EVM-Adresse hat pro Chain eine Balance-PDA für ihre Nonce, ihr natives Gas-Guthaben und ihren Code. Ihre PDA mit externer Autorität besitzt ihre Token-Konten und signiert CPIs. Chains auf einem Rome-Programm teilen sich diese Autorität.

Diese Konten wurden auf Hadrian (Testnet) gelesen:

| Konto                           | MetaMask-Adresse `0x35153297…a266`                                             | Solana-Wallet `2PMoUv…`, synthetische Adresse `0x45b64dae…127d`                             |
| ------------------------------- | ------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------- |
| Eigene Solana-Konten der Wallet | Keine vom MetaMask-Schlüssel                                                   | SOL-Systemkonto `2PMoUv…`; eigenes wSOL-Konto `T8gKAAg9pz5eLcerH1Nh52Hn97m1nnGyhY9z4bwtyir` |
| Balance-PDA                     | `8zuWEakFcuRRJ5Gju44u6Ptyk22gbNUMbsD8VLEQVS4c`                                 | `EeRr14Feh3Ft7YuyacAVJQd3YSYsKAPTqdMEN43gtBSd`                                              |
| PDA mit externer Autorität      | `EZSTURZAg3GMqiWN3NBCvMLjEeLSxGH9PGooW6dAG8Kb`                                 | `FMSHMpgdA9rEhzGLSvFniAHT7BmGjJweQqxPiGJJntC1`                                              |
| Token-Konto, das Rome verwendet | USDC `8wAzpmag4oL4c6ku6wqQBjxWXYLPoVsek6SyAvrYaxim`, im Besitz von `EZSTURZA…` | wSOL `3pPjxR4ho3mVb5AMauVCjqTBUVS2Rif5JAnk9DFukPg2`, im Besitz von `FMSHMpgd…`              |

Die Token eines Solana-Nutzers liegen an zwei Orten: in den eigenen Konten der Wallet und in den von PDAs besessenen Konten der synthetischen Adresse, die Wrapper lesen. Das SDK verschiebt Token hinein mit `ActivateAta` und zurück mit `transfer_spl`, wie in [Wie ruft ein Solana-Nutzer einen Solidity-Vertrag auf?](#how-does-a-solana-user-call-a-solidity-contract)beschrieben. Der Sweep `0x95b2502d…` gab 0,016587 wSOL an die Wallet zurück. Dieselbe MetaMask-Adresse hat unterschiedliche Token-Konten auf Hadrian (Testnet) und Rubicon (Mainnet), weil sie auf unterschiedlichen Rome-Programmen, Mints und Solana-Clustern laufen.

### Wer bezahlt welche Gebühr, wenn ein EVM-Nutzer und ein Solana-Nutzer denselben Vertrag aufrufen? Ist es ein Gebührenpfad oder zwei?

Rome verwendet ein Kostenmodell mit zwei Wegen, es abzurechnen. Eine Rome-Gas-Einheit ist ein Lamport Solana-Kosten: Signaturgebühren, die Treasury-Abgabe von 5.000 Lamports, jede Prioritätsgebühr und Miete abzüglich Rückerstattungen.

Auf von der Wallet signierten Solana-Pfaden zahlt der Solana-Fee-Payer diese Kosten in SOL, ohne EVM-Gas-Gebühr. Bei MetaMask- und Relay-Aufrufen legt der Rome Proxy SOL vor. Das Programm belastet den EVM-Sender `Lamports × Gaspreis der Transaktion` aus seinem nativen Guthaben an einen Proxy-Fee-Empfänger. Der Gas-Token ist USDC auf Hadrian (Testnet) und Rubicon (Mainnet).

Diese beiden `Supply-` Aufrufe (USDC von MetaMask, wSOL vom Solana-Schlüssel) verwendeten AavePool 2.0.0 (`0x81e7e7e4…`) auf Hadrian (Testnet). Jeder erstellte zwei Konten.

| Kosten oder Empfänger          | EVM-Schlüssel (MetaMask)                                                               | Solana-Schlüssel (v1-Wallet-signiert)                                                                                     |
| ------------------------------ | -------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------- |
| EVM-Transaktion                | `0xc7e6ee8d…`, von `0x35153297…`                                                       | `0xb0712551…`, von `0x45b64dae…`                                                                                          |
| Wer signierte und bezahlte SOL | Romans Proxy-Zahler `GNX1fLhb…`                                                        | Die Wallet des Nutzers `2PMoUv…`                                                                                          |
| Verbrauchtes SOL               | 2.102.962 Lamports = 5.000 Signatur + 2 Priorität + 5.000 Abgabe + 2 × 1.046.480 Miete | 2.107.960 Lamports = 10.000 in Signaturgebühren (Transaktion + Ed25519-Verifikation) + 5.000 Abgabe + 2 × 1.046.480 Miete |
| Berechnetes EVM-Gas            | Der Sender zahlte 2.102.962 Gas × 13.004.742.450 Wei = 0,0273485 USDC                  | `gasUsed` 0, `gasPrice` 0                                                                                                 |
| Gas gezahlt an                 | Proxy-Fee-Empfänger `0x179d6112…`                                                      | Niemand; kein `gasRecipient`                                                                                              |
| Treasury-Abgabe-Empfänger      | `7WDWCxvk…`, Treasury-Konto #31                                                        | `3F9eKFpr…`, Treasury-Konto #6                                                                                            |

* **Legacy-Pfad (älterer Weg):** `0x350b8e36…` kostete die Wallet 1.056.480 Lamports: 5.000 Signaturgebühr + 5.000 Abgabe + 1.046.480 Miete, für ein erstelltes Konto. EVM-Gas war 0.
* **Relay:** Aave `Borrow` Transaktion `0x18d65e8c…` verwendete 16 Solana-Legs. Die synthetische Adresse zahlte 2.177.992 Gas = 0,0226594 USDC, unter Verwendung desselben Gebührenpfads wie ein MetaMask-Nutzer. Die Gasgebühr deckt `16 × 5.002 + 5.000 Abgabe + 2 × 1.046.480 Miete = 2.177.992`. Jedes Relay-Leg trägt außerdem die Ed25519-Verifikationssignatur. Der Proxy bezahlt diese 5.000 Lamports pro Leg und stellt sie nicht in Rechnung, daher kostete dieser Aufruf den Proxy 16 × 10.002 Lamports an Gebühren.
* **Gemeinsame Treasury:** Jeder Pfad zahlt seine Treasury-Abgabe von 5.000 Lamports in eines der 64 Treasury-Konten der Chain ein. Die beiden obigen Supply-Aufrufe zahlten ihre Abgaben in die Konten #31 und #6 desselben Sets ein.
* **Deklarierter Preis:** Rome berechnet den deklarierten Preis der Transaktion, `maxFeePerGas` für EIP-1559. Es gibt keine Base Fee und keine Rückerstattung der Differenz. Live-Transaktionen mit EVM-Schlüssel deklarierten das `eth_gasPrice` Zitat von 10.403.793.960 Wei pro Lamport mit 1× bis 2×, und jede zahlte genau das, was sie deklarierte. Gas wird pro Lamport Solana-Kosten bepreist, nicht pro EVM-OpCode.
* **Vom Wallet signierte Kosten:** Die SDK-Pfade setzen keine Prioritätsgebühr, daher zahlen Nutzer keine Compute-Gebühr. Sie zahlen Signaturgebühren, die Abgabe und Miete in SOL. Der v1-Pfad bezahlt zwei Signaturen: die Transaktionssignatur und die Ed25519-Verifikation.

Siehe den [Solana-Aufrufablauf](#how-does-a-solana-user-call-a-solidity-contract) und [Dual-Lane-Leitfaden](https://docs.rome.builders/de/entwicklerleitfaden/dual-lane-app.md) für die Wallet- und Relay-Pfade.

### Wird die Liquidität zwischen Solana- und EVM-Nutzern geteilt oder aufgeteilt?

Geteilt. Beide Pfade handeln gegen die Konten desselben Mints. Auf Aave auf Hadrian (Testnet) stellten sowohl ein Solana-Schlüssel als auch ein EVM-Schlüssel im MetaMask-Pfad über das wSOL-Escrow-Konto `3yY2FHSG…` (MetaMask: supply `0xaf460f52…`, borrow `0x89dbf0b6…`; Solana-Schlüssel: supply `0xb0712551…`, borrow `0x18d65e8c…`). Das ist das Escrow des wSOL-Wrappers, das die awSOL-Reserve hält.

Auf rome-dex zahlte eine Solana-Wallet Liquidität direkt in dieselben Vaults ein, die von EVM-Router-Swaps verwendet werden `0xa7f77530…`. Die Solana-Einzahlungs-Transaktion `2xFSzza7…` enthält kein Rome-Programm. Nur von Verträgen gehaltene Salden hängen vom Wrapper ab, daher verwende für Pools und Vaults den kanonischen Wrapper aus dem Registry (siehe den [Abschnitt zu PDA und Wrapper](#every-address-has-a-pda-so-why-dont-the-wrappers-split-liquidity)). Messe wSOL-Liquidität nicht mit `totalSupply`: Es liest 0, weil der native SOL-Mint einen Supply von 0 meldet.

### Wie verschiebe ich Token und Gasguthaben zwischen einer MetaMask-Adresse und einer Solana-Wallet?

* **Solana-Wallet zu MetaMask-Adresse, Token:** Erstelle das Token-Konto, falls es fehlt (die idempotente Erstellung des Associated-Token-Programms, mit der externen Autoritäts-PDA der Adresse als Eigentümer), und sende dann einfach eine SPL-Überweisung dorthin. `HelperProgram.ata(address, mint)` gibt dessen Adresse zurück. Transaktion `2tBhefMJ…` tat beides und verschob 20 USDC.
* **Solana-Wallet zu MetaMask-Adresse, Gas:** Finanziere deine eigene synthetische Adresse mit `fundSyntheticGas`. Sende dann eine native Wertüberweisung von der synthetischen Adresse an die MetaMask-Adresse.
* **MetaMask-Adresse zu Solana-Wallet, Token:** Rufe `transfer_spl(bytes32,uint64,bytes32)` auf dem Helper-Precompile direkt von der EVM-Adresse aus, mit dem bereits existierenden Token-Konto des Empfängers. Alternativ rufe `RomeBridgeWithdraw.bridgeOutToSolana`auf, was eine Erlaubnis und ein vorhandenes Token-Konto des Empfängers erfordert.
* **MetaMask-Adresse zu Solana-Wallet, Gas:** Rufe das zahlungspflichtige `withdrawal(bytes32 to)` des Withdraw-Precompiles mit dem Betrag als `msg.value`auf. Die Wallet erhält es als USDC in ihrem USDC-Token-Konto, das Rome bei Bedarf erstellt. `msg.value` muss ein Vielfaches von 10^12 Wei sein. Der Empfänger muss ein bestehendes Wallet-Konto sein.

`transfer_spl_to_signer` erreicht Ihr eigenes Wallet nur auf der wallet-signierten Solana-Lane. Von MetaMask aus oder über den Relay ist der Unterzeichner der Proxy-Payer von Rome, daher schlägt der Aufruf fehl oder die Token gehen an Rome. Siehe die [Precompile-Referenz](https://docs.rome.builders/de/referenz/precompiles.md).

Eine Identität kann die Token der anderen nur durch eine explizite Genehmigung ausgeben, `approve_spl` oder ein ERC-20 `approve`, wie bei jeder anderen Adresse. Jedes Token-Konto hat einen Delegaten-Slot. Siehe [Token-Interop](https://docs.rome.builders/de/kernkonzepte/token-interop.md#one-time-grant-per-wallet).

### Ist meine Adresse auf jeder Rome-Chain gleich?

Die EVM-Adresse ist auf jeder Chain gleich, weil sie aus dem Schlüssel abgeleitet wird. Ihr Nonce und ihr Gas-Guthaben werden pro Chain verwaltet. Ihre Token-Konten werden von Chains mit demselben Rome-Programm gemeinsam genutzt und unterscheiden sich zwischen Programmen und Clustern. Siehe die [Kontozuordnung](#how-do-solana-and-evm-accounts-map).

### Welche Wallet funktioniert auf der Solana-Lane? Funktioniert Phantom?

Noch nicht auf der Solana-Lane. Die Solana-Lane verwendet Solana-v1-Transaktionen, und die Wallet muss sie signieren. Auf dem Devnet funktioniert Solflare; Phantom noch nicht.

### Zeigt der Explorer, welche Lane eine Transaktion verwendet hat?

Teilweise. Die [Über den Explorer](https://docs.rome.builders/de/apps-auf-rome/via.md) zeigt, ob ein EVM-Schlüssel oder ein Solana-Schlüssel einen Aufruf gesendet hat: `Ursprung` ist `ecdsa` oder `solana_unsigned`, und Aufrufe mit Solana-Schlüsseln tragen `solanaSigner`. Es unterscheidet nicht zwischen den Legacy-, v1- und Relay-Routen; alle drei zeigen `solana_unsigned`an. Ein Relay-Aufruf ist der mit ungleich null `gasUsed` und einem `gasRecipient`. Ein Gas-Top-up mit `fundSyntheticGas` wird angezeigt als `ecdsa` ohne `solanaSigner`.

## Wohin als Nächstes

* [Architektur](https://docs.rome.builders/de/erste-schritte-1/architecture.md)
* [Ausführungsmodell](https://docs.rome.builders/de/kernkonzepte/execution-model.md)
* [Token-Interop](https://docs.rome.builders/de/kernkonzepte/token-interop.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)
* [Eine Dual-Lane-App bauen](https://docs.rome.builders/de/entwicklerleitfaden/dual-lane-app.md)
* [Integrieren Sie ein Solana-Programm](https://docs.rome.builders/de/entwicklerleitfaden/integrate-solana-program.md)
* [Precompile-Referenz](https://docs.rome.builders/de/referenz/precompiles.md)
* [JSON-RPC-Referenz](https://docs.rome.builders/de/referenz/json-rpc.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/kernkonzepte/how-solana-and-evm-meet.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.
