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

# Referensi Precompile

Setiap metode pada precompile interoperabilitas Solana milik Rome — alamat, tanda tangan Solidity, selector, dan apakah metode tersebut membaca, memanggil, atau menyiapkan CPI.

Selector yang didispatch oleh program on-chain Rome, melalui precompile. Selector = `keccak256(signature)[:4]`; setiap baris di bawah diverifikasi terhadap itu. Antarmuka Solidity berada di [`rome-solidity/contracts/interface.sol`](https://github.com/rome-protocol/rome-solidity/blob/master/contracts/interface.sol).

**Baca kolom Dispatch sebelum yang lain.** Ini menjelaskan apa yang dilakukan suatu metode terhadap state Solana:

| Dispatch              | Apa yang terjadi                                                                                                                                                                                                                 | CPI Solana nyata | Diperbolehkan dalam eksekusi iteratif |
| --------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------- | ------------------------------------- |
| `Invoke` / `Tersusun` | Satu atau lebih CPI, ditandatangani sebagai PDA otoritas eksternal milik pemanggil tempat seed berlaku. Pada jalur **legacy** mereka dijalankan segera; pada jalur **cached** mereka dipentaskan dan dikomit di akhir transaksi. | Ya               | Legacy: **tidak**. Cached: ya         |
| `EthCall`             | Komputasi murni atau pembacaan state milik Rome sendiri                                                                                                                                                                          | Tidak            | Ya                                    |
| `CrossStateEthCall`   | Pembacaan byte dari akun Solana lain, yang dimuat sebelumnya oleh emulasi. Tanpa CPI, tanpa efek samping.                                                                                                                        | Tidak            | Ya                                    |
| `Precompiled`         | Kriptografi deterministik (precompile standar Ethereum)                                                                                                                                                                          | Tidak            | Ya                                    |

Sebuah kontrak menggunakan **satu jalur**: baik precompile legacy (`0xff…07`, `0xff…08`, `0xff…09`, `0x42…16`) atau yang cached (`0xff…04`, `0xff…05`, `0xff…06`, `0xff…0b`). Mencampur panggilan yang memodifikasi dari keduanya dalam satu transaksi ditolak saat runtime. Pembacaan tetap diperbolehkan, dengan satu pengecualian: setelah invoke jalur cached dipicu, pembacaan jalur legacy ditolak untuk sisa transaksi. Lihat [Integrasikan program Solana](/id/panduan-pengembang/integrate-solana-program.md).

**Siapa yang membayar.** Pembayar biaya Solana menalangi setiap lamport yang dibelanjakan CPI jalur legacy (sewa, transfer, `swap_gas_to_lamports`); program mengukur saldo pembayar di sekitar setiap CPI dan menagihkan pengeluaran bersih kepada pengguna sebagai gas pada harga gas, sambil mengembalikan lamport yang dikembalikan CPI.

**Siapa yang menandatangani.** Kontrak yang memanggil precompile bertindak sebagai dirinya sendiri: penandatangan adalah PDA otoritas eksternal kontrak (`["EXTERNAL_AUTHORITY", contract]`). PDA milik pengguna sendiri hanya menandatangani pada transaksi yang dikirim pengguna langsung ke alamat precompile. Dalam `DELEGATECALL` / `CALLCODE`, selector yang memodifikasi ditolak kecuali `create_ata*`, `create_pda*`, `swap_gas_to_lamports`, `init_spl_mint` dan `create_and_init_mint` pada HelperProgram, `create_ata*` pada ASplCached, dan `invoke` / `invoke_signed` pada CpiProgram. Mereka dikecualikan karena targetnya terikat pada pemanggil atau didanai oleh operator, bukan karena mereka tidak menandatangani apa pun: `create_and_init_mint` tetap menandatangani dengan PDA pemanggil luar untuk membayar sewa mint dan hanya boleh membuat mint yang otoritasnya adalah PDA itu, dan `invoke` / `invoke_signed` menolak otoritas mentah (`DelegatecallOwnerAuthority`) dan memberi namespace pada PDA yang diberi salt menggunakan alamat kontrak yang sedang berjalan.

Setiap metode bersifat non-payable (`msg.value > 0` revert dengan `TransferProhibited`) kecuali `withdrawal(bytes32)`. Metode yang ditandai *hanya satu-state* ditolak pada chain op-geth-stack. Sebuah CPI tidak boleh menyebut pembayar biaya Solana (kecuali di dalam instruksi transfer System biasa) atau program Rome, dan tidak boleh memanggil program Rome.

## SystemCached (`0xff00000000000000000000000000000000000004`)

Pembuatan PDA + operasi program system (allocate, assign, transfer lamport), dipentaskan ke overlay. Padanan cached untuk `System @ 0xff..07`selector yang memodifikasi (System legacy tetap mempertahankan selector baca murni).

| Signature Solidity                   | Selector     | Dispatch | Deskripsi                                                         |
| ------------------------------------ | ------------ | -------- | ----------------------------------------------------------------- |
| `create_pda()`                       | `0xe0402a8d` | `Invoke` | Membuat `external_auth` PDA milik pemanggil, bebas-rent, data nol |
| `create_pda(uint64)`                 | `0x4ceab657` | `Invoke` | Sama, dengan lamport yang ditentukan funder di atas rent          |
| `create_pda(uint64,bytes32)`         | `0x48e2bb86` | `Invoke` | PDA turunan salt dengan lamport                                   |
| `create_pda(bytes32,uint64,bytes32)` | `0xcc258bbf` | `Invoke` | Owner ditentukan, ukuran-N, turunan salt                          |
| `allocate(uint64,bytes32)`           | `0x93225c9f` | `Invoke` | Alokasikan N byte pada PDA turunan salt                           |
| `assign(bytes32,bytes32)`            | `0x8ac00bdc` | `Invoke` | Menetapkan PDA turunan salt ke owner baru                         |
| `transfer(address,uint64)`           | `0x5d359fbd` | `Invoke` | Transfer lamport ke PDA yang diturunkan dari alamat EVM           |
| `transfer(bytes32,uint64)`           | `0xfd54d1ea` | `Invoke` | Transfer lamport ke pubkey Solana mentah                          |
| `transfer(bytes32,uint64,bytes32)`   | `0x875abfc0` | `Invoke` | Transfer lamport ke pubkey mentah, sumber turunan salt            |

## SplCached (`0xff00000000000000000000000000000000000005`)

Transfer SPL Token / Token-2022 + inisialisasi ATA + pembacaan akun lintas-state, dipentaskan ke overlay.

| Signature Solidity                              | Selector     | Dispatch            | Deskripsi                                                                                                                                                                                                                                                                                                                                                                          |
| ----------------------------------------------- | ------------ | ------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `transfer(address,uint256)`                     | `0xa9059cbb` | `Invoke`            | Transfer SPL oleh pemanggil sebagai owner ke ATA dari PDA yang diturunkan dari alamat EVM, mint rollup saat ini                                                                                                                                                                                                                                                                    |
| `transfer(bytes32,uint256)`                     | `0x6a467394` | `Invoke`            | Sama, penerima diberikan sebagai pubkey Solana mentah                                                                                                                                                                                                                                                                                                                              |
| `transfer(address,uint256,bytes32)`             | `0x57cfeeee` | `Invoke`            | Varian mint eksplisit, tujuan alamat EVM                                                                                                                                                                                                                                                                                                                                           |
| `transfer(bytes32,uint256,bytes32)`             | `0x7db527f9` | `Invoke`            | Varian mint eksplisit, tujuan pubkey mentah                                                                                                                                                                                                                                                                                                                                        |
| `transferFrom(address,address,uint256,bytes32)` | `0x401e3367` | `Invoke`            | Varian sumber delegasi — otoritas = `external_auth(caller)`, diterima sebagai owner ATA ATAU delegate dengan jumlah yang cukup. Digunakan oleh `SPL_ERC20_cached.transferFrom` dan alur yang digerakkan router                                                                                                                                                                     |
| `approve(address,uint256,bytes32)`              | `0x8180f2fc` | `Invoke`            | Approve spender EVM — owner = `external_auth(caller)`, delegate = `external_auth(spender_addr)`. Digunakan oleh `SPL_ERC20_cached.approve`                                                                                                                                                                                                                                         |
| `mint(address,uint256,bytes32)`                 | `0x1e458bee` | `Invoke`            | PDA pemanggil menandatangani sebagai otoritas mint. Runtime SPL menegakkan bahwa PDA pemanggil == otoritas mint on-chain. Digunakan oleh `SPL_ERC20_cached.mint_to` dan penyelesaian bridge masuk                                                                                                                                                                                  |
| `init(bytes32,bytes32,bytes32)`                 | `0x0b0ad508` | `Invoke`            | `InitializeAccount3` ix (ata, mint, owner)                                                                                                                                                                                                                                                                                                                                         |
| `account(address)`                              | `0x73b9aa91` | `CrossStateEthCall` | Baca state akun SPL untuk ATA turunan PDA milik alamat EVM (mint rollup saat ini)                                                                                                                                                                                                                                                                                                  |
| `account(bytes32)`                              | `0x882358ae` | `CrossStateEthCall` | Baca state akun SPL untuk pubkey ATA mentah                                                                                                                                                                                                                                                                                                                                        |
| `account(address,bytes32)`                      | `0xf9827227` | `CrossStateEthCall` | Sama seperti `account(address)` dengan mint eksplisit.                                                                                                                                                                                                                                                                                                                             |
| `mint_info(bytes32)`                            | `0xe24bf5d4` | `CrossStateEthCall` | Fakta mint, sadar overlay: program token, desimal, **hook yang diaktifkan** program hook (0 bila tidak ada *atau* inert), fee bps epoch saat ini, dan bitmap keberadaan ekstensi. Selector yang sama dengan `HelperProgram.mint_info` — satu kapabilitas, dua rumah dispatch, karena kontrak jalur cached tidak dapat memakai pembacaan legacy setelah invoke cached telah dipicu. |

## ASplCached (`0xff00000000000000000000000000000000000006`)

Pembuatan Associated Token Account, idempoten.

| Signature Solidity            | Selector     | Dispatch | Deskripsi                                                            |
| ----------------------------- | ------------ | -------- | -------------------------------------------------------------------- |
| `create_ata()`                | `0xb6d336ed` | `Invoke` | Pembuatan ATA idempoten untuk caller-PDA × mint rollup saat ini      |
| `create_ata(bytes32)`         | `0x81972e35` | `Invoke` | Pembuatan ATA idempoten untuk caller-PDA × mint eksplisit            |
| `create_ata(address)`         | `0x5a7c3259` | `Invoke` | Pembuatan ATA idempoten untuk PDA turunan alamat EVM × mint saat ini |
| `create_ata(address,bytes32)` | `0x3de2251a` | `Invoke` | Pembuatan ATA idempoten untuk alamat EVM × mint eksplisit            |

## WithdrawCached (`0xff0000000000000000000000000000000000000b`)

Jalur penarikan token gas (gas native → wrapper SPL, gas native → SOL, gas native → caller PDA), dipentaskan. Padanan cached untuk `Withdraw @ 0x42..16`.

| Signature Solidity            | Selector     | Dispatch   | Deskripsi                                                                                                                                                                                                                                                                                                                                                                                                                               |
| ----------------------------- | ------------ | ---------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `withdrawal(bytes32) payable` | `0x4d8b0ea4` | `Tersusun` | Burn `msg.value` Gas Rome, transfer ke penerima akun sistem Solana                                                                                                                                                                                                                                                                                                                                                                      |
| `withdraw_to_pda(uint256)`    | `0x7f3124a0` | `Tersusun` | Bakarkan wei, setorkan lamport ke `EXTERNAL_AUTHORITY` PDA milik pemanggil. Hanya satu-state.                                                                                                                                                                                                                                                                                                                                           |
| `withdraw_to_ata(uint256)`    | `0x8059abc0` | `Tersusun` | Bakarkan wei, setorkan wrapper SPL ke ATA milik PDA pemanggil. Hanya satu-state. Jalur wrap dari jembatan gas-wrapper.                                                                                                                                                                                                                                                                                                                  |
| `deposit(uint256)`            | `0xb6b55f25` | `Tersusun` | Kebalikan dari `withdrawal` — transfer SPL dari ATA milik PDA pemanggil ke ATA sol\_wallet chain di sisi Solana; **mint** `wei` gas native ke pemanggil di sisi EVM. Mint murni (tanpa debit penyeimbang terhadap `Withdraw::ADDRESS` — wallet SPL milik chain adalah penopang ekonominya, bukan alamat precompile). Hanya satu-state. Jalur unwrap dari jembatan gas-wrapper. Sesuai dengan `HelperProgram.deposit_from_ata` semantik. |

## System (`0xff00000000000000000000000000000000000007`)

Derivasi PDA + konversi base58 + utilitas bergaya identity. Precompile baca-murni — setiap metode `EthCall` (tanpa efek samping Solana).

| Signature Solidity                                | Selector     | Dispatch  | Deskripsi                                                                   |
| ------------------------------------------------- | ------------ | --------- | --------------------------------------------------------------------------- |
| `find_program_address(bytes32,(bytes)[])`         | `0x27e3edda` | `EthCall` | Solana `find_program_address` melalui syscall — mengembalikan `(pda, bump)` |
| `create_program_address(bytes32,(bytes)[],uint8)` | `0xb99f29e1` | `EthCall` | Derivasi PDA waktu-konstan dengan bump yang diketahui                       |
| `rome_evm_program_id()`                           | `0xb76fd45b` | `EthCall` | Mengembalikan ID program Solana untuk program Rome EVM ini                  |
| `program_id()`                                    | `0x77764881` | `EthCall` | Mengembalikan ID Program System Rome (identitas precompile ini)             |
| `mint_id()`                                       | `0xe132a122` | `EthCall` | Mengembalikan pubkey mint SPL token gas chain (`OwnerInfo.chain_mint_id`)   |
| `operator()`                                      | `0x570ca735` | `EthCall` | Mengembalikan penandatangan Solana dari tx Rome luar                        |
| `bytes32_to_base58(bytes32)`                      | `0xfa2b1a5f` | `EthCall` | Byte pubkey → string base58                                                 |
| `base58_to_bytes32(bytes)`                        | `0x5df01b72` | `EthCall` | string base58 → byte pubkey                                                 |

## CpiProgram (`0xff00000000000000000000000000000000000008`)

**Precompile dengan dua tujuan.** Dari 7 selector di bawah ini, **2 melakukan CPI Solana nyata** (`invoke`, `invoke_signed` — didispatch sebagai `Invoke`dan **5 adalah pembacaan lintas-state murni** (`account_info`, `account_data_at`, `account_u64_at`, `account_lamports`, `pdas_batch_derive` — didispatch sebagai `CrossStateEthCall`, tanpa syscall, tanpa `found_cpi` flag diset). Frasa historis "CPI shortcut selectors" merujuk pada selector baca sebagai pengganti hemat-CU untuk pembacaan berbasis CPI sebelumnya — mereka sendiri **bukan CPI**. Lihat tabel disambiguasi di bagian atas seksi ini untuk matriks perilaku lengkap.

| Signature Solidity                                             | Selector     | Dispatch            | Deskripsi                                                                                                                                                                                                                                                                   |
| -------------------------------------------------------------- | ------------ | ------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `invoke(bytes32,(bytes32,bool,bool)[],bytes)`                  | `0x7480cb86` | `Invoke`            | CPI ditandatangani sebagai `EXTERNAL_AUTHORITY(caller)` ketika akun itu terdaftar sebagai penandatangan (ditolak di bawah DELEGATECALL); tanpa sub-PDA yang diberi salt. Pemanggil meneruskan program target + meta akun + data ix                                          |
| `invoke_signed(bytes32,(bytes32,bool,bool)[],bytes,bytes32[])` | `0xb94f3733` | `Invoke`            | CPI ditandatangani sebagai `EXTERNAL_AUTHORITY(caller)` pada CALL langsung; salt ditambahkan per seed PDA. Di bawah DELEGATECALL, otoritas pemanggil mentah ditolak dan seed yang diberi salt membawa alamat kontrak yang sedang berjalan — lihat catatan derivasi di bawah |
| `account_info(bytes32)`                                        | `0xc13465d9` | `CrossStateEthCall` | Baca state lengkap akun Solana (lamport/owner/flag/data)                                                                                                                                                                                                                    |
| `account_data_at(bytes32,uint16,uint16)`                       | `0x593762e8` | `CrossStateEthCall` | Baca irisan dari buffer data akun Solana mana pun                                                                                                                                                                                                                           |
| `account_u64_at(bytes32,uint16)`                               | `0xb317d4c1` | `CrossStateEthCall` | Pembacaan u64 LE bertipe pada offset yang diketahui — menghemat roundtrip ABI                                                                                                                                                                                               |
| `account_lamports(bytes32)`                                    | `0xde79ed54` | `CrossStateEthCall` | Probe hanya-lamport — melewati pengambilan data                                                                                                                                                                                                                             |
| `pdas_batch_derive(bytes[][],bytes32)`                         | `0x944336f8` | `CrossStateEthCall` | N PDA independen terhadap satu program dalam satu dispatch                                                                                                                                                                                                                  |

## HelperProgram (`0xff00000000000000000000000000000000000009`)

Helper yang menghadap pengguna Rome untuk pembuatan ATA/PDA, transfer/approve/mint SPL yang ditandatangani oleh PDA pemanggil, konversi gas↔lamport, deposit ATA, dan pembacaan yang menghadap SPL\_ERC20 ( `EXTERNAL_AUTHORITY` user\_balance`allowance_of` / `). Setiap metode bersifat`not\_payable `; jalur mutasi melalui`(satu CPI) kecuali `Invoke` deposit\_from\_ata `(hanya satu-state), tiga query baca-saja` (`Tersusun`pda `ata`/`query (` ), dan dua pembacaan SPL\_ERC20 lintas-state (`EthCall`— satu pengambilan akun Solana).`CrossStateEthCall` — satu pengambilan akun Solana).

| Signature Solidity                                               | Selector     | Dispatch            | Deskripsi                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| ---------------------------------------------------------------- | ------------ | ------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `create_ata(address)`                                            | `0x5a7c3259` | `Invoke`            | Buat ATA untuk pengguna EVM di bawah mint gas chain                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `create_ata(address,bytes32)`                                    | `0x3de2251a` | `Invoke`            | Buat ATA untuk pengguna EVM di bawah mint arbitrer                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `create_ata_for_key(bytes32,bytes32)`                            | `0xd258a69d` | `Invoke`            | Pembuatan ATA idempoten untuk pubkey Solana mentah arbitrer sebagai owner (tidak diturunkan via `external_auth`). Operator membayar rent. Digunakan oleh `SPL_ERC20.bridgeOutToSolana` / `ensureRecipientAta` / `create_token_account` alur penerima pubkey mentah                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `create_pda(address)`                                            | `0xff3556ca` | `Invoke`            | Buat milik pengguna `EXTERNAL_AUTHORITY` PDA (bebas sewa)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| `create_pda(address,uint64)`                                     | `0x58e88298` | `Invoke`            | Sama, tetapi didanai dengan `lamports` di atas batas sewa minimum                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `swap_gas_to_lamports(uint64)`                                   | `0x6e3f24e0` | `Invoke`            | Kreditkan PDA pemanggil dengan `n` lamports dari pembayar biaya Solana pada transaksi; pemanggil membayarnya dalam gas Rome (pengeluaran lamport pembayar di dalam CPI legacy apa pun ditambahkan ke biaya transaksi)                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `transfer_lamports(address,uint64)`                              | `0x5fe71665` | `Invoke`            | Pindahkan lamports dari PDA pemanggil ke PDA pengguna EVM lain                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `transfer_spl(address,uint64)`                                   | `0xb12be5ba` | `Invoke`            | Kirim SPL gas rantai dari ATA milik PDA pemanggil ke ATA pengguna tujuan                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `transfer_spl(bytes32,uint64)`                                   | `0xba3a5eac` | `Invoke`            | Kirim SPL gas rantai dari ATA milik PDA pemanggil ke ATA yang ditentukan secara eksplisit                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| `transfer_spl(address,uint64,bytes32)`                           | `0x53b505e0` | `Invoke`            | Kirim SPL dengan mint arbitrer dari ATA milik PDA pemanggil ke ATA pengguna tujuan                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `transfer_spl(bytes32,uint64,bytes32)`                           | `0xb6977879` | `Invoke`            | Kirim SPL dengan mint arbitrer dari ATA milik PDA pemanggil ke ATA yang ditentukan secara eksplisit                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `transfer_spl(bytes32,bytes32,uint64,bytes32)`                   | `0x766b362a` | `Invoke`            | Varian delegasi — pemanggil menyediakan `src_ata` (harus dimiliki PDA ATAU PDA harus menjadi delegasi dengan cukup `delegated_amount`)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `transfer_spl(address,address,uint64,bytes32)`                   | `0xe479df56` | `Invoke`            | Varian delegasi berbasis alamat — menurunkan kedua ATA dari alamat EVM secara internal. Menandatangani sebagai `external_auth(caller)`; SPL Token menerima PDA sebagai pemilik ATAU delegasi. Digunakan oleh `SPL_ERC20.transferFrom`                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `transfer_spl_to_signer(uint64,bytes32)`                         | `0x46efa679` | `Invoke`            | Jalur keluar native Solana. Mengirim `jumlah` dari `mint` dari ATA milik PDA pemanggil ke **milik penandatangan Solana luar** ATA untuk mint tersebut (hanya dompet milik pengguna pada jalur Solana yang ditandatangani oleh dompet; dari MetaMask atau melalui relay, penandatangan adalah pembayar proksi Rome; tidak ada konversi alamat EVM). Tidak perlu approve — PDA pemanggil memiliki ATA sumber. Pasangkan dengan `ActivateAta` (slot 18) untuk penggunaan EVM ujung-ke-ujung hanya dengan kunci Solana. Ini menjangkau dompet pada jalur v1 saat ini dan pada legacy yang lebih lama `DoTxUnsigned` (slot 17), karena dompet menandatangani transaksi Solana pada keduanya. |
| `approve_spl(address,uint64,bytes32)`                            | `0xabf6f675` | `Invoke`            | PDA pemanggil sebagai pemilik menetapkan `delegate_pda(spender)` pada ATA milik pemilik melalui SPL `approve_checked`. Digunakan oleh `SPL_ERC20.approve`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| `approve_spl_raw_delegate(bytes32,bytes32,uint64,bytes32,uint8)` | `0x7881d453` | `Invoke`            | SPL `approve_checked` dengan delegasi pubkey mentah yang disediakan pemanggil (mis., Wormhole `authority_signer` PDA, tidak ada padanan alamat EVM). Pemanggil memberikan `decimals` untuk melewati pembacaan mint on-chain (hemat \~30-50K CU). Dihardcode `spl_program = SPL Token`. Digunakan oleh `RomeBridgeWithdraw.approveBurnETH`                                                                                                                                                                                                                                                                                                                                               |
| `mint_spl(address,uint64,bytes32)`                               | `0xd795522b` | `Invoke`            | PDA pemanggil sebagai otoritas mint mencetak ke ATA pengguna tujuan melalui SPL `mint_to_checked`. Runtime SPL menegakkan kecocokan otoritas. Digunakan oleh `SPL_ERC20.mint_to`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `create_mint_account(bytes32)`                                   | `0xe97d3291` | `Invoke`            | System CreateAccount yang mengalokasikan PDA turunan salt (`external_auth_with_salt(caller, salt)`) dengan space=82 yang dimiliki SPL Token. Pendana = PDA external\_auth milik pemanggil. Dua penandatangan PDA. Digunakan oleh `ERC20SPLFactory.create_token_mint`                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `init_spl_mint(bytes32,uint8,bytes32,bool,bytes32)`              | `0x4f75e987` | `Invoke`            | SPL Token `InitializeMint2` terhadap mint yang sudah dialokasikan sebelumnya. Tidak ada penandatangan PDA (mint\_authority/freeze\_authority disimpan sebagai data, bukan penandatangan runtime). Digunakan oleh `ERC20SPLFactory.init_token_mint`                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `create_and_init_mint(uint8,bytes32,bool,bytes32,bytes32)`       | `0x20972d0f` | `Tersusun`          | Gabungan: System CreateAccount + SPL InitializeMint2 dalam satu dispatch. Menghemat 1 envelope Rome DoTx dibandingkan dengan `create_mint_account` + `init_spl_mint` pemanggilan                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `deposit_from_ata(uint256)`                                      | `0x4479b709` | `Tersusun`          | Tarik SPL dari ATA pemanggil ke gas native Rome. **Hanya satu state** — ditolak pada chain op-geth                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `pda(address)`                                                   | `0x8854a299` | `EthCall`           | Turunkan milik pengguna `EXTERNAL_AUTHORITY` PDA — hanya baca                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `pda_with_salt(address,bytes32)`                                 | `0x5c6d04b3` | `EthCall`           | Turunan salt `EXTERNAL_AUTHORITY` PDA dalam satu dispatch. Merangkum panggilan 2 kali di sisi Solidity `rome_evm_program_id() + find_program_address()` komposisi. Digunakan oleh `RomeEVMAccount.pda_with_salt`, `RomeBridgeWithdraw.{burnUSDC,burnETH}`                                                                                                                                                                                                                                                                                                                                                                                                                               |
| `ata(address)`                                                   | `0x31db4f82` | `EthCall`           | Turunkan `getATA(user_pda, chain_mint_id)` — menggabungkan EXT\_AUTH + ATA — hanya baca                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `ata(address,bytes32)`                                           | `0xfeb1c647` | `EthCall`           | Sama dengan mint eksplisit — hanya baca                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `user_balance(address,bytes32)`                                  | `0xdd0119c8` | `CrossStateEthCall` | Baca ATA pengguna `jumlah` (offset 64 TokenAccount SPL). Mengembalikan 0 jika ATA tidak ada (probe chain baru). Merangkum 3 dispatch v1. Digunakan oleh `SPL_ERC20.balanceOf`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `mint_info(bytes32)`                                             | `0xe24bf5d4` | `CrossStateEthCall` | Fakta mint untuk pemanggil jalur legacy: program token, desimal, **hook yang diaktifkan** program hook (0 bila tidak ada *atau* inert), bps biaya epoch saat ini, bitmap keberadaan ekstensi. Dicerminkan pada `SplCached` pada selector yang sama. `feeBps` adalah sebuah **predikat** — ini menyatakan bahwa biaya telah diaktifkan, bukan operand, karena biaya sebenarnya dibatasi oleh `maximum_fee` yang dengan sengaja tidak dibawa oleh ini.                                                                                                                                                                                                                                    |
| `allowance_of(address,address,bytes32)`                          | `0xed72dbc8` | `CrossStateEthCall` | Baca delegated\_amount ATA milik pemilik dengan **pemeriksaan kesamaan delegasi** — mengembalikan 0 kecuali delegasi on-chain == `external_auth(spender)`. Sesuai semantik ERC-20 (SYARAT WAJIB). Digunakan oleh `SPL_ERC20.allowance`                                                                                                                                                                                                                                                                                                                                                                                                                                                  |

## Tarik keluar (`0x4200000000000000000000000000000000000016`)

Penarikan gas native Rome → Solana.

| Signature Solidity         | Selector     | Dispatch               | Deskripsi                                                                                                        |
| -------------------------- | ------------ | ---------------------- | ---------------------------------------------------------------------------------------------------------------- |
| `withdrawal(bytes32)`      | `0x4d8b0ea4` | `Tersusun` (`payable`) | Burn `msg.value` gas Rome; mint+transfer ke akun sistem Solana `ke`. Satu-satunya metode precompile yang payable |
| `withdraw_to_pda(uint256)` | `0x7f3124a0` | `Tersusun`             | Bakar gas; setorkan ke `EXTERNAL_AUTHORITY` PDA. **Hanya satu state**                                            |
| `withdraw_to_ata(uint256)` | `0x8059abc0` | `Tersusun`             | Bakar gas; setorkan ke `getATA(caller_pda, chain_mint_id)`. **Hanya satu state**                                 |


---

# 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/id/referensi/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.