> 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/referenz/precompiles.md).

# Referenz der Precompiles

Jede Methode der Solana-Interop-Precompiles von Rome — Adresse, Solidity-Signatur, Selektor und ob sie liest, aufruft oder eine CPI vorbereitet.

Die Selektoren, die Roms On-Chain-Programm per Precompile ausführt. Selektor = `keccak256(signature)[:4]`; jede Zeile unten wird daran überprüft. Die Solidity-Interfaces liegen in [`rome-solidity/contracts/interface.sol`](https://github.com/rome-protocol/rome-solidity/blob/master/contracts/interface.sol).

**Lies zuerst die Spalte Dispatch.** Sie sagt, was eine Methode mit dem Solana-Zustand macht:

| Ausführung                   | Was passiert                                                                                                                                                                                                                                                  | Echte Solana-CPI | In iterativer Ausführung erlaubt |
| ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------- | -------------------------------- |
| `Aufruf` / `Zusammengesetzt` | Ein oder mehrere CPIs, signiert als die externe Autoritäts-PDA des Aufrufers, wenn Salze gelten. Auf dem **Legacy** Pfad laufen sie sofort; auf dem **zwischengespeicherte** Pfad werden sie zwischengespeichert und am Ende der Transaktion festgeschrieben. | Ja               | Legacy: **nein**. Cached: ja     |
| `EthCall`                    | Reine Berechnung oder ein Lesen von Roms eigenem Zustand                                                                                                                                                                                                      | Nein             | Ja                               |
| `CrossStateEthCall`          | Ein Lesezugriff auf die Bytes eines anderen Solana-Kontos, per Emulation vorab geladen. Kein CPI, keine Seiteneffekte.                                                                                                                                        | Nein             | Ja                               |
| `Vorcompiliert`              | Deterministische Kryptographie (die Ethereum-Standard-Precompiles)                                                                                                                                                                                            | Nein             | Ja                               |

Ein Vertrag verwendet **einen Track**: entweder die Legacy-Precompiles (`0xff…07`, `0xff…08`, `0xff…09`, `0x42…16`) oder die gecachten (`0xff…04`, `0xff…05`, `0xff…06`, `0xff…0b`). Das Mischen von mutierenden Aufrufen aus beiden in einer Transaktion wird zur Laufzeit abgelehnt. Lesezugriffe bleiben erlaubt, mit einer Ausnahme: Sobald ein Invoke auf dem Cache-Pfad ausgelöst wurde, werden Lesezugriffe auf dem Legacy-Pfad für den Rest der Transaktion abgelehnt. Siehe [Integrieren Sie ein Solana-Programm](https://docs.rome.builders/de/entwicklerleitfaden/integrate-solana-program.md).

**Wer bezahlt.** Der Solana-Fee-Payer legt jeden Lamport vor, den ein CPI auf dem Legacy-Pfad ausgibt (Rent, Transfers, `swap_gas_to_lamports`); das Programm misst das Guthaben des Zahlers um jeden CPI herum und belastet den Nettobetrag den Benutzer als Gas zum Gaspreis, wobei vom CPI zurückgegebene Lamports erstattet werden.

**Wer signiert.** Ein Vertrag, der ein Precompile aufruft, handelt als er selbst: Der Signierer ist die externe Autoritäts-PDA des Vertrags (`["EXTERNAL_AUTHORITY", contract]`). Die eigene PDA eines Benutzers signiert nur bei einer Transaktion, die der Benutzer direkt an die Precompile-Adresse sendet. Unter `DELEGATECALL` / `CALLCODE`, werden mutierende Selektoren abgelehnt außer `create_ata*`, `create_pda*`, `swap_gas_to_lamports`, `init_spl_mint` und `create_and_init_mint` auf HelperProgram, `create_ata*` auf ASplCached und `invoke` / `invoke_signed` auf CpiProgram. Sie sind ausgenommen, weil ihr Ziel an den Aufrufer gebunden ist oder vom Operator finanziert wird, nicht weil sie nichts signieren: `create_and_init_mint` signiert immer noch mit der PDA des äußeren Aufrufers, um die Miete des Mint zu bezahlen, und darf nur einen Mint erstellen, dessen Autoritäten diese PDA sind, und `invoke` / `invoke_signed` verweigern die nackte Autorität (`DelegatecallOwnerAuthority`) und mit der Adresse des laufenden Vertrags gesalzene PDAs im Namespace.

Jede Methode ist nicht zahlbar (`msg.value > 0` löst mit `TransferProhibited`) aus, außer `withdrawal(bytes32)`. Methoden mit dem Kennzeichen *nur einzelner Zustand* werden auf op-geth-stack-Ketten abgelehnt. Ein CPI darf den Solana-Fee-Payer nicht nennen (außer innerhalb einer reinen System-Transfer-Instruktion) oder das Rome-Programm, und darf das Rome-Programm nicht aufrufen.

## SystemCached (`0xff00000000000000000000000000000000000004`)

PDA-Erstellung + Systemprogramm-Operationen (allocate, assign, Lamport-Transfer), zwischengestaged im Overlay. Gegenstück im Cache zum Legacy `System bei 0xff..07`'s mutating selectors (das Legacy-System behält die reinen Lese-Selektoren).

| Solidity-Signatur                    | Selektor     | Ausführung | Beschreibung                                                            |
| ------------------------------------ | ------------ | ---------- | ----------------------------------------------------------------------- |
| `create_pda()`                       | `0xe0402a8d` | `Aufruf`   | Erstellt die `external_auth` PDA des Aufrufers, mietbefreit, ohne Daten |
| `create_pda(uint64)`                 | `0x4ceab657` | `Aufruf`   | Dasselbe, mit vom Finanzierer angegebenen Lamports oberhalb der Miete   |
| `create_pda(uint64,bytes32)`         | `0x48e2bb86` | `Aufruf`   | Aus Salz abgeleitete PDA mit Lamports                                   |
| `create_pda(bytes32,uint64,bytes32)` | `0xcc258bbf` | `Aufruf`   | Vom Besitzer spezifiziert, Größe N, aus Salz abgeleitet                 |
| `allocate(uint64,bytes32)`           | `0x93225c9f` | `Aufruf`   | N Bytes auf einer aus Salz abgeleiteten PDA zuweisen                    |
| `assign(bytes32,bytes32)`            | `0x8ac00bdc` | `Aufruf`   | Eine aus Salz abgeleitete PDA einem neuen Besitzer zuweisen             |
| `transfer(address,uint64)`           | `0x5d359fbd` | `Aufruf`   | Lamport-Transfer an eine aus EVM-Adresse abgeleitete PDA                |
| `transfer(bytes32,uint64)`           | `0xfd54d1ea` | `Aufruf`   | Lamport-Transfer an einen rohen Solana-Pubkey                           |
| `transfer(bytes32,uint64,bytes32)`   | `0x875abfc0` | `Aufruf`   | Lamport-Transfer an einen rohen Pubkey, Quelle aus Salz abgeleitet      |

## SplCached (`0xff00000000000000000000000000000000000005`)

SPL-Token-/Token-2022-Transfers + ATA-Initialisierung + kontenübergreifende Zustandslesezugriffe, ins Overlay gestaged.

| Solidity-Signatur                               | Selektor     | Ausführung          | Beschreibung                                                                                                                                                                                                                                                                                                                                                                                                                        |
| ----------------------------------------------- | ------------ | ------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `transfer(address,uint256)`                     | `0xa9059cbb` | `Aufruf`            | SPL-Transfer vom als Besitzer auftretenden Aufrufer an die von der EVM-Adresse abgeleitete ATA, aktueller Rollup-Mint                                                                                                                                                                                                                                                                                                               |
| `transfer(bytes32,uint256)`                     | `0x6a467394` | `Aufruf`            | Dasselbe, Empfänger angegeben als roher Solana-Pubkey                                                                                                                                                                                                                                                                                                                                                                               |
| `transfer(address,uint256,bytes32)`             | `0x57cfeeee` | `Aufruf`            | Variante mit explizitem Mint, EVM-Adress-Ziel                                                                                                                                                                                                                                                                                                                                                                                       |
| `transfer(bytes32,uint256,bytes32)`             | `0x7db527f9` | `Aufruf`            | Variante mit explizitem Mint, Ziel roher Pubkey                                                                                                                                                                                                                                                                                                                                                                                     |
| `transferFrom(address,address,uint256,bytes32)` | `0x401e3367` | `Aufruf`            | Delegate-Quelle-Variante — Autorität = `external_auth(caller)`, akzeptiert als ATA-Besitzer ODER als Delegate mit ausreichendem Betrag. Verwendet von `SPL_ERC20_cached.transferFrom` und routergesteuerten Abläufen                                                                                                                                                                                                                |
| `approve(address,uint256,bytes32)`              | `0x8180f2fc` | `Aufruf`            | EVM-Spender-Genehmigung — Besitzer = `external_auth(caller)`, Delegate = `external_auth(spender_addr)`. Verwendet von `SPL_ERC20_cached.approve`                                                                                                                                                                                                                                                                                    |
| `mint(address,uint256,bytes32)`                 | `0x1e458bee` | `Aufruf`            | Die PDA des Aufrufers signiert als Mint-Autorität. Die SPL-Runtime erzwingt PDA des Aufrufers == On-Chain-Mint-Autorität. Verwendet von `SPL_ERC20_cached.mint_to` und der eingehenden Bridge-Abrechnung                                                                                                                                                                                                                            |
| `init(bytes32,bytes32,bytes32)`                 | `0x0b0ad508` | `Aufruf`            | `InitializeAccount3` ix (ata, mint, owner)                                                                                                                                                                                                                                                                                                                                                                                          |
| `account(address)`                              | `0x73b9aa91` | `CrossStateEthCall` | SPL-Kontenzustand für die von der PDA der EVM-Adresse abgeleitete ATA lesen (aktueller Rollup-Mint)                                                                                                                                                                                                                                                                                                                                 |
| `account(bytes32)`                              | `0x882358ae` | `CrossStateEthCall` | SPL-Kontenzustand für einen rohen ATA-Pubkey lesen                                                                                                                                                                                                                                                                                                                                                                                  |
| `account(address,bytes32)`                      | `0xf9827227` | `CrossStateEthCall` | Wie `account(address)` mit einem expliziten Mint.                                                                                                                                                                                                                                                                                                                                                                                   |
| `mint_info(bytes32)`                            | `0xe24bf5d4` | `CrossStateEthCall` | Mint-Fakten, Overlay-bewusst: Token-Programm, Dezimalstellen, **aktiviert** Hook-Programm (0 wenn nicht vorhanden *oder* inert), Gebühren-Bps der aktuellen Epoche und eine Bitmap der vorhandenen Erweiterungen. Derselbe Selektor wie `HelperProgram.mint_info` — eine Fähigkeit, zwei Dispatch-Heime, denn ein Vertrag auf dem Cache-Pfad kann den Legacy-Lesezugriff nicht verwenden, nachdem ein Cache-Invoke ausgelöst wurde. |

## ASplCached (`0xff00000000000000000000000000000000000006`)

Erstellung eines Associated Token Accounts, idempotent.

| Solidity-Signatur             | Selektor     | Ausführung | Beschreibung                                                                    |
| ----------------------------- | ------------ | ---------- | ------------------------------------------------------------------------------- |
| `create_ata()`                | `0xb6d336ed` | `Aufruf`   | Idempotente ATA-Erstellung für Aufrufer-PDA × aktueller Rollup-Mint             |
| `create_ata(bytes32)`         | `0x81972e35` | `Aufruf`   | Idempotente ATA-Erstellung für Aufrufer-PDA × expliziten Mint                   |
| `create_ata(address)`         | `0x5a7c3259` | `Aufruf`   | Idempotente ATA-Erstellung für von EVM-Adresse abgeleitete PDA × aktuellen Mint |
| `create_ata(address,bytes32)` | `0x3de2251a` | `Aufruf`   | Idempotente ATA-Erstellung für EVM-Adresse × expliziten Mint                    |

## WithdrawCached (`0xff0000000000000000000000000000000000000b`)

Auszahlungsarme des Gas-Tokens (natürliches Gas → SPL-Wrapper, natürliches Gas → SOL, natürliches Gas → Aufrufer-PDA), gestaged. Gegenstück im Cache zum Legacy `Withdraw bei 0x42..16`.

| Solidity-Signatur             | Selektor     | Ausführung        | Beschreibung                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| ----------------------------- | ------------ | ----------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `withdrawal(bytes32) payable` | `0x4d8b0ea4` | `Zusammengesetzt` | Verbrennen `msg.value` Rome-Gas, Überweisung an Solana-Systemkonten-Empfänger                                                                                                                                                                                                                                                                                                                                                                                                             |
| `withdraw_to_pda(uint256)`    | `0x7f3124a0` | `Zusammengesetzt` | Wei verbrennen, Lamports auf die `EXTERNAL_AUTHORITY` PDA des Aufrufers einzahlen. Nur einzelner Zustand.                                                                                                                                                                                                                                                                                                                                                                                 |
| `withdraw_to_ata(uint256)`    | `0x8059abc0` | `Zusammengesetzt` | Wei verbrennen, SPL-Wrapper auf die vom Aufrufer-PDA gehaltene ATA einzahlen. Nur einzelner Zustand. Wrap-Arm der Gas-Wrapper-Bridge.                                                                                                                                                                                                                                                                                                                                                     |
| `deposit(uint256)`            | `0xb6b55f25` | `Zusammengesetzt` | Gegenstück zu `withdrawal` — SPL-Transfer von der vom Aufrufer-PDA gehaltenen ATA zum sol\_wallet-ATA der Kette auf der Solana-Seite; **mint** `Wei` natürliches Gas an den Aufrufer auf der EVM-Seite. Reine Prägung (kein ausgleichender Abzug gegen `Withdraw::ADDRESS` — die SPL-Wallet der Kette ist die wirtschaftliche Absicherung, nicht die Precompile-Adresse). Nur einzelner Zustand. Unwrap-Arm der Gas-Wrapper-Bridge. Entspricht `HelperProgram.deposit_from_ata` Semantik. |

## System (`0xff00000000000000000000000000000000000007`)

PDA-Ableitung + Base58-Konvertierung + Identity-artige Hilfsfunktionen. Nur-Lese-Precompile — jede Methode ist `EthCall` (keine Solana-Seiteneffekte).

| Solidity-Signatur                                 | Selektor     | Ausführung | Beschreibung                                                                         |
| ------------------------------------------------- | ------------ | ---------- | ------------------------------------------------------------------------------------ |
| `find_program_address(bytes32,(bytes)[])`         | `0x27e3edda` | `EthCall`  | Solana `find_program_address` per Syscall — gibt zurück `(pda, bump)`                |
| `create_program_address(bytes32,(bytes)[],uint8)` | `0xb99f29e1` | `EthCall`  | Konstante-Zeit-PDA-Ableitung mit bekanntem Bump                                      |
| `rome_evm_program_id()`                           | `0xb76fd45b` | `EthCall`  | Gibt die Solana-Programm-ID dieses Rome-EVM-Programms zurück                         |
| `program_id()`                                    | `0x77764881` | `EthCall`  | Gibt Roms System-Programm-ID zurück (die Identität dieses Precompiles)               |
| `mint_id()`                                       | `0xe132a122` | `EthCall`  | Gibt die SPL-Mint-Pubkey des Gas-Tokens der Kette zurück (`OwnerInfo.chain_mint_id`) |
| `operator()`                                      | `0x570ca735` | `EthCall`  | Gibt den Solana-Signer der äußeren Rome-Transaktion zurück                           |
| `bytes32_to_base58(bytes32)`                      | `0xfa2b1a5f` | `EthCall`  | Pubkey-Bytes → Base58-String                                                         |
| `base58_to_bytes32(bytes)`                        | `0x5df01b72` | `EthCall`  | Base58-String → Pubkey-Bytes                                                         |

## CpiProgram (`0xff00000000000000000000000000000000000008`)

**Precompile mit Doppelfunktion.** Von den 7 Selektoren unten, **führen 2 echte Solana-CPI aus** (`invoke`, `invoke_signed` — ausführen als `Aufruf` und **5 sind reine Cross-State-Lesezugriffe** (`account_info`, `account_data_at`, `account_u64_at`, `account_lamports`, `pdas_batch_derive` — ausführen als `CrossStateEthCall`, kein Syscall, kein `found_cpi` Flag gesetzt). Der historische Ausdruck „CPI shortcut selectors“ bezog sich auf die Lese-Selektoren als CU-sparende Ersatzlösungen für frühere CPI-basierte Lesezugriffe — sie selbst sind **keine CPIs**. Siehe die Unterscheidungstabelle am Anfang dieses Abschnitts für die vollständige Verhaltensmatrix.

| Solidity-Signatur                                              | Selektor     | Ausführung          | Beschreibung                                                                                                                                                                                                                                                                     |
| -------------------------------------------------------------- | ------------ | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `invoke(bytes32,(bytes32,bool,bool)[],bytes)`                  | `0x7480cb86` | `Aufruf`            | CPI signiert als `EXTERNAL_AUTHORITY(caller)` wenn dieses Konto als Signierer aufgeführt ist (unter DELEGATECALL abgelehnt); keine gesalzenen Unter-PDAs. Aufrufer übergibt Zielprogramm + Account-Metas + ix-Daten                                                              |
| `invoke_signed(bytes32,(bytes32,bool,bool)[],bytes,bytes32[])` | `0xb94f3733` | `Aufruf`            | CPI signiert als `EXTERNAL_AUTHORITY(caller)` bei einem direkten CALL; Salze werden pro-PDA-Seed angehängt. Unter DELEGATECALL wird die nackte Autorität des Aufrufers abgelehnt und gesalzene Seeds tragen die Adresse des laufenden Vertrags — siehe die Ableitungsnotiz unten |
| `account_info(bytes32)`                                        | `0xc13465d9` | `CrossStateEthCall` | Den vollständigen Zustand eines Solana-Kontos lesen (Lamports/Besitzer/Flags/Daten)                                                                                                                                                                                              |
| `account_data_at(bytes32,uint16,uint16)`                       | `0x593762e8` | `CrossStateEthCall` | Einen Ausschnitt des Datenpuffers eines beliebigen Solana-Kontos lesen                                                                                                                                                                                                           |
| `account_u64_at(bytes32,uint16)`                               | `0xb317d4c1` | `CrossStateEthCall` | Getyptes u64-LE-Lesen an einer bekannten Offset-Position — spart ABI-Roundtrip                                                                                                                                                                                                   |
| `account_lamports(bytes32)`                                    | `0xde79ed54` | `CrossStateEthCall` | Nur-Lamports-Abfrage — überspringt das Laden der Daten                                                                                                                                                                                                                           |
| `pdas_batch_derive(bytes[][],bytes32)`                         | `0x944336f8` | `CrossStateEthCall` | N unabhängige PDAs gegen ein Programm in einem Dispatch                                                                                                                                                                                                                          |

## HelperProgram (`0xff00000000000000000000000000000000000009`)

Rome-Helpers für Benutzer für ATA/PDA-Erstellung, SPL-Transfers/Genehmigungen/Minting, signiert durch die PDA des Aufrufers, `EXTERNAL_AUTHORITY` Gas↔Lamports-Konvertierung, ATA-Einzahlung und SPL\_ERC20-bezogene Lesezugriffe (`user_balance` / `allowance_of`). Jede Methode ist `nicht zahlbar`; Mutationen laufen über `Aufruf` (einzelner CPI) außer `deposit_from_ata` (`Zusammengesetzt`, nur einzelner Zustand), die drei schreibgeschützten `pda`/`ata` Abfragen (`EthCall`), und die zwei Cross-State-SPL\_ERC20-Lesezugriffe (`CrossStateEthCall` — ein einzelner Solana-Kontoabruf).

| Solidity-Signatur                                                | Selektor     | Ausführung          | Beschreibung                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| ---------------------------------------------------------------- | ------------ | ------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `create_ata(address)`                                            | `0x5a7c3259` | `Aufruf`            | ATA für den EVM-Benutzer unter dem Gas-Mint der Kette erstellen                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `create_ata(address,bytes32)`                                    | `0x3de2251a` | `Aufruf`            | ATA für den EVM-Benutzer unter einem beliebigen Mint erstellen                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `create_ata_for_key(bytes32,bytes32)`                            | `0xd258a69d` | `Aufruf`            | Idempotente ATA-Erstellung für einen beliebigen rohen Solana-Pubkey als Besitzer (nicht abgeleitet via `external_auth`). Der Operator bezahlt die Miete. Verwendet von `SPL_ERC20.bridgeOutToSolana` / `ensureRecipientAta` / `create_token_account` Abläufe mit rohem Pubkey-Empfänger                                                                                                                                                                                                                                                                                                                                                                                                   |
| `create_pda(address)`                                            | `0xff3556ca` | `Aufruf`            | Erstelle des Benutzers `EXTERNAL_AUTHORITY` PDA (mietbefreit)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `create_pda(address,uint64)`                                     | `0x58e88298` | `Aufruf`            | Dasselbe, aber finanziert mit `Lamports` über der Mietuntergrenze                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `swap_gas_to_lamports(uint64)`                                   | `0x6e3f24e0` | `Aufruf`            | Gutschrift für die PDA des Aufrufers mit `n` Lamports vom Solana-Fee-Payer der Transaktion; der Aufrufer bezahlt dafür in Rome-Gas (der Lamport-Verbrauch des Zahlers innerhalb eines Legacy-CPI wird zur Transaktionsgebühr addiert)                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `transfer_lamports(address,uint64)`                              | `0x5fe71665` | `Aufruf`            | Verschiebt Lamports von der PDA des Aufrufers zu einer anderen PDA eines EVM-Benutzers                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `transfer_spl(address,uint64)`                                   | `0xb12be5ba` | `Aufruf`            | Sendet Chain-Gas-SPL von der ATA der PDA des Aufrufers zur ATA des Zielbenutzers                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `transfer_spl(bytes32,uint64)`                                   | `0xba3a5eac` | `Aufruf`            | Sendet Chain-Gas-SPL von der ATA der PDA des Aufrufers an eine explizite ATA                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `transfer_spl(address,uint64,bytes32)`                           | `0x53b505e0` | `Aufruf`            | Sendet SPL mit beliebigem Mint von der ATA der PDA des Aufrufers zur ATA des Zielbenutzers                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `transfer_spl(bytes32,uint64,bytes32)`                           | `0xb6977879` | `Aufruf`            | Sendet SPL mit beliebigem Mint von der ATA der PDA des Aufrufers an eine explizite ATA                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `transfer_spl(bytes32,bytes32,uint64,bytes32)`                   | `0x766b362a` | `Aufruf`            | Delegierte Variante — der Aufrufer liefert `src_ata` (muss im Besitz der PDA sein ODER die PDA muss der Delegierte mit ausreichendem `delegated_amount`)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `transfer_spl(address,address,uint64,bytes32)`                   | `0xe479df56` | `Aufruf`            | Adressschlüsselbasierte Delegiertenvariante — leitet beide ATAs intern aus EVM-Adressen ab. Signiert als `external_auth(caller)`; SPL Token akzeptiert die PDA als Owner ODER Delegierten. Verwendet von `SPL_ERC20.transferFrom`                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `transfer_spl_to_signer(uint64,bytes32)`                         | `0x46efa679` | `Aufruf`            | Solana-native Ausstiegsstufe. Sendet `Betrag` von `mint` von der ATA der PDA des Aufrufers an die **ATA des äußeren Solana-Signers** für diesen Mint (die eigene Wallet des Benutzers nur auf der mit Wallet signierten Solana-Lane; von MetaMask oder über den Relay ist der Signer Rome's Proxy-Zahler; keine Umwandlung von EVM-Adressen). Keine Genehmigung nötig — die Aufrufer-PDA besitzt die Quell-ATA. Kombiniere es mit `ActivateAta` (Slot 18) für eine End-to-End-EVM-Nutzung nur mit Solana-Schlüssel. Es erreicht die Wallet auf der aktuellen v1-Lane und auf der älteren Legacy- `DoTxUnsigned` (Slot 17)-Lane, da die Wallet auf beiden die Solana-Transaktion signiert. |
| `approve_spl(address,uint64,bytes32)`                            | `0xabf6f675` | `Aufruf`            | Aufrufer-PDA-als-Owner setzt `delegate_pda(spender)` auf owner-ATA über SPL `approve_checked`. Verwendet von `SPL_ERC20.approve`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `approve_spl_raw_delegate(bytes32,bytes32,uint64,bytes32,uint8)` | `0x7881d453` | `Aufruf`            | SPL `approve_checked` mit vom Aufrufer bereitgestelltem Raw-Pubkey-Delegierten (z. B. Wormhole `authority_signer` PDA, kein EVM-Adressäquivalent). Der Aufrufer übergibt `Dezimalstellen` um das Mint-Lesen on-chain zu überspringen (Einsparung von ca. 30–50K CU). Fest verdrahtet `spl_program = SPL Token`. Verwendet von `RomeBridgeWithdraw.approveBurnETH`                                                                                                                                                                                                                                                                                                                         |
| `mint_spl(address,uint64,bytes32)`                               | `0xd795522b` | `Aufruf`            | Aufrufer-PDA-als-Mint-Autorität prägt an die ATA des Zielbenutzers über SPL `mint_to_checked`. Die SPL-Runtime erzwingt die Übereinstimmung der Autorität. Verwendet von `SPL_ERC20.mint_to`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `create_mint_account(bytes32)`                                   | `0xe97d3291` | `Aufruf`            | System-CreateAccount, das eine aus Salt abgeleitete PDA allokiert (`external_auth_with_salt(caller, salt)`) mit space=82, im Besitz von SPL Token. Finanziert von der external\_auth-PDA des Aufrufers. Zwei PDA-Signer. Verwendet von `ERC20SPLFactory.create_token_mint`                                                                                                                                                                                                                                                                                                                                                                                                                |
| `init_spl_mint(bytes32,uint8,bytes32,bool,bytes32)`              | `0x4f75e987` | `Aufruf`            | SPL Token `InitializeMint2` gegen vorab zugewiesenen Mint. Kein PDA-Signer (mint\_authority/freeze\_authority werden als Daten gespeichert, nicht als Laufzeit-Signer). Verwendet von `ERC20SPLFactory.init_token_mint`                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `create_and_init_mint(uint8,bytes32,bool,bytes32,bytes32)`       | `0x20972d0f` | `Zusammengesetzt`   | Kombiniert: System CreateAccount + SPL InitializeMint2 in einem Dispatch. Spart 1 Rome-DoTx-Envelope gegenüber separaten `create_mint_account` + `init_spl_mint` Aufrufen                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `deposit_from_ata(uint256)`                                      | `0x4479b709` | `Zusammengesetzt`   | Zieht SPL von der ATA des Aufrufers in Rome-natives Gas ein. **Nur Einzelzustand** — auf op-geth-Chains abgelehnt                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `pda(address)`                                                   | `0x8854a299` | `EthCall`           | Leite die `EXTERNAL_AUTHORITY` PDA des Benutzers ab — nur lesend                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `pda_with_salt(address,bytes32)`                                 | `0x5c6d04b3` | `EthCall`           | Aus Salz abgeleitete `EXTERNAL_AUTHORITY` PDA in einem einzigen Dispatch. Reduziert die 2-Aufruf-Komposition auf Solidity-Seite `rome_evm_program_id() + find_program_address()` wird zusammengesetzt. Verwendet von `RomeEVMAccount.pda_with_salt`, `RomeBridgeWithdraw.{burnUSDC,burnETH}`                                                                                                                                                                                                                                                                                                                                                                                              |
| `ata(address)`                                                   | `0x31db4f82` | `EthCall`           | Leite `getATA(user_pda, chain_mint_id)` — setzt EXT\_AUTH + ATA zusammen — nur lesend                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `ata(address,bytes32)`                                           | `0xfeb1c647` | `EthCall`           | Dasselbe mit einem expliziten Mint — nur lesend                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `user_balance(address,bytes32)`                                  | `0xdd0119c8` | `CrossStateEthCall` | Liest die ATA des Benutzers `Betrag` (SPL-TokenAccount-Offset 64). Gibt 0 zurück, wenn die ATA nicht existiert (Fresh-Chain-Probe). Reduziert 3 v1-Dispatches auf einen. Verwendet von `SPL_ERC20.balanceOf`                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `mint_info(bytes32)`                                             | `0xe24bf5d4` | `CrossStateEthCall` | Mint-Fakten für einen Aufrufer im Legacy-Track: Token-Programm, Dezimalstellen, **aktiviert** Hook-Programm (0 wenn nicht vorhanden *oder* inert), Fee-Bps der aktuellen Epoche, Bitmap der Vorhandenseins-Erweiterungen. Gespiegelt in `SplCached` mit demselben Selektor. `feeBps` ist ein **Prädikat** — es sagt aus, dass eine Gebühr aktiviert ist; es ist kein Operand, da die tatsächliche Gebühr durch `maximum_fee` begrenzt wird, das dieses absichtlich nicht mitführt.                                                                                                                                                                                                        |
| `allowance_of(address,address,bytes32)`                          | `0xed72dbc8` | `CrossStateEthCall` | Liest delegated\_amount der owner-ATA mit **Delegate-Gleichheitsprüfung** — gibt 0 zurück, sofern on-chain delegate == `external_auth(spender)`. ERC-20-semantisch korrekt (HARD REQ). Verwendet von `SPL_ERC20.allowance`                                                                                                                                                                                                                                                                                                                                                                                                                                                                |

## Abheben (`0x4200000000000000000000000000000000000016`)

Rome → Solana native Gas-Auszahlung.

| Solidity-Signatur          | Selektor     | Ausführung                    | Beschreibung                                                                                                               |
| -------------------------- | ------------ | ----------------------------- | -------------------------------------------------------------------------------------------------------------------------- |
| `withdrawal(bytes32)`      | `0x4d8b0ea4` | `Zusammengesetzt` (`payable`) | Verbrennen `msg.value` Rome-Gas; Prägen+Übertragen an ein Solana-Systemkonto `zu`. Die einzige zahlbare Precompile-Methode |
| `withdraw_to_pda(uint256)` | `0x7f3124a0` | `Zusammengesetzt`             | Gas verbrennen; Einzahlung an die `EXTERNAL_AUTHORITY` PDA des Aufrufers. **Nur Einzelzustand**                            |
| `withdraw_to_ata(uint256)` | `0x8059abc0` | `Zusammengesetzt`             | Gas verbrennen; Einzahlung an `getATA(caller_pda, chain_mint_id)`. **Nur Einzelzustand**                                   |


---

# 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/referenz/precompiles.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.
