> 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/vi/tai-lieu-tham-khao/precompiles.md).

# Tài liệu tham chiếu Precompile

Mọi phương thức trên các precompile tương tác với Solana của Rome — địa chỉ, chữ ký Solidity, selector, và việc nó đọc, gọi hay dàn dựng một CPI.

Các selector mà chương trình on-chain của Rome gửi đi, thông qua precompile. Selector = `keccak256(signature)[:4]`; mọi hàng bên dưới đều được xác minh theo đó. Các giao diện Solidity nằm trong [`rome-solidity/contracts/interface.sol`](https://github.com/rome-protocol/rome-solidity/blob/master/contracts/interface.sol).

**Hãy đọc cột Dispatch trước tiên.** Nó cho biết một phương thức làm gì với trạng thái Solana:

| Dispatch               | Điều xảy ra                                                                                                                                                                                                          | CPI Solana thực | Được phép trong thực thi lặp  |
| ---------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------- | ----------------------------- |
| `Invoke` / `Được ghép` | Một hoặc nhiều CPI, được ký như PDA quyền bên ngoài của bên gọi khi có áp dụng seed. Trên **nhánh** legacy, chúng chạy ngay lập tức; trên **cached** nhánh cached, chúng được dàn chờ và cam kết vào cuối giao dịch. | Có              | Legacy: **không**. Cached: có |
| `EthCall`              | Tính toán thuần hoặc đọc trạng thái của chính Rome                                                                                                                                                                   | Không           | Có                            |
| `CrossStateEthCall`    | Đọc bytes của một tài khoản Solana khác, được nạp sẵn bằng mô phỏng. Không CPI, không có tác dụng phụ.                                                                                                               | Không           | Có                            |
| `Precompiled`          | Mật mã xác định (các precompile theo chuẩn Ethereum)                                                                                                                                                                 | Không           | Có                            |

Một hợp đồng sử dụng **một nhánh**: hoặc các precompile legacy (`0xff…07`, `0xff…08`, `0xff…09`, `0x42…16`) hoặc các precompile cached (`0xff…04`, `0xff…05`, `0xff…06`, `0xff…0b`). Việc trộn các lệnh thay đổi trạng thái từ cả hai trong cùng một giao dịch sẽ bị từ chối khi chạy. Các lệnh đọc vẫn được phép, với một ngoại lệ: khi một invoke ở nhánh cached đã được kích hoạt, các lệnh đọc ở nhánh legacy sẽ bị từ chối trong phần còn lại của giao dịch. Xem [Tích hợp một chương trình Solana](https://docs.rome.builders/vi/huong-dan-cho-nha-phat-trien/integrate-solana-program.md).

**Ai trả tiền.** Bên trả phí của Solana tạm ứng mọi lamport mà một CPI ở nhánh legacy tiêu tốn (rent, chuyển khoản, `swap_gas_to_lamports`); chương trình đo số dư của bên trả phí quanh mỗi CPI và tính phần chi ròng cho người dùng như gas theo giá gas, đồng thời hoàn trả các lamport mà CPI trả về.

**Ai ký.** Một hợp đồng gọi một precompile sẽ hành xử như chính nó: bên ký là PDA quyền bên ngoài của hợp đồng (`["EXTERNAL_AUTHORITY", contract]`). PDA của chính người dùng chỉ ký trên một giao dịch mà người dùng gửi trực tiếp đến địa chỉ precompile. Dưới `DELEGATECALL` / `CALLCODE`, các selector thay đổi trạng thái bị từ chối ngoại trừ `create_ata*`, `create_pda*`, `swap_gas_to_lamports`, `init_spl_mint` và `create_and_init_mint` trên HelperProgram, `create_ata*` trên ASplCached, và `invoke` / `invoke_signed` trên CpiProgram. Chúng được miễn vì đích đến của chúng bị ràng buộc với bên gọi hoặc được operator tài trợ, chứ không phải vì chúng không ký gì cả: `create_and_init_mint` vẫn ký bằng PDA của bên gọi bên ngoài để trả rent cho mint và chỉ có thể tạo một mint mà các authority là PDA đó, và `invoke` / `invoke_signed` từ chối authority trần (`DelegatecallOwnerAuthority`) và thêm muối vào namespace cho các PDA bằng địa chỉ của hợp đồng đang chạy.

Mọi phương thức đều là không thể nạp tiền (`msg.value > 0` sẽ revert với `TransferProhibited`) ngoại trừ `withdrawal(bytes32)`. Các phương thức được đánh dấu *chỉ một trạng thái* bị từ chối trên các chain op-geth-stack. Một CPI không được nêu tên bên trả phí Solana (trừ khi nằm trong một lệnh System transfer thuần túy) hoặc chương trình Rome, và cũng không được gọi chương trình Rome.

## SystemCached (`0xff00000000000000000000000000000000000004`)

Tạo PDA + các thao tác system-program (allocate, assign, chuyển lamport), được dàn chờ vào overlay. Bản tương ứng cached của `System @ 0xff..07`các selector thay đổi trạng thái của nó (System legacy vẫn giữ các selector đọc thuần).

| Chữ ký Solidity                      | Selector     | Dispatch | Mô tả                                                          |
| ------------------------------------ | ------------ | -------- | -------------------------------------------------------------- |
| `create_pda()`                       | `0xe0402a8d` | `Invoke` | Tạo `external_auth` PDA của bên gọi, miễn rent, dữ liệu rỗng   |
| `create_pda(uint64)`                 | `0x4ceab657` | `Invoke` | Tương tự, với lamport do bên cấp vốn chỉ định cao hơn mức rent |
| `create_pda(uint64,bytes32)`         | `0x48e2bb86` | `Invoke` | PDA được suy ra từ salt với lamport                            |
| `create_pda(bytes32,uint64,bytes32)` | `0xcc258bbf` | `Invoke` | PDA được chỉ định bởi chủ sở hữu, kích thước N, suy ra từ salt |
| `allocate(uint64,bytes32)`           | `0x93225c9f` | `Invoke` | Phân bổ N byte trên một PDA suy ra từ salt                     |
| `assign(bytes32,bytes32)`            | `0x8ac00bdc` | `Invoke` | Gán một PDA suy ra từ salt cho chủ sở hữu mới                  |
| `transfer(address,uint64)`           | `0x5d359fbd` | `Invoke` | Chuyển lamport đến PDA được suy ra từ địa chỉ EVM              |
| `transfer(bytes32,uint64)`           | `0xfd54d1ea` | `Invoke` | Chuyển lamport đến pubkey Solana thô                           |
| `transfer(bytes32,uint64,bytes32)`   | `0x875abfc0` | `Invoke` | Chuyển lamport đến pubkey thô, nguồn được suy ra từ salt       |

## SplCached (`0xff00000000000000000000000000000000000005`)

Chuyển SPL Token / Token-2022 + khởi tạo ATA + đọc tài khoản cross-state, được dàn chờ vào overlay.

| Chữ ký Solidity                                 | Selector     | Dispatch            | Mô tả                                                                                                                                                                                                                                                                                                                                                                           |
| ----------------------------------------------- | ------------ | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `transfer(address,uint256)`                     | `0xa9059cbb` | `Invoke`            | Chuyển SPL với người gọi là chủ sở hữu đến ATA của PDA được suy ra từ địa chỉ EVM, mint của rollup hiện tại                                                                                                                                                                                                                                                                     |
| `transfer(bytes32,uint256)`                     | `0x6a467394` | `Invoke`            | Tương tự, người nhận được cung cấp dưới dạng pubkey Solana thô                                                                                                                                                                                                                                                                                                                  |
| `transfer(address,uint256,bytes32)`             | `0x57cfeeee` | `Invoke`            | Biến thể mint tường minh, đích đến là địa chỉ EVM                                                                                                                                                                                                                                                                                                                               |
| `transfer(bytes32,uint256,bytes32)`             | `0x7db527f9` | `Invoke`            | Biến thể mint tường minh, đích đến là pubkey thô                                                                                                                                                                                                                                                                                                                                |
| `transferFrom(address,address,uint256,bytes32)` | `0x401e3367` | `Invoke`            | Biến thể nguồn delegate — authority = `external_auth(caller)`, được chấp nhận là chủ sở hữu ATA HOẶC delegate có đủ số lượng. Dùng bởi `SPL_ERC20_cached.transferFrom` và các luồng do router điều phối                                                                                                                                                                         |
| `approve(address,uint256,bytes32)`              | `0x8180f2fc` | `Invoke`            | Phê duyệt người chi tiêu EVM — owner = `external_auth(caller)`, delegate = `external_auth(spender_addr)`. Dùng bởi `SPL_ERC20_cached.approve`                                                                                                                                                                                                                                   |
| `mint(address,uint256,bytes32)`                 | `0x1e458bee` | `Invoke`            | PDA của bên gọi ký với tư cách mint authority. SPL runtime buộc PDA của bên gọi == mint authority trên chuỗi. Dùng bởi `SPL_ERC20_cached.mint_to` và việc thanh toán cầu vào từ bên ngoài                                                                                                                                                                                       |
| `init(bytes32,bytes32,bytes32)`                 | `0x0b0ad508` | `Invoke`            | `InitializeAccount3` ix (ata, mint, owner)                                                                                                                                                                                                                                                                                                                                      |
| `account(address)`                              | `0x73b9aa91` | `CrossStateEthCall` | Đọc trạng thái tài khoản SPL cho ATA của PDA được suy ra từ địa chỉ EVM (mint của rollup hiện tại)                                                                                                                                                                                                                                                                              |
| `account(bytes32)`                              | `0x882358ae` | `CrossStateEthCall` | Đọc trạng thái tài khoản SPL cho một pubkey ATA thô                                                                                                                                                                                                                                                                                                                             |
| `account(address,bytes32)`                      | `0xf9827227` | `CrossStateEthCall` | Tương tự như `account(address)` nhưng với mint tường minh.                                                                                                                                                                                                                                                                                                                      |
| `mint_info(bytes32)`                            | `0xe24bf5d4` | `CrossStateEthCall` | Sự thật về mint, có xét overlay: token program, decimals, **được kích hoạt** hook program (0 khi không có *hoặc* vô hiệu), fee bps của epoch hiện tại, và bitmap hiện diện extension. Cùng selector với `HelperProgram.mint_info` — một năng lực, hai điểm dispatch, vì một hợp đồng ở nhánh cached không thể dùng lệnh đọc legacy sau khi một invoke cached đã được kích hoạt. |

## ASplCached (`0xff00000000000000000000000000000000000006`)

Tạo Associated Token Account, có tính idempotent.

| Chữ ký Solidity               | Selector     | Dispatch | Mô tả                                                        |
| ----------------------------- | ------------ | -------- | ------------------------------------------------------------ |
| `create_ata()`                | `0xb6d336ed` | `Invoke` | Tạo ATA idempotent cho caller-PDA × mint của rollup hiện tại |
| `create_ata(bytes32)`         | `0x81972e35` | `Invoke` | Tạo ATA idempotent cho caller-PDA × mint tường minh          |
| `create_ata(address)`         | `0x5a7c3259` | `Invoke` | Tạo ATA idempotent cho EVM-addr-derived PDA × mint hiện tại  |
| `create_ata(address,bytes32)` | `0x3de2251a` | `Invoke` | Tạo ATA idempotent cho EVM-addr × mint tường minh            |

## WithdrawCached (`0xff0000000000000000000000000000000000000b`)

Các nhánh rút token gas (native gas → SPL wrapper, native gas → SOL, native gas → caller PDA), được dàn chờ. Bản tương ứng cached của `Withdraw @ 0x42..16`.

| Chữ ký Solidity               | Selector     | Dispatch    | Mô tả                                                                                                                                                                                                                                                                                                                                                                                                                      |
| ----------------------------- | ------------ | ----------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `withdrawal(bytes32) payable` | `0x4d8b0ea4` | `Được ghép` | Đốt `msg.value` Rome gas, chuyển đến người nhận là tài khoản hệ thống Solana                                                                                                                                                                                                                                                                                                                                               |
| `withdraw_to_pda(uint256)`    | `0x7f3124a0` | `Được ghép` | Đốt wei, nạp lamport vào `EXTERNAL_AUTHORITY` PDA của bên gọi. Chỉ một trạng thái.                                                                                                                                                                                                                                                                                                                                         |
| `withdraw_to_ata(uint256)`    | `0x8059abc0` | `Được ghép` | Đốt wei, nạp SPL wrapper vào ATA thuộc PDA của bên gọi. Chỉ một trạng thái. Nhánh wrap của cầu gas-wrapper.                                                                                                                                                                                                                                                                                                                |
| `deposit(uint256)`            | `0xb6b55f25` | `Được ghép` | Ngược lại của `withdrawal` — chuyển SPL từ ATA thuộc PDA của bên gọi sang ATA sol\_wallet của chain ở phía Solana; **mint** `wei` gas gốc cho bên gọi ở phía EVM. Mint thuần túy (không bù trừ khoản ghi nợ đối với `Withdraw::ADDRESS` — ví SPL của chain là sự bảo chứng kinh tế, không phải địa chỉ precompile). Chỉ một trạng thái. Nhánh unwrap của cầu gas-wrapper. Khớp `HelperProgram.deposit_from_ata` ngữ nghĩa. |

## System (`0xff00000000000000000000000000000000000007`)

Suy ra PDA + chuyển đổi base58 + các tiện ích kiểu identity. Precompile chỉ đọc — mọi phương thức đều là `EthCall` (không có tác dụng phụ phía Solana).

| Chữ ký Solidity                                   | Selector     | Dispatch  | Mô tả                                                                      |
| ------------------------------------------------- | ------------ | --------- | -------------------------------------------------------------------------- |
| `find_program_address(bytes32,(bytes)[])`         | `0x27e3edda` | `EthCall` | Solana `find_program_address` thông qua syscall — trả về `(pda, bump)`     |
| `create_program_address(bytes32,(bytes)[],uint8)` | `0xb99f29e1` | `EthCall` | Suy ra PDA trong thời gian hằng số với bump đã biết                        |
| `rome_evm_program_id()`                           | `0xb76fd45b` | `EthCall` | Trả về Solana program ID của chương trình Rome EVM này                     |
| `program_id()`                                    | `0x77764881` | `EthCall` | Trả về System Program ID của Rome (định danh của precompile này)           |
| `mint_id()`                                       | `0xe132a122` | `EthCall` | Trả về pubkey mint SPL của token gas của chain (`OwnerInfo.chain_mint_id`) |
| `operator()`                                      | `0x570ca735` | `EthCall` | Trả về signer Solana của giao dịch Rome bên ngoài                          |
| `bytes32_to_base58(bytes32)`                      | `0xfa2b1a5f` | `EthCall` | Byte pubkey → chuỗi base58                                                 |
| `base58_to_bytes32(bytes)`                        | `0x5df01b72` | `EthCall` | chuỗi base58 → byte pubkey                                                 |

## CpiProgram (`0xff00000000000000000000000000000000000008`)

**Precompile đa mục đích.** Trong 7 selector bên dưới, **2 thực hiện CPI Solana thực** (`invoke`, `invoke_signed` — dispatch như `Invoke`và **5 là các lệnh đọc cross-state thuần** (`account_info`, `account_data_at`, `account_u64_at`, `account_lamports`, `pdas_batch_derive` — dispatch như `CrossStateEthCall`, không syscall, không `found_cpi` cờ được đặt). Cụm từ lịch sử "CPI shortcut selectors" dùng để chỉ các selector đọc như những bản thay thế tiết kiệm CU cho các lệnh đọc dựa trên CPI trước đó — bản thân chúng **không phải CPI**. Xem bảng phân biệt ở đầu phần này để biết ma trận hành vi đầy đủ.

| Chữ ký Solidity                                                | Selector     | Dispatch            | Mô tả                                                                                                                                                                                                                                                                |
| -------------------------------------------------------------- | ------------ | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `invoke(bytes32,(bytes32,bool,bool)[],bytes)`                  | `0x7480cb86` | `Invoke`            | CPI được ký như `EXTERNAL_AUTHORITY(caller)` khi tài khoản đó được liệt kê là signer (bị từ chối dưới DELEGATECALL); không có sub-PDA có salt. Bên gọi truyền program đích + account metas + dữ liệu ix                                                              |
| `invoke_signed(bytes32,(bytes32,bool,bool)[],bytes,bytes32[])` | `0xb94f3733` | `Invoke`            | CPI được ký như `EXTERNAL_AUTHORITY(caller)` trên một CALL trực tiếp; salt được nối thêm theo seed của từng PDA. Dưới DELEGATECALL, authority trần của bên gọi bị từ chối và các seed có salt mang theo địa chỉ của hợp đồng đang chạy — xem ghi chú suy ra bên dưới |
| `account_info(bytes32)`                                        | `0xc13465d9` | `CrossStateEthCall` | Đọc toàn bộ trạng thái của một tài khoản Solana (lamport/chủ sở hữu/cờ/dữ liệu)                                                                                                                                                                                      |
| `account_data_at(bytes32,uint16,uint16)`                       | `0x593762e8` | `CrossStateEthCall` | Đọc một lát cắt của bộ đệm dữ liệu của bất kỳ tài khoản Solana nào                                                                                                                                                                                                   |
| `account_u64_at(bytes32,uint16)`                               | `0xb317d4c1` | `CrossStateEthCall` | Đọc u64 LE có kiểu tại một offset đã biết — tiết kiệm vòng ABI roundtrip                                                                                                                                                                                             |
| `account_lamports(bytes32)`                                    | `0xde79ed54` | `CrossStateEthCall` | Chỉ thăm dò lamport — bỏ qua việc lấy dữ liệu                                                                                                                                                                                                                        |
| `pdas_batch_derive(bytes[][],bytes32)`                         | `0x944336f8` | `CrossStateEthCall` | N PDA độc lập đối với một program trong một lần dispatch                                                                                                                                                                                                             |

## HelperProgram (`0xff00000000000000000000000000000000000009`)

Các tiện ích hướng người dùng của Rome cho việc tạo ATA/PDA, chuyển SPL/approve/mint được ký bởi `EXTERNAL_AUTHORITY` PDA của bên gọi, chuyển đổi gas↔lamport, nạp vào ATA, và các lệnh đọc dành cho SPL\_ERC20 (`user_balance` / `allowance_of`). Mọi phương thức đều là `not_payable`; các đường biến đổi đi qua `Invoke` (một CPI duy nhất) ngoại trừ `deposit_from_ata` (`Được ghép`, chỉ một trạng thái), ba truy vấn chỉ-đọc `pda`/`ata` (truy vấn`EthCall`), và hai lệnh đọc cross-state SPL\_ERC20 (`CrossStateEthCall` — một lần lấy tài khoản Solana).

| Chữ ký Solidity                                                  | Selector     | Dispatch            | Mô tả                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| ---------------------------------------------------------------- | ------------ | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `create_ata(address)`                                            | `0x5a7c3259` | `Invoke`            | Tạo ATA cho người dùng EVM dưới mint gas của chain                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `create_ata(address,bytes32)`                                    | `0x3de2251a` | `Invoke`            | Tạo ATA cho người dùng EVM dưới một mint tùy ý                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `create_ata_for_key(bytes32,bytes32)`                            | `0xd258a69d` | `Invoke`            | Tạo ATA idempotent cho một pubkey Solana thô bất kỳ làm chủ sở hữu (không được suy ra qua `external_auth`). Operator trả rent. Dùng bởi `SPL_ERC20.bridgeOutToSolana` / `ensureRecipientAta` / `create_token_account` các luồng người nhận dùng pubkey thô                                                                                                                                                                                                                                                                                              |
| `create_pda(address)`                                            | `0xff3556ca` | `Invoke`            | Tạo của người dùng `EXTERNAL_AUTHORITY` PDA (được miễn rent)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `create_pda(address,uint64)`                                     | `0x58e88298` | `Invoke`            | Giống, nhưng được cấp vốn bằng `lamports` trên mức sàn rent                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `swap_gas_to_lamports(uint64)`                                   | `0x6e3f24e0` | `Invoke`            | Ghi có cho PDA của bên gọi với `n` lamports từ bên thanh toán phí Solana của giao dịch; bên gọi trả chúng bằng Rome gas (mức chi lamport của bên thanh toán trong bất kỳ CPI kiểu cũ nào được cộng vào phí giao dịch)                                                                                                                                                                                                                                                                                                                                   |
| `transfer_lamports(address,uint64)`                              | `0x5fe71665` | `Invoke`            | Chuyển lamports từ PDA của bên gọi sang PDA của người dùng EVM khác                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `transfer_spl(address,uint64)`                                   | `0xb12be5ba` | `Invoke`            | Gửi SPL chain-gas từ ATA của PDA bên gọi đến ATA của người dùng đích                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `transfer_spl(bytes32,uint64)`                                   | `0xba3a5eac` | `Invoke`            | Gửi SPL chain-gas từ ATA của PDA bên gọi đến một ATA chỉ định                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `transfer_spl(address,uint64,bytes32)`                           | `0x53b505e0` | `Invoke`            | Gửi SPL có mint tùy ý từ ATA của PDA bên gọi đến ATA của người dùng đích                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `transfer_spl(bytes32,uint64,bytes32)`                           | `0xb6977879` | `Invoke`            | Gửi SPL có mint tùy ý từ ATA của PDA bên gọi đến ATA chỉ định                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `transfer_spl(bytes32,bytes32,uint64,bytes32)`                   | `0x766b362a` | `Invoke`            | Biến thể ủy quyền — bên gọi cung cấp `src_ata` (phải thuộc sở hữu của PDA HOẶC PDA phải là bên được ủy quyền với đủ `delegated_amount`)                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `transfer_spl(address,address,uint64,bytes32)`                   | `0xe479df56` | `Invoke`            | Biến thể ủy quyền theo khóa địa chỉ — suy ra cả hai ATA từ địa chỉ EVM nội bộ. Ký dưới dạng `external_auth(caller)`; SPL Token chấp nhận PDA là chủ sở hữu HOẶC bên được ủy quyền. Được dùng bởi `SPL_ERC20.transferFrom`                                                                                                                                                                                                                                                                                                                               |
| `transfer_spl_to_signer(uint64,bytes32)`                         | `0x46efa679` | `Invoke`            | Nhánh thoát gốc Solana. Gửi `amount` của `mint` từ ATA của PDA bên gọi đến **ATA của** cho mint đó (ví tự của người dùng chỉ trên luồng Solana được ký bằng ví; từ MetaMask hoặc qua relay, bên ký là bên thanh toán ủy quyền của Rome; không chuyển đổi địa chỉ EVM). Không cần approve — PDA của bên gọi sở hữu ATA nguồn. Kết hợp với `ActivateAta` (slot 18) cho việc sử dụng EVM chỉ với khóa Solana end-to-end. Nó tới được ví trên luồng v1 hiện tại và trên luồng legacy cũ hơn `DoTxUnsigned` (slot 17) vì ví ký giao dịch Solana trên cả hai. |
| `approve_spl(address,uint64,bytes32)`                            | `0xabf6f675` | `Invoke`            | PDA của bên gọi với vai trò chủ sở hữu đặt `delegate_pda(spender)` trên ATA của chủ sở hữu qua SPL `approve_checked`. Dùng bởi `SPL_ERC20.approve`                                                                                                                                                                                                                                                                                                                                                                                                      |
| `approve_spl_raw_delegate(bytes32,bytes32,uint64,bytes32,uint8)` | `0x7881d453` | `Invoke`            | SPL `approve_checked` với bên được ủy quyền raw-pubkey do bên gọi cung cấp (ví dụ Wormhole `authority_signer` PDA, không có tương đương địa chỉ EVM). Bên gọi truyền `decimals` để bỏ qua việc đọc mint trên chuỗi (tiết kiệm \~30-50K CU). Mã hóa cứng `spl_program = SPL Token`. Dùng bởi `RomeBridgeWithdraw.approveBurnETH`                                                                                                                                                                                                                         |
| `mint_spl(address,uint64,bytes32)`                               | `0xd795522b` | `Invoke`            | PDA của bên gọi với vai trò mint\_authority đúc vào ATA của người dùng đích qua SPL `mint_to_checked`. SPL runtime thực thi đối sánh thẩm quyền. Được dùng bởi `SPL_ERC20.mint_to`                                                                                                                                                                                                                                                                                                                                                                      |
| `create_mint_account(bytes32)`                                   | `0xe97d3291` | `Invoke`            | System CreateAccount cấp phát một PDA suy ra từ salt (`external_auth_with_salt(caller, salt)`) với space=82 thuộc sở hữu của SPL Token. Bên cấp vốn = PDA external\_auth của bên gọi. Hai bên ký PDA. Được dùng bởi `ERC20SPLFactory.create_token_mint`                                                                                                                                                                                                                                                                                                 |
| `init_spl_mint(bytes32,uint8,bytes32,bool,bytes32)`              | `0x4f75e987` | `Invoke`            | SPL Token `InitializeMint2` trên mint đã được cấp phát trước. Không có bên ký PDA (mint\_authority/freeze\_authority được lưu dưới dạng dữ liệu, không phải bên ký lúc chạy). Được dùng bởi `ERC20SPLFactory.init_token_mint`                                                                                                                                                                                                                                                                                                                           |
| `create_and_init_mint(uint8,bytes32,bool,bytes32,bytes32)`       | `0x20972d0f` | `Được ghép`         | Kết hợp: System CreateAccount + SPL InitializeMint2 trong một lần dispatch. Tiết kiệm 1 phong bì Rome DoTx so với tách riêng `create_mint_account` + `init_spl_mint` lệnh gọi                                                                                                                                                                                                                                                                                                                                                                           |
| `deposit_from_ata(uint256)`                                      | `0x4479b709` | `Được ghép`         | Rút SPL từ ATA của bên gọi vào Rome native gas. **Chỉ trạng thái đơn** — bị từ chối trên các chuỗi op-geth                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `pda(address)`                                                   | `0x8854a299` | `EthCall`           | Suy ra của người dùng `EXTERNAL_AUTHORITY` PDA — chỉ đọc                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `pda_with_salt(address,bytes32)`                                 | `0x5c6d04b3` | `EthCall`           | Suy ra từ salt `EXTERNAL_AUTHORITY` PDA trong một lần dispatch. Gộp lại chuỗi 2 lời gọi phía Solidity `rome_evm_program_id() + find_program_address()` thành một. Được dùng bởi `RomeEVMAccount.pda_with_salt`, `RomeBridgeWithdraw.{burnUSDC,burnETH}`                                                                                                                                                                                                                                                                                                 |
| `ata(address)`                                                   | `0x31db4f82` | `EthCall`           | Suy ra `getATA(user_pda, chain_mint_id)` — kết hợp EXT\_AUTH + ATA — chỉ đọc                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `ata(address,bytes32)`                                           | `0xfeb1c647` | `EthCall`           | Tương tự với mint chỉ định — chỉ đọc                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `user_balance(address,bytes32)`                                  | `0xdd0119c8` | `CrossStateEthCall` | Đọc ATA của người dùng `amount` (độ lệch 64 của SPL TokenAccount). Trả về 0 nếu ATA không tồn tại (thăm dò chuỗi mới). Gộp lại 3 lần dispatch v1. Được dùng bởi `SPL_ERC20.balanceOf`                                                                                                                                                                                                                                                                                                                                                                   |
| `mint_info(bytes32)`                                             | `0xe24bf5d4` | `CrossStateEthCall` | Các thông tin mint cho bên gọi theo luồng legacy: chương trình token, số thập phân, **được kích hoạt** hook program (0 khi không có *hoặc* (trơ), fee bps của epoch hiện tại, bitmap hiện diện extension. Được phản chiếu trên `SplCached` ở cùng selector. `feeBps` là một **vị từ** — nó cho biết một khoản phí đã được kích hoạt, nó không phải là toán hạng, vì phí thực tế bị chặn bởi `maximum_fee` mà phần này cố ý không mang theo.                                                                                                             |
| `allowance_of(address,address,bytes32)`                          | `0xed72dbc8` | `CrossStateEthCall` | Đọc delegated\_amount của ATA chủ sở hữu với **kiểm tra bằng nhau của delegate** — trả về 0 trừ khi delegate trên chuỗi == `external_auth(spender)`. Đúng về ngữ nghĩa ERC-20 (YÊU CẦU CỨNG). Được dùng bởi `SPL_ERC20.allowance`                                                                                                                                                                                                                                                                                                                       |

## Rút (`0x4200000000000000000000000000000000000016`)

Rút native gas từ Rome → Solana.

| Chữ ký Solidity            | Selector     | Dispatch                | Mô tả                                                                                                                             |
| -------------------------- | ------------ | ----------------------- | --------------------------------------------------------------------------------------------------------------------------------- |
| `withdrawal(bytes32)`      | `0x4d8b0ea4` | `Được ghép` (`payable`) | Đốt `msg.value` Rome gas; đúc + chuyển đến một tài khoản hệ thống Solana `vào`. Phương thức precompile duy nhất có thể thanh toán |
| `withdraw_to_pda(uint256)` | `0x7f3124a0` | `Được ghép`             | Đốt gas; nạp vào `EXTERNAL_AUTHORITY` PDA của bên gọi. **Chỉ trạng thái đơn**                                                     |
| `withdraw_to_ata(uint256)` | `0x8059abc0` | `Được ghép`             | Đốt gas; nạp vào `getATA(caller_pda, chain_mint_id)`. **Chỉ trạng thái đơn**                                                      |


---

# 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/vi/tai-lieu-tham-khao/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.
