> 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 dieksekusi program on-chain Rome, menurut 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.** Itu menjelaskan apa yang dilakukan sebuah metode terhadap state Solana:

| Dispatch              | Apa yang terjadi                                                                                                                                                                                                                               | CPI Solana sungguhan | Diizinkan dalam eksekusi iteratif |
| --------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------- | --------------------------------- |
| `Invoke` / `Tersusun` | Satu atau lebih CPI, ditandatangani sebagai PDA otoritas eksternal milik pemanggil jika seed berlaku. Pada **legacy** jalur legacy, mereka berjalan segera; pada **cached** jalur cached, mereka dipentaskan dan dikomit pada akhir transaksi. | Ya                   | Legacy: **tidak**. Cached: ya     |
| `EthCall`             | Kalkulasi murni atau pembacaan state milik Rome sendiri                                                                                                                                                                                        | Tidak                | Ya                                |
| `CrossStateEthCall`   | Pembacaan byte milik akun Solana lain, 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 memutasi dari keduanya dalam satu transaksi ditolak saat runtime. Pembacaan tetap diizinkan, dengan satu pengecualian: setelah invoke jalur cached dipicu, pembacaan jalur legacy ditolak untuk sisa transaksi. Lihat [Integrasikan program Solana](https://docs.rome.builders/id/panduan-pengembang/integrate-solana-program.md).

**Siapa yang membayar.** Pembayar biaya Solana menalangi setiap lamport yang dihabiskan CPI jalur legacy (rent, transfer, `swap_gas_to_lamports`; program mengukur saldo pembayar di sekitar setiap CPI dan membebankan pengeluaran bersih ke pengguna sebagai gas pada harga gas, sambil mengembalikan lamport yang dikembalikan oleh 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. Di bawah `DELEGATECALL` / `CALLCODE`, selector yang memutasi 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 ke pemanggil atau didanai oleh operator, bukan karena mereka tidak menandatangani apa pun: `create_and_init_mint` tetap menandatangani dengan PDA pemanggil luar untuk membayar rent mint dan hanya boleh membuat mint yang otoritasnya adalah PDA itu, dan `invoke` / `invoke_signed` menolak otoritas mentah (`DelegatecallOwnerAuthority`) dan menambahkan salt namespace pada PDA dengan alamat kontrak yang sedang berjalan.

Setiap metode bersifat non-payable (`msg.value > 0` revert dengan `TransferProhibited`) kecuali `withdrawal(bytes32)`. Metode yang ditandai *hanya single-state* ditolak pada rantai 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 system-program (allocate, assign, transfer lamport), dipentaskan ke overlay. Padanan cached untuk legacy `System @ 0xff..07`selector yang memutasi (legacy System tetap mempertahankan selector baca murni).

| Tanda tangan Solidity                | Selector     | Dispatch | Deskripsi                                                           |
| ------------------------------------ | ------------ | -------- | ------------------------------------------------------------------- |
| `create_pda()`                       | `0xe0402a8d` | `Invoke` | Membuat `external_auth` PDA milik pemanggil, bebas sewa, nol-data   |
| `create_pda(uint64)`                 | `0x4ceab657` | `Invoke` | Sama, dengan lamport yang ditentukan pendana di atas rent           |
| `create_pda(uint64,bytes32)`         | `0x48e2bb86` | `Invoke` | PDA yang diturunkan dari salt dengan lamport                        |
| `create_pda(bytes32,uint64,bytes32)` | `0xcc258bbf` | `Invoke` | PDA yang ditentukan pemilik, ukuran-N, diturunkan dari salt         |
| `allocate(uint64,bytes32)`           | `0x93225c9f` | `Invoke` | Mengalokasikan N byte pada PDA yang diturunkan dari salt            |
| `assign(bytes32,bytes32)`            | `0x8ac00bdc` | `Invoke` | Menetapkan PDA yang diturunkan dari salt ke pemilik 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 yang diturunkan dari salt |

## SplCached (`0xff00000000000000000000000000000000000005`)

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

| Tanda tangan Solidity                           | Selector     | Dispatch            | Deskripsi                                                                                                                                                                                                                                                                                                                                            |
| ----------------------------------------------- | ------------ | ------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `transfer(address,uint256)`                     | `0xa9059cbb` | `Invoke`            | Transfer SPL atas nama pemanggil sebagai pemilik ke ATA milik 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 delegate — otoritas = `external_auth(caller)`, diterima sebagai pemilik 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 — pemilik = `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 yang diturunkan dari 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, **armed** program hook (0 jika tidak ada *atau* inert), fee bps epoch saat ini, dan bitmap keberadaan ekstensi. Selector sama seperti `HelperProgram.mint_info` — satu kapabilitas, dua rumah dispatch, karena kontrak jalur cached tidak dapat memakai read legacy setelah invoke cached dipicu. |

## ASplCached (`0xff00000000000000000000000000000000000006`)

Pembuatan Associated Token Account, idempotent.

| Tanda tangan Solidity         | Selector     | Dispatch | Deskripsi                                                                          |
| ----------------------------- | ------------ | -------- | ---------------------------------------------------------------------------------- |
| `create_ata()`                | `0xb6d336ed` | `Invoke` | Pembuatan ATA idempotent untuk PDA pemanggil × mint rollup saat ini                |
| `create_ata(bytes32)`         | `0x81972e35` | `Invoke` | Pembuatan ATA idempotent untuk PDA pemanggil × mint eksplisit                      |
| `create_ata(address)`         | `0x5a7c3259` | `Invoke` | Pembuatan ATA idempotent untuk PDA yang diturunkan dari alamat EVM × mint saat ini |
| `create_ata(address,bytes32)` | `0x3de2251a` | `Invoke` | Pembuatan ATA idempotent untuk alamat EVM × mint eksplisit                         |

## WithdrawCached (`0xff0000000000000000000000000000000000000b`)

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

| Tanda tangan Solidity         | Selector     | Dispatch   | Deskripsi                                                                                                                                                                                                                                                                                                                                                                                                                           |
| ----------------------------- | ------------ | ---------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `withdrawal(bytes32) payable` | `0x4d8b0ea4` | `Tersusun` | Bakar `msg.value` gas Rome, transfer ke penerima akun sistem Solana                                                                                                                                                                                                                                                                                                                                                                 |
| `withdraw_to_pda(uint256)`    | `0x7f3124a0` | `Tersusun` | Bakar wei, setorkan lamport ke `EXTERNAL_AUTHORITY` PDA milik pemanggil. Hanya single-state.                                                                                                                                                                                                                                                                                                                                        |
| `withdraw_to_ata(uint256)`    | `0x8059abc0` | `Tersusun` | Bakar wei, setorkan pembungkus SPL ke ATA milik PDA pemanggil. Hanya single-state. Jalur wrap dari bridge pembungkus gas.                                                                                                                                                                                                                                                                                                           |
| `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 pengimbang terhadap `Withdraw::ADDRESS` — wallet SPL chain adalah penopang ekonominya, bukan alamat precompile). Hanya single-state. Jalur unwrap dari bridge pembungkus gas. Sesuai dengan `HelperProgram.deposit_from_ata` semantik. |

## System (`0xff00000000000000000000000000000000000007`)

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

| Tanda tangan 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 sudah diketahui                 |
| `rome_evm_program_id()`                           | `0xb76fd45b` | `EthCall` | Mengembalikan Solana program ID untuk program Rome EVM ini                  |
| `program_id()`                                    | `0x77764881` | `EthCall` | Mengembalikan System Program ID 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 serbaguna.** Dari 7 selector di bawah, **2 melakukan CPI Solana sungguhan** (`invoke`, `invoke_signed` — dispatch sebagai `Invoke`) dan **5 adalah pembacaan lintas-state murni** (`account_info`, `account_data_at`, `account_u64_at`, `account_lamports`, `pdas_batch_derive` — dispatch sebagai `CrossStateEthCall`, tanpa syscall, tanpa `found_cpi` flag diset). Frasa historis "selector pintasan CPI" merujuk pada selector baca sebagai pengganti hemat-CU untuk pembacaan berbasis CPI sebelumnya — selector itu sendiri **bukan CPI**. Lihat tabel disambiguasi di bagian atas seksi ini untuk matriks perilaku lengkap.

| Tanda tangan Solidity                                          | Selector     | Dispatch            | Deskripsi                                                                                                                                                                                                                                                          |
| -------------------------------------------------------------- | ------------ | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `invoke(bytes32,(bytes32,bool,bool)[],bytes)`                  | `0x7480cb86` | `Invoke`            | CPI ditandatangani sebagai `EXTERNAL_AUTHORITY(caller)` ketika akun itu tercantum sebagai signer (ditolak di bawah DELEGATECALL); tanpa sub-PDA bersalt; pemanggil meneruskan program target + metadata 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 bersalt membawa alamat kontrak yang sedang berjalan — lihat catatan derivasi di bawah |
| `account_info(bytes32)`                                        | `0xc13465d9` | `CrossStateEthCall` | Baca state lengkap sebuah akun Solana (lamport/pemilik/flag/data)                                                                                                                                                                                                  |
| `account_data_at(bytes32,uint16,uint16)`                       | `0x593762e8` | `CrossStateEthCall` | Baca irisan buffer data dari 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 Rome yang menghadap pengguna 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`tidak\_payable `; mutasi melalui`(satu CPI) kecuali `Invoke` deposit\_from\_ata `, hanya single-state), tiga kueri hanya-baca` (`Tersusun`pda `ata`/`kueri (` ), dan dua pembacaan SPL\_ERC20 lintas-state (`EthCall`— satu pengambilan akun Solana).`CrossStateEthCall` — satu pengambilan akun Solana).

| Tanda tangan 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 idempotent untuk pubkey Solana mentah arbitrer sebagai pemilik (bukan diturunkan via `external_auth`). Operator membayar sewa. 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 `lamport` di atas batas minimum sewa                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `swap_gas_to_lamports(uint64)`                                   | `0x6e3f24e0` | `Invoke`            | Kreditkan PDA pemanggil dengan `n` lamport dari fee payer Solana pada transaksi; pemanggil membayarnya dalam gas Rome (pengeluaran lamport pihak pembayar di dalam CPI lawas apa pun ditambahkan ke biaya transaksi)                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `transfer_lamports(address,uint64)`                              | `0x5fe71665` | `Invoke`            | Pindahkan lamport dari PDA pemanggil ke PDA pengguna EVM lain                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `transfer_spl(address,uint64)`                                   | `0xb12be5ba` | `Invoke`            | Kirim SPL chain-gas dari ATA PDA pemanggil ke ATA pengguna tujuan                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `transfer_spl(bytes32,uint64)`                                   | `0xba3a5eac` | `Invoke`            | Kirim SPL chain-gas dari ATA PDA pemanggil ke ATA eksplisit                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `transfer_spl(address,uint64,bytes32)`                           | `0x53b505e0` | `Invoke`            | Kirim SPL mint-arbitrer dari ATA PDA pemanggil ke ATA pengguna tujuan                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `transfer_spl(bytes32,uint64,bytes32)`                           | `0xb6977879` | `Invoke`            | Kirim SPL mint-arbitrer dari ATA PDA pemanggil ke ATA eksplisit                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `transfer_spl(bytes32,bytes32,uint64,bytes32)`                   | `0x766b362a` | `Invoke`            | Varian delegasi — pemanggil menyediakan `src_ata` (harus dimiliki PDA ATAU PDA harus menjadi delegate dengan `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 owner ATAU delegate. Digunakan oleh `SPL_ERC20.transferFrom`                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `transfer_spl_to_signer(uint64,bytes32)`                         | `0x46efa679` | `Invoke`            | Bagian keluar native Solana. Mengirim `jumlah` dari `mint` dari ATA PDA pemanggil ke **ATA penandatangan Solana luar** untuk mint itu (hanya dompet milik pengguna pada jalur Solana yang ditandatangani dompet; dari MetaMask atau melalui relay, penandatangan adalah proxy payer Rome; tidak ada konversi alamat EVM). Tidak perlu approve — PDA pemanggil memiliki ATA sumber. Pasangkan dengan `ActivateAta` (slot 18) untuk penggunaan EVM end-to-end hanya dengan kunci Solana. Ini menjangkau dompet pada jalur v1 saat ini dan pada `DoTxUnsigned` (slot 17) jalur legacy yang lebih lama, karena dompet menandatangani transaksi Solana pada keduanya. |
| `approve_spl(address,uint64,bytes32)`                            | `0xabf6f675` | `Invoke`            | PDA pemanggil sebagai pemilik menetapkan `delegate_pda(spender)` pada ATA pemilik via SPL `approve_checked`. Digunakan oleh `SPL_ERC20.approve`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `approve_spl_raw_delegate(bytes32,bytes32,uint64,bytes32,uint8)` | `0x7881d453` | `Invoke`            | SPL `approve_checked` dengan delegate raw-pubkey yang disediakan pemanggil (mis. Wormhole `authority_signer` PDA, tidak ada padanan alamat EVM). Pemanggil memberikan `decimals` untuk melewati pembacaan mint on-chain (\~30-50K CU hemat). Hardcoded `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 via SPL `mint_to_checked`. Runtime SPL memaksa 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 milik 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 telah 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 `create_mint_account` + `init_spl_mint` panggilan                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `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`           | Derivasi 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 langkah di sisi Solidity `rome_evm_program_id() + find_program_address()` komposisi. Digunakan oleh `RomeEVMAccount.pda_with_salt`, `RomeBridgeWithdraw.{burnUSDC,burnETH}`                                                                                                                                                                                                                                                                                                                                                                                                     |
| `ata(address)`                                                   | `0x31db4f82` | `EthCall`           | Derivasi `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 SPL TokenAccount). 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, **armed** program hook (0 jika 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 sebuah operand, karena biaya sebenarnya dibatasi oleh `maximum_fee` yang sengaja tidak dibawa oleh ini.                                                                                                                                                                                                                           |
| `allowance_of(address,address,bytes32)`                          | `0xed72dbc8` | `CrossStateEthCall` | Baca delegated\_amount ATA pemilik dengan **pemeriksaan kesetaraan delegate** — mengembalikan 0 kecuali delegate on-chain == `external_auth(spender)`. Sesuai semantik ERC-20 (KEHARUSAN KERAS). Digunakan oleh `SPL_ERC20.allowance`                                                                                                                                                                                                                                                                                                                                                                                                                            |

## Tarik keluar (`0x4200000000000000000000000000000000000016`)

Penarikan gas native Rome → Solana.

| Tanda tangan Solidity      | Selector     | Dispatch               | Deskripsi                                                                                                                    |
| -------------------------- | ------------ | ---------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
| `withdrawal(bytes32)`      | `0x4d8b0ea4` | `Tersusun` (`payable`) | Bakar `msg.value` Gas Rome; mint+transfer ke akun sistem Solana `menjadi`. Satu-satunya metode precompile yang dapat dibayar |
| `withdraw_to_pda(uint256)` | `0x7f3124a0` | `Tersusun`             | Bakar gas; setorkan ke milik pemanggil `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.
