> 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 dispatcht. Selektor = `keccak256(Signatur)[:4]`; jede Zeile unten wird dagegen verifiziert. Die Solidity-Interfaces befinden sich 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-State macht:

| Dispatch              | Was passiert                                                                                                                                                                                                                               | Echtes Solana CPI | Im iterativen Ausführen erlaubt           |
| --------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------- | ----------------------------------------- |
| `Invoke` / `Composed` | Ein oder mehrere CPIs, signiert als die externe-Authority-PDA des Aufrufers, wenn Seeds gelten. Auf dem **legacy** Pfad laufen sie sofort; auf dem **gecachte** Pfad werden sie zwischengespeichert und am Ende der Transaktion committed. | Ja                | Legacy: **nein**. Zwischengespeichert: ja |
| `EthCall`             | Pure Berechnung oder ein Lesezugriff auf Roms eigenen State                                                                                                                                                                                | Nein              | Ja                                        |
| `CrossStateEthCall`   | Ein Lesezugriff auf die Bytes eines anderen Solana-Kontos, per Emulation vorgeladen. Kein CPI, keine Seiteneffekte.                                                                                                                        | Nein              | Ja                                        |
| `Precompiled`         | Deterministische Kryptografie (die Ethereum-Standard-Precompiles)                                                                                                                                                                          | Nein              | Ja                                        |

Ein Contract verwendet **einen Pfad**: entweder die Legacy-Precompiles (`0xff…07`, `0xff…08`, `0xff…09`, `0x42…16`) oder die zwischengespeicherten (`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 des Cached-Pfads ausgelöst wurde, werden Legacy-Pfad-Lesezugriffe für den Rest der Transaktion abgelehnt. Siehe [Integrieren Sie ein Solana-Programm](/de/entwicklerleitfaden/integrate-solana-program.md).

**Wer zahlt.** Der Solana-Fee-Payer legt jeden Lamport vor, den ein CPI des Legacy-Pfads ausgibt (Rent, Transfers, `swap_gas_to_lamports`); das Programm misst den Kontostand des Zahlers um jeden CPI herum und belastet dem Nutzer den Nettoverbrauch als Gas zum Gaspreis, wobei Lamports zurückerstattet werden, die ein CPI zurückgibt.

**Wer signiert.** Ein Contract, der ein Precompile aufruft, handelt als er selbst: Der Signer ist die externe-Authority-PDA des Contracts (`["EXTERNAL_AUTHORITY", contract]`). Die eigene PDA eines Nutzers signiert nur bei einer Transaktion, die der Nutzer 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 oder vom Operator finanziert ist, nicht weil sie nichts signieren: `create_and_init_mint` signiert weiterhin mit der PDA des äußeren Aufrufers, um die Rent des Mints zu bezahlen, und kann nur einen Mint erstellen, dessen Authorities diese PDA sind, und `invoke` / `invoke_signed` verweigern die nackte Authority (`DelegatecallOwnerAuthority`) und namespace-salzen PDAs mit der Adresse des laufenden Contracts.

Jede Methode ist nicht zahlbar (`msg.value > 0` führt zu einem Revert mit `TransferProhibited`) außer `withdrawal(bytes32)`. Methoden, die als *nur Single-State* markiert sind, werden auf op-geth-stack-Chains abgelehnt. Ein CPI darf weder den Solana-Fee-Payer nennen (außer innerhalb einer einfachen System-Transfer-Instruktion) noch das Rome-Programm und darf das Rome-Programm nicht aufrufen.

## SystemCached (`0xff00000000000000000000000000000000000004`)

PDA-Erstellung + System-Programm-Operationen (allocate, assign, Lamport-Transfer), in ein Overlay gestaged. Das zwischengespeicherte Gegenstück zu Legacy `System @ 0xff..07`s mutierenden Selektoren (Legacy-System behält die reinen Lese-Selektoren).

| Solidity-Signatur                    | Selektor     | Dispatch | Beschreibung                                                           |
| ------------------------------------ | ------------ | -------- | ---------------------------------------------------------------------- |
| `create_pda()`                       | `0xe0402a8d` | `Invoke` | Erstellt die `external_auth` PDA des Aufrufers, rentenfrei, ohne Daten |
| `create_pda(uint64)`                 | `0x4ceab657` | `Invoke` | Dasselbe, mit vom Financier angegebenen Lamports oberhalb der Rent     |
| `create_pda(uint64,bytes32)`         | `0x48e2bb86` | `Invoke` | Salt-abgeleitete PDA mit Lamports                                      |
| `create_pda(bytes32,uint64,bytes32)` | `0xcc258bbf` | `Invoke` | Vom Owner angegebene, Größe-N, salt-abgeleitete                        |
| `allocate(uint64,bytes32)`           | `0x93225c9f` | `Invoke` | Allociert N Bytes auf einer salt-abgeleiteten PDA                      |
| `assign(bytes32,bytes32)`            | `0x8ac00bdc` | `Invoke` | Weist einer salt-abgeleiteten PDA einen neuen Owner zu                 |
| `transfer(address,uint64)`           | `0x5d359fbd` | `Invoke` | Lamport-Transfer an eine von einer EVM-Adresse abgeleitete PDA         |
| `transfer(bytes32,uint64)`           | `0xfd54d1ea` | `Invoke` | Lamport-Transfer an eine rohe Solana-Pubkey                            |
| `transfer(bytes32,uint64,bytes32)`   | `0x875abfc0` | `Invoke` | Lamport-Transfer an eine rohe Pubkey, Quelle salt-abgeleitet           |

## SplCached (`0xff00000000000000000000000000000000000005`)

SPL-Token-/Token-2022-Transfers + ATA-Init + Cross-State-Kontolesezugriffe, in ein Overlay gestaged.

| Solidity-Signatur                               | Selektor     | Dispatch            | Beschreibung                                                                                                                                                                                                                                                                                                                                                                                                                               |
| ----------------------------------------------- | ------------ | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `transfer(address,uint256)`                     | `0xa9059cbb` | `Invoke`            | SPL-Transfer, bei dem der Aufrufer als Owner fungiert, an die ATA einer von einer EVM-Adresse abgeleiteten PDA, aktueller Rollup-Mint                                                                                                                                                                                                                                                                                                      |
| `transfer(bytes32,uint256)`                     | `0x6a467394` | `Invoke`            | Dasselbe, Empfänger als rohe Solana-Pubkey angegeben                                                                                                                                                                                                                                                                                                                                                                                       |
| `transfer(address,uint256,bytes32)`             | `0x57cfeeee` | `Invoke`            | Variante mit explizitem Mint, EVM-Adress-Ziel                                                                                                                                                                                                                                                                                                                                                                                              |
| `transfer(bytes32,uint256,bytes32)`             | `0x7db527f9` | `Invoke`            | Variante mit explizitem Mint, Ziel als rohe Pubkey                                                                                                                                                                                                                                                                                                                                                                                         |
| `transferFrom(address,address,uint256,bytes32)` | `0x401e3367` | `Invoke`            | Variante mit Delegate-Quelle — Authority = `external_auth(caller)`, akzeptiert als ATA-Owner ODER Delegate mit ausreichendem Betrag. Verwendet von `SPL_ERC20_cached.transferFrom` und routergesteuerten Abläufen                                                                                                                                                                                                                          |
| `approve(address,uint256,bytes32)`              | `0x8180f2fc` | `Invoke`            | EVM-Spender-Approve — Owner = `external_auth(caller)`, Delegate = `external_auth(spender_addr)`. Verwendet von `SPL_ERC20_cached.approve`                                                                                                                                                                                                                                                                                                  |
| `mint(address,uint256,bytes32)`                 | `0x1e458bee` | `Invoke`            | Die PDA des Aufrufers signiert als Mint-Authority. Der SPL-Laufzeitcode erzwingt, dass die PDA des Aufrufers == die On-Chain-Mint-Authority ist. Verwendet von `SPL_ERC20_cached.mint_to` und Inbound-Bridge-Abwicklung                                                                                                                                                                                                                    |
| `init(bytes32,bytes32,bytes32)`                 | `0x0b0ad508` | `Invoke`            | `InitializeAccount3` ix (ata, mint, owner)                                                                                                                                                                                                                                                                                                                                                                                                 |
| `account(address)`                              | `0x73b9aa91` | `CrossStateEthCall` | SPL-Kontostatus für die von der PDA der EVM-Adresse abgeleitete ATA (aktueller Rollup-Mint) lesen                                                                                                                                                                                                                                                                                                                                          |
| `account(bytes32)`                              | `0x882358ae` | `CrossStateEthCall` | SPL-Kontostatus für eine rohe ATA-Pubkey lesen                                                                                                                                                                                                                                                                                                                                                                                             |
| `account(address,bytes32)`                      | `0xf9827227` | `CrossStateEthCall` | Dasselbe wie `account(address)` mit einem expliziten Mint.                                                                                                                                                                                                                                                                                                                                                                                 |
| `mint_info(bytes32)`                            | `0xe24bf5d4` | `CrossStateEthCall` | Mint-Fakten, overlay-bewusst: Token-Programm, Dezimalstellen, **aktiviertes** Hook-Programm (0 wenn nicht vorhanden *oder* inert), Gebühren in Bp der aktuellen Epoche und eine Bitmap der vorhandenen Erweiterungen. Derselbe Selektor wie `HelperProgram.mint_info` — eine Fähigkeit, zwei Dispatch-Ziele, weil ein Contract auf dem Cached-Pfad den Legacy-Lesezugriff nicht verwenden kann, nachdem ein Cached-Invoke ausgelöst wurde. |

## ASplCached (`0xff00000000000000000000000000000000000006`)

Erstellung eines Associated Token Accounts, idempotent.

| Solidity-Signatur             | Selektor     | Dispatch | Beschreibung                                                                               |
| ----------------------------- | ------------ | -------- | ------------------------------------------------------------------------------------------ |
| `create_ata()`                | `0xb6d336ed` | `Invoke` | Idempotente ATA-Erstellung für die PDA des Aufrufers × aktueller Rollup-Mint               |
| `create_ata(bytes32)`         | `0x81972e35` | `Invoke` | Idempotente ATA-Erstellung für die PDA des Aufrufers × expliziter Mint                     |
| `create_ata(address)`         | `0x5a7c3259` | `Invoke` | Idempotente ATA-Erstellung für eine von einer EVM-Adresse abgeleitete PDA × aktueller Mint |
| `create_ata(address,bytes32)` | `0x3de2251a` | `Invoke` | Idempotente ATA-Erstellung für EVM-Adresse × expliziter Mint                               |

## WithdrawCached (`0xff0000000000000000000000000000000000000b`)

Legs zum Abheben des Gas-Tokens (nativer Gas → SPL-Wrapper, nativer Gas → SOL, nativer Gas → Caller-PDA), gestaged. Das zwischengespeicherte Gegenstück zu Legacy `Withdraw @ 0x42..16`.

| Solidity-Signatur             | Selektor     | Dispatch   | Beschreibung                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| ----------------------------- | ------------ | ---------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `withdrawal(bytes32) payable` | `0x4d8b0ea4` | `Composed` | Burn `msg.value` Rome-Gas, Transfer an den Solana-Systemkonto-Empfänger                                                                                                                                                                                                                                                                                                                                                                                                            |
| `withdraw_to_pda(uint256)`    | `0x7f3124a0` | `Composed` | Wei verbrennen, Lamports an die `EXTERNAL_AUTHORITY` PDA des Aufrufers einzahlen. Nur Single-State.                                                                                                                                                                                                                                                                                                                                                                                |
| `withdraw_to_ata(uint256)`    | `0x8059abc0` | `Composed` | Wei verbrennen, SPL-Wrapper an die dem Caller gehörende ATA der PDA einzahlen. Nur Single-State. Wrap-Leg der Gas-Wrapper-Bridge.                                                                                                                                                                                                                                                                                                                                                  |
| `deposit(uint256)`            | `0xb6b55f25` | `Composed` | Gegenteil von `withdrawal` — SPL-Transfer von der dem Caller gehörenden ATA der PDA an die sol\_wallet-ATA der Chain auf der Solana-Seite; **mint** `wei` nativer Gas an den Aufrufer auf der EVM-Seite. Reines Minting (kein ausgleichender Debit gegen `Withdraw::ADDRESS` — das SPL-Wallet der Chain ist die wirtschaftliche Deckung, nicht die Precompile-Adresse). Nur Single-State. Unwrap-Leg der Gas-Wrapper-Bridge. Entspricht `HelperProgram.deposit_from_ata` Semantik. |

## System (`0xff00000000000000000000000000000000000007`)

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

| Solidity-Signatur                                 | Selektor     | Dispatch  | 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` | PDA-Ableitung mit konstanter Laufzeit und 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 Program ID zurück (die Identität dieses Precompiles)                |
| `mint_id()`                                       | `0xe132a122` | `EthCall` | Gibt die SPL-Mint-Pubkey des Gas-Tokens der Chain 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`)

**Dual-Purpose-Precompile.** Von den 7 Selektoren unten **führen 2 echtes Solana CPI aus** (`invoke`, `invoke_signed` — dispatchen als `Invoke`) und **5 sind reine Cross-State-Lesezugriffe** (`account_info`, `account_data_at`, `account_u64_at`, `account_lamports`, `pdas_batch_derive` — dispatchen als `CrossStateEthCall`, kein Syscall, kein `found_cpi` Flag gesetzt). Der historische Ausdruck „CPI shortcut selectors“ bezog sich auf die Lese-Selektoren als CU-sparende Ersatzfunktionen für frühere CPI-basierte Reads — sie selbst sind **keine CPIs**. Siehe die Aufschlüsselungstabelle oben in diesem Abschnitt für die vollständige Verhaltensmatrix.

| Solidity-Signatur                                              | Selektor     | Dispatch            | Beschreibung                                                                                                                                                                                                                                                                 |
| -------------------------------------------------------------- | ------------ | ------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `invoke(bytes32,(bytes32,bool,bool)[],bytes)`                  | `0x7480cb86` | `Invoke`            | CPI signiert als `EXTERNAL_AUTHORITY(caller)` wenn dieses Konto als Signer aufgeführt ist (unter DELEGATECALL abgelehnt); keine gesalzten Sub-PDAs. Der Caller übergibt Zielprogramm + Account-Metas + ix-Daten                                                              |
| `invoke_signed(bytes32,(bytes32,bool,bool)[],bytes,bytes32[])` | `0xb94f3733` | `Invoke`            | CPI signiert als `EXTERNAL_AUTHORITY(caller)` bei einem direkten CALL; Salts werden pro-PDA-Seed angehängt. Unter DELEGATECALL wird die nackte Caller-Authority abgelehnt und gesalzte Seeds tragen die Adresse des laufenden Contracts — siehe die Ableitungshinweise unten |
| `account_info(bytes32)`                                        | `0xc13465d9` | `CrossStateEthCall` | Den vollständigen Zustand eines Solana-Kontos lesen (Lamports/Owner/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-Lesezugriff an einem bekannten Offset — spart ABI-Roundtrip                                                                                                                                                                                                  |
| `account_lamports(bytes32)`                                    | `0xde79ed54` | `CrossStateEthCall` | Nur-Lamports-Probe — überspringt Datenabruf                                                                                                                                                                                                                                  |
| `pdas_batch_derive(bytes[][],bytes32)`                         | `0x944336f8` | `CrossStateEthCall` | N unabhängige PDAs gegen ein Programm in einem Dispatch                                                                                                                                                                                                                      |

## HelperProgram (`0xff00000000000000000000000000000000000009`)

Rome-Benutzerhilfen für ATA-/PDA-Erstellung, SPL-Transfers/Approve/Mint, signiert durch die `EXTERNAL_AUTHORITY` PDA des Aufrufers, Gas↔Lamports-Konvertierung, ATA-Deposit und SPL\_ERC20-Reads (`user_balance` / `allowance_of`). Jede Methode ist `not_payable`; Mutationen laufen über `Invoke` (einzelner CPI) außer `deposit_from_ata` (`Composed`, nur Single-State), die drei Read-only- `pda`/`ata` Abfragen (`EthCall`), und die zwei Cross-State-SPL\_ERC20-Lesezugriffe (`CrossStateEthCall` — ein Solana-Kontoabruf).

| Solidity-Signatur                                                | Selektor     | Dispatch            | Beschreibung                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| ---------------------------------------------------------------- | ------------ | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `create_ata(address)`                                            | `0x5a7c3259` | `Invoke`            | ATA für den EVM-Nutzer unter dem Gas-Mint der Chain erstellen                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `create_ata(address,bytes32)`                                    | `0x3de2251a` | `Invoke`            | ATA für den EVM-Nutzer unter einem beliebigen Mint erstellen                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `create_ata_for_key(bytes32,bytes32)`                            | `0xd258a69d` | `Invoke`            | Idempotente ATA-Erstellung für einen beliebigen rohen Solana-Pubkey als Owner (nicht abgeleitet via `external_auth`). Der Operator zahlt die Rent. Verwendet von `SPL_ERC20.bridgeOutToSolana` / `ensureRecipientAta` / `create_token_account` Flows mit rohem Pubkey-Empfänger                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `create_pda(address)`                                            | `0xff3556ca` | `Invoke`            | Erstelle die des Nutzers `EXTERNAL_AUTHORITY` PDA (mietfrei)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `create_pda(address,uint64)`                                     | `0x58e88298` | `Invoke`            | Dasselbe, aber finanziert mit `Lamports` über dem Mietminimum                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `swap_gas_to_lamports(uint64)`                                   | `0x6e3f24e0` | `Invoke`            | Gutschreibe der PDA des Aufrufers mit `n` Lamports vom Solana-Gebührenzahler der Transaktion; der Aufrufer zahlt dafür in Rome-Gas (der Lamport-Betrag des Zahlers innerhalb jeder Legacy-CPI wird zur Transaktionsgebühr hinzugefügt)                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `transfer_lamports(address,uint64)`                              | `0x5fe71665` | `Invoke`            | Verschiebe Lamports von der PDA des Aufrufers zur PDA eines anderen EVM-Benutzers                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `transfer_spl(address,uint64)`                                   | `0xb12be5ba` | `Invoke`            | Sende Chain-Gas-SPL von der ATA der PDA des Aufrufers zur ATA des Zielbenutzers                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `transfer_spl(bytes32,uint64)`                                   | `0xba3a5eac` | `Invoke`            | Sende Chain-Gas-SPL von der ATA der PDA des Aufrufers an eine explizite ATA                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `transfer_spl(address,uint64,bytes32)`                           | `0x53b505e0` | `Invoke`            | Sende SPL mit beliebigem Mint von der ATA der PDA des Aufrufers zur ATA des Zielbenutzers                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `transfer_spl(bytes32,uint64,bytes32)`                           | `0xb6977879` | `Invoke`            | Sende SPL mit beliebigem Mint von der ATA der PDA des Aufrufers an eine explizite ATA                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `transfer_spl(bytes32,bytes32,uint64,bytes32)`                   | `0x766b362a` | `Invoke`            | Delegierten-Variante — der Aufrufer liefert `src_ata` (muss im Besitz der PDA sein ODER die PDA muss der Delegierte mit ausreichender `delegated_amount`)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `transfer_spl(address,address,uint64,bytes32)`                   | `0xe479df56` | `Invoke`            | Adressschlüssel-Delegiertenvariante — leitet beide ATAs intern aus EVM-Adressen ab. Signiert als `external_auth(caller)`; SPL Token akzeptiert die PDA als Eigentümer ODER Delegierten. Verwendet von `SPL_ERC20.transferFrom`                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `transfer_spl_to_signer(uint64,bytes32)`                         | `0x46efa679` | `Invoke`            | Solana-native Austrittsseite. Sendet `Betrag` von `mint` von der ATA der PDA des Aufrufers an die **äußere ATA des Solana-Signierers** ATA für diesen Mint (die eigene Wallet des Benutzers nur auf dem wallet-signierten Solana-Pfad; von MetaMask oder über den Relay ist der Signierer der Proxy-Zahler von Rome; keine EVM-Adressumwandlung). Keine Genehmigung nötig — die PDA des Aufrufers besitzt die Quell-ATA. Kombiniere es mit `ActivateAta` (Slot 18) für eine durchgängige EVM-Nutzung nur mit Solana-Schlüssel. Es erreicht die Wallet auf dem aktuellen v1-Pfad und auf dem älteren Legacy- `DoTxUnsigned` (Slot 17)-Pfad, weil die Wallet auf beiden die Solana-Transaktion signiert. |
| `approve_spl(address,uint64,bytes32)`                            | `0xabf6f675` | `Invoke`            | Caller-PDA als Eigentümer setzt `delegate_pda(spender)` auf der Owner-ATA über SPL `approve_checked`. Verwendet von `SPL_ERC20.approve`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `approve_spl_raw_delegate(bytes32,bytes32,uint64,bytes32,uint8)` | `0x7881d453` | `Invoke`            | SPL `approve_checked` mit vom Aufrufer bereitgestelltem Raw-Pubkey-Delegierten (z. B. Wormhole `authority_signer` PDA, kein EVM-Adressäquivalent). Der Aufrufer übergibt `decimals` um das On-Chain-Mint-Lesen zu überspringen (Einsparung von ca. 30–50K CU). Fest codiert `spl_program = SPL Token`. Verwendet von `RomeBridgeWithdraw.approveBurnETH`                                                                                                                                                                                                                                                                                                                                               |
| `mint_spl(address,uint64,bytes32)`                               | `0xd795522b` | `Invoke`            | Caller-PDA als Mint-Authority mintet über SPL an die ATA des Zielbenutzers `mint_to_checked`. SPL-Laufzeit erzwingt die Übereinstimmung der Authority. Verwendet von `SPL_ERC20.mint_to`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| `create_mint_account(bytes32)`                                   | `0xe97d3291` | `Invoke`            | System-CreateAccount, das eine aus Salt abgeleitete PDA zuweist (`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` | `Invoke`            | SPL Token `InitializeMint2` gegen vorab zugewiesenen Mint. Kein PDA-Signer (mint\_authority/freeze\_authority sind als Daten gespeichert, nicht als Laufzeit-Signer). Verwendet von `ERC20SPLFactory.init_token_mint`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `create_and_init_mint(uint8,bytes32,bool,bytes32,bytes32)`       | `0x20972d0f` | `Composed`          | 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` | `Composed`          | Ziehe SPL von der ATA des Aufrufers in das native Gas von Rome. **Nur Einzelzustand** — auf op-geth-Ketten abgelehnt                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `pda(address)`                                                   | `0x8854a299` | `EthCall`           | Leite die des Benutzers ab `EXTERNAL_AUTHORITY` PDA — nur lesend                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `pda_with_salt(address,bytes32)`                                 | `0x5c6d04b3` | `EthCall`           | Salt-abgeleitete `EXTERNAL_AUTHORITY` PDA in einem einzigen Dispatch. Verdichtet die 2-Aufruf- `rome_evm_program_id() + find_program_address()` Zusammensetzung. Verwendet von `RomeEVMAccount.pda_with_salt`, `RomeBridgeWithdraw.{burnUSDC,burnETH}`                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `ata(address)`                                                   | `0x31db4f82` | `EthCall`           | Ableiten `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` | Benutzer-ATA lesen `Betrag` (SPL-TokenAccount-Offset 64). Gibt 0 zurück, wenn die ATA nicht existiert (Probe auf frischer Kette). Verdichtet 3 v1-Dispatches. Verwendet von `SPL_ERC20.balanceOf`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `mint_info(bytes32)`                                             | `0xe24bf5d4` | `CrossStateEthCall` | Mint-Fakten für einen Caller auf dem Legacy-Pfad: Token-Programm, Dezimalstellen, **aktiviertes** Hook-Programm (0 wenn nicht vorhanden *oder* (inert), aktuelle Epoch-Gebühren in BpS, Bitmap der vorhandenen Erweiterungen. Spiegelbildlich auf `SplCached` mit demselben Selektor. `feeBps` ist ein **Prädikat** — es sagt aus, dass eine Gebühr aktiviert ist, es ist kein Operand, da die eigentliche Gebühr durch `maximum_fee` gedeckelt ist, was dieses absichtlich nicht enthält.                                                                                                                                                                                                             |
| `allowance_of(address,address,bytes32)`                          | `0xed72dbc8` | `CrossStateEthCall` | Lese delegated\_amount der Owner-ATA mit **Delegierten-Gleichheitsprüfung** — gibt 0 zurück, außer der On-Chain-Delegierte == `external_auth(spender)`. ERC-20-semantisch korrekt (HARTES ERFORDERNIS). Verwendet von `SPL_ERC20.allowance`                                                                                                                                                                                                                                                                                                                                                                                                                                                            |

## Auszahlung (`0x4200000000000000000000000000000000000016`)

Rome → Solana native Gas-Abhebung.

| Solidity-Signatur          | Selektor     | Dispatch               | Beschreibung                                                                                                     |
| -------------------------- | ------------ | ---------------------- | ---------------------------------------------------------------------------------------------------------------- |
| `withdrawal(bytes32)`      | `0x4d8b0ea4` | `Composed` (`zahlbar`) | Burn `msg.value` Rome-Gas; Mint+Transfer an ein Solana-Systemkonto `zu`. Die einzige zahlbare Precompile-Methode |
| `withdraw_to_pda(uint256)` | `0x7f3124a0` | `Composed`             | Verbrenne Gas; zahle auf die `EXTERNAL_AUTHORITY` PDA ein. **Nur Einzelzustand**                                 |
| `withdraw_to_ata(uint256)` | `0x8059abc0` | `Composed`             | Verbrenne Gas; zahle auf `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.