> 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/huong-dan-cho-nha-phat-trien/integrate-solana-program.md).

# Tích hợp một chương trình Solana

Tích hợp một chương trình Solana với Rome EVM — ai là người ký Solana, giá trị đi vào chương trình của bạn và quay trở lại như thế nào, quy tắc một luồng, atomic so với iterative, và cấp phát account.

Hướng dẫn này dành cho một nhóm chương trình Solana muốn người dùng Rome EVM sử dụng chương trình của họ — một chương trình privacy, lending hoặc vault phải giữ giá trị cho các tài khoản EVM. Nó xây dựng dựa trên [Gọi Solana từ EVM](https://docs.rome.builders/vi/huong-dan-cho-nha-phat-trien/call-solana-from-evm.md) (cơ chế precompile) và trả lời những câu hỏi xuất hiện khi một chương trình thực sự nằm ở phía bên kia: *ai* ký, *cách* token đi vào và đi ra, và *những* giới hạn định hình thiết kế.

Luồng được dùng xuyên suốt: một tài khoản EVM chuyển USDC vào chương trình của bạn ("shield" hoặc "deposit"), chương trình của bạn giữ nó cho người dùng đó, rồi sau đó giải phóng nó trở lại ("unshield" hoặc "withdraw"). Hãy thay các động từ bằng của riêng bạn.

## 1. Mỗi địa chỉ EVM có một danh tính Solana

Rome tạo ra một tài khoản Solana cho mỗi địa chỉ EVM — cả người dùng lẫn hợp đồng — được gọi là **thẩm quyền bên ngoài**:

```
external_auth(addr) = find_program_address(["EXTERNAL_AUTHORITY", addr_h160], rome_evm_program_id)
```

Nó sở hữu các tài khoản token liên kết của địa chỉ đó (đó là nơi `wUSDC.balanceOf(addr)` đọc từ) và nó là khóa ký các CPI được thực hiện thay mặt cho địa chỉ đó. Chương trình của bạn nhìn thấy một pubkey Solana 32 byte; nó không bao giờ thấy một H160.

**Ai ký được quyết định bởi ai gọi precompile:**

| Precompile được gọi bởi                                                       | người ký Solana                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| ----------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Một **hợp đồng**, với một `CALL`                                              | Các **chính** thẩm quyền bên ngoài (`external_auth(contract)`), cộng với mọi sub-PDA có muối của hợp đồng mà nó yêu cầu                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| Một **người dùng**, trong một giao dịch được gửi thẳng đến địa chỉ precompile | Các **chính của người dùng** thẩm quyền bên ngoài                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| Một hợp đồng thông qua `DELEGATECALL`                                         | Thẩm quyền trần bị từ chối (`DelegatecallOwnerAuthority`). `invoke` không có người ký, và `invoke_signed` với các sub-PDA có muối, vẫn chạy — nhưng các sub-PDA đó được phân vùng theo địa chỉ của hợp đồng đang chạy (`["EXTERNAL_AUTHORITY", caller, running_contract, salt]`), vì vậy `pda_with_salt` không tạo ra chúng. Trong HelperProgram, chỉ các bộ chọn tạo và cấp vốn được thông qua (`create_ata*`, `create_pda*`, `swap_gas_to_lamports`, `init_spl_mint`, `create_and_init_mint`); chúng được miễn vì đích đến của chúng gắn với bên gọi hoặc được nhà vận hành cấp vốn, chứ không phải vì chúng không ký gì |

Quy tắc ERC-20 mà bạn đã biết: **một hợp đồng không thể tự mình di chuyển tài sản của người dùng.** Nó hoạt động như danh tính của chính nó, và người dùng cấp quyền cho nó trước. Với các token phải di chuyển ở phía Solana, quyền cấp đó là một SPL delegation trên tài khoản token của người dùng; quyền ERC-20 của wrapper `approve` chỉ là một allowance ở phía EVM mà các lệnh chuyển của chính wrapper tôn trọng. Đó là cách các wrapper token của riêng Rome hoạt động, và đó là cách adapter của bạn sẽ hoạt động (mục 3).

Sub-PDA có muối: `invoke_signed` nhận một danh sách các `bytes32` muối, và Rome ký bằng `["EXTERNAL_AUTHORITY", caller_h160, salt]` cho mỗi mục (kèm bump; bên gọi là hợp đồng trong một cuộc gọi trực tiếp). `HelperProgram.pda_with_salt(addr, salt)` trả về địa chỉ từ Solidity. Hãy dùng một salt cho mỗi người dùng (ví dụ địa chỉ của người dùng) khi chương trình của bạn muốn có một tài khoản owner riêng cho mỗi vị thế.

Cấp vốn: một PDA thẩm quyền bên ngoài không nhất thiết phải tồn tại để sở hữu một ATA (`create_ata` là idempotent và người trả phí Solana của giao dịch sẽ chịu tiền rent). Nó phải tồn tại và giữ lamport chỉ khi nó cấp vốn cho các tài khoản mà instruction của bạn tạo ra. `HelperProgram.create_pda(addr)` tạo nó như một System `CreateAccount`, vì vậy chỉ gọi nó một lần; nó không idempotent. `swap_gas_to_lamports(n)` ghi có cho PDA của địa chỉ `n` lamport từ người trả phí Solana của giao dịch, và bên gọi trả cho chúng bằng gas của Rome: tác động của mọi CPI theo track legacy lên số dư của người trả phí được cộng vào phí giao dịch và tính cho người dùng theo giá gas, giống như cách rent cho các tài khoản do CPI tạo ra được tính. Bước cấp phát của lane Solana được mô tả trong [Gọi EVM từ Solana](https://docs.rome.builders/vi/huong-dan-cho-nha-phat-trien/call-evm-from-solana.md); một hợp đồng cấp phát PDA của chính nó trong constructor hoặc lần gọi đầu tiên.

## 2. Ba cách giữ vị thế của người dùng

**A. Một hợp đồng adapter (khuyến nghị cho một adapter có thể tái sử dụng).** Một hợp đồng Solidity duy nhất đứng trước chương trình của bạn. Người dùng cấp cho thẩm quyền của adapter một SPL delegation trên tài khoản token của họ; adapter kéo token vào một tài khoản token mà nó sở hữu, gọi chương trình của bạn với tư cách chính nó, và định danh vị thế của người dùng bên trong chương trình của bạn bằng một sub-PDA theo từng người dùng hoặc bằng một định danh mà nó truyền trong dữ liệu instruction. Khi đi ra, nó bảo chương trình của bạn giải phóng đến tài khoản token riêng của người dùng. Adapter là danh tính Solana duy nhất mà chương trình của bạn cần biết. Quyền cấp là một SPL delegation, không phải một ERC-20 `approve`; mục 3 giải thích vì sao và nó tốn gì của người dùng.

**B. Người dùng là người ký Solana.** Giao diện phía trước gửi một giao dịch từ tài khoản EVM của người dùng **trực tiếp đến precompile CpiProgram** (`to = 0xff…08`, calldata = dữ liệu được mã hóa theo ABI `invoke` hoặc `invoke_signed`), vì vậy thẩm quyền bên ngoài của chính người dùng sẽ ký và chương trình của bạn định danh vị thế bằng nó. Không có hợp đồng adapter và không có delegation, nhưng mỗi hành động là một giao dịch calldata mờ trong ví, và mọi thứ luồng cần ngoài CPI (ATA, một lần chuyển trước đó) đều là một giao dịch riêng. Nó phù hợp cho các quyền cấp một lần (quyền cấp của người dùng `approve_spl` cho một wrapper) và cho các chương trình đơn giản, không phù hợp cho các luồng nhiều bước. [Cardo](https://github.com/rome-protocol/cardo) sử dụng cấu trúc này: giao diện phía trước của nó gửi `invoke` thẳng đến precompile từ ví của người dùng.

**C. Một bộ định tuyến không lưu ký.** Một hợp đồng không bao giờ giữ token của người dùng. Người dùng cấp cho thẩm quyền của router một SPL delegation trên chính tài khoản token của họ; router thực hiện CPI vào chương trình của bạn với thẩm quyền đó làm transfer authority, vì vậy token di chuyển từ tài khoản token của người dùng sang tài khoản của chương trình bạn (hoặc ngược lại về người dùng), và router không giữ gì giữa các lần gọi. Router suy ra mọi tài khoản phía người dùng từ `msg.sender`, vì vậy quyền cấp của một người dùng không thể được trỏ sang tài khoản của người dùng khác, và nó gọi một chương trình cố định với các dạng instruction cố định thay vì hoạt động như một `invoke` bộ chuyển tiếp tổng quát.  `RomeDexRouter` trên [rome-dex](https://github.com/rome-protocol/rome-dex) được viết theo cách này; làn EVM của rome-dex cũng cung cấp trực tiếp thô `invoke` theo dạng B. Nó cần cùng quyền cấp như A, với cùng chi phí một delegate (mục 3), và không cần bước kéo.

Phần còn lại của hướng dẫn này theo A; C dùng cùng quyền cấp và cùng quy tắc ký.

## 3. Token vào, token ra

USDC trên Rome là một SPL mint được nhìn từ hai phía: `wUSDC` wrapper ERC-20 ở phía EVM và ATA của thẩm quyền bên ngoài ở phía Solana. Với địa chỉ riêng của một người dùng thì hai phía là cùng một số dư: `wUSDC.balanceOf(user)` đọc ATA của người dùng. Không có gì di chuyển hay đồng bộ giữa hai góc nhìn.

**Số dư wrapper của một hợp đồng không phải là một tài khoản token mà hợp đồng kiểm soát.** Factory triển khai `SPL_ERC20_cached` cho một mint thông thường, và của Hadrian `wUSDC` là một cái như vậy. Wrapper đó không thể ký thay cho một hợp đồng, vì vậy khi `wUSDC.transferFrom(user, adapter, amount)` hoặc `transfer` gửi token đến một hợp đồng, các token SPL di chuyển vào **tài khoản token ký quỹ riêng của wrapper** (`escrow_ata()`), và wrapper ghi lại số lượng theo từng hợp đồng trong bộ nhớ của nó. `wUSDC.balanceOf(adapter)` trả về bản ghi đó, một sổ cái ký quỹ, chứ không phải số dư của một tài khoản token thuộc sở hữu của `external_auth(adapter)`. Adapter của bạn không thể chuyển những token đó cho chương trình của bạn trong một CPI; chúng chỉ có thể rời đi thông qua wrapper một lần nữa. Vì vậy một adapter tự cấp vốn bằng `transferFrom` không có gì để chi tiêu ở phía Solana.

Con đường hoạt động là một SPL delegation:

* **Cấp quyền.** Người dùng gửi `approve_spl(adapter, amount, mint)` như một giao dịch **thẳng đến HelperProgram** (`to = 0xff…09`), nơi `mint` là của wrapper `mint_id()`. Thẩm quyền của chính người dùng ký, và delegate mà nó đặt trên tài khoản token của người dùng là thẩm quyền bên ngoài của adapter.
* **Vào.** Hành động `deposit(amount)` kéo bằng overload delegate `HelperProgram.transfer_spl(srcAta, dstAta, amount, mint)`, với ATA của người dùng làm nguồn và ATA riêng của adapter (`HelperProgram.ata(address(this), mint)`, được tạo một lần bằng `create_ata`) làm đích. Thẩm quyền của adapter ký với vai trò delegate. Token giờ nằm trong một tài khoản token thuộc sở hữu của `external_auth(adapter)`, chính là tài khoản mà CPI của bạn chỉ định; người ký và nguồn đều là của adapter, nên không cần thêm quyền nào khác. Chúng không xuất hiện trong `wUSDC.balanceOf(adapter)`.
* **Ra.** Instruction withdraw của chương trình bạn chuyển đến **ATA của** người dùng, `HelperProgram.ata(user, mint)`. Việc nhận không cần chữ ký của người dùng, và số dư được thấy ngay dưới dạng `wUSDC.balanceOf(user)`. Nếu ATA có thể chưa tồn tại, hãy tạo nó trước bằng `HelperProgram.create_ata(user, mint)` (idempotent).

**Một tài khoản token chỉ có một delegate.** Quyền cấp ở trên thay thế quyền cấp riêng của wrapper trên tài khoản đó. Cho đến khi người dùng cấp lại cho wrapper, mọi `wUSDC` `transfer` hoặc `transferFrom` lệnh ra khỏi địa chỉ của họ đều hoàn nguyên với lỗi SPL `0x4`. Sau bất kỳ luồng nào sử dụng quyền cấp này, hãy gọi `wUSDC.isEnabled(user)`; khi nó trả về `false`, hãy yêu cầu người dùng gửi `approve_spl(wrapper, 2^64-1, mint)` đến HelperProgram một lần nữa, đúng mức cấp tối đa mà wrapper được thiết kế quanh (xem [Một lần: cấp quyền cho wrapper](https://docs.rome.builders/vi/huong-dan-cho-nha-phat-trien/dual-lane-app.md#one-time-grant-the-wrapper)). Một quyền cấp bị giới hạn sẽ phá vỡ các `wUSDC` lệnh chuyển thông thường của người dùng một khi nó cạn dần, và `isEnabled` vẫn `true` trong khi vẫn còn bất kỳ phần nào, nên ứng dụng sẽ không biết để hỏi lại.

Để kiểm tra một mint có wrapper nào, hãy đọc `wrapper_kind_by_mint(mint)` (địa chỉ factory nằm trong `contracts.json` trong [registry](https://github.com/rome-protocol/rome-registry)). `1` là wrapper cached mà phần này mô tả. `2` là wrapper direct-CPI mà factory triển khai cho một mint Token-2022 với transfer hook được kích hoạt; hướng dẫn này không đề cập đến nó. Mục registry `tokens.json` liệt kê địa chỉ wrapper và mint nhưng không nêu đó là loại nào.

## 4. Một track cho mỗi hợp đồng, và cho mỗi giao dịch

Rome có hai họ precompile thay đổi trạng thái Solana, và **một giao dịch chỉ dùng đúng một trong số đó** — runtime từ chối một giao dịch trộn các lời gọi thay đổi từ cả hai, kể cả giữa các hợp đồng.

| Track      | Precompiles                                                                                         | Hiệu lực có tác dụng                                                                                             | Hoạt động trong thực thi lặp                                                                    |
| ---------- | --------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------- |
| **Legacy** | `CpiProgram` `0xff…08` (`invoke`, `invoke_signed`), `HelperProgram` `0xff…09`, `Withdraw` `0x42…16` | Ngay lập tức, như một CPI thực sự bên trong bước EVM                                                             | **Không** — một CPI legacy trong một giao dịch lặp sẽ thất bại với `CpiProhibitedInIterativeTx` |
| **Cached** | `SplCached` `0xff…05`, `ASplCached` `0xff…06`, `SystemCached` `0xff…04`, `WithdrawCached` `0xff…0b` | Được dàn dựng trong một lớp phủ và được ghi nhận thành các CPI ở cuối giao dịch; một EVM revert sẽ loại bỏ chúng | Có                                                                                              |

Điều này có nghĩa gì cho tích hợp chương trình:

* **Việc gọi các instruction của chính chương trình bạn chỉ ở track legacy.** Track cached không có `invoke`; nó bao phủ các chuyển SPL, tạo ATA, các thao tác system-program và rút gas.
* Vì vậy bước cấp vốn cho adapter cũng phải ở track legacy nếu nó chạy trong cùng một giao dịch với CPI. Lệnh `transferFrom` là một lời gọi ở track cached, nên nó không thể chia sẻ một giao dịch với CPI của bạn (và, như mục 3 cho thấy, nó chỉ ghi có vào một sổ cái ký quỹ). Hãy kéo bằng `HelperProgram.transfer_spl(userAta, adapterAta, amount, mint)` thay vào đó, sau khi người dùng đã biến adapter thành SPL delegate (`approve_spl` , do người dùng gửi trực tiếp đến HelperProgram). Việc kéo và CPI đều ở track legacy, nên chúng chạy trong cùng một giao dịch.
* **Để wrapper ra khỏi giao dịch đó.** Đừng gọi các hàm thay đổi của wrapper (`wUSDC.transfer`, `transferFrom`) từ adapter trong cùng một giao dịch với một CPI legacy. Kiểm tra `isEnabled(user)` và số dư từ giao diện phía trước với `eth_call`.
* **Và giao dịch CPI phải nguyên tử.** Đó là giới hạn mà thiết kế phải nằm dưới.

Các thao tác đọc nằm ngoài quy tắc: `account_info`, `account_data_at`, `account_u64_at`, `account_lamports`, `pdas_batch_derive` và `HelperProgram.user_balance` / `allowance_of` là các lần đọc của tài khoản đã được nạp sẵn (không có CPI), được phép ở cả hai track và trong cả hai chế độ thực thi. Hãy đặt các kiểm tra trước của bạn trên chúng. Một quy tắc thứ tự: một khi một mutation cached đã xảy ra trong một giao dịch, các lần đọc ở track legacy sẽ bị chặn trong phần còn lại của giao dịch đó — đọc trước, rồi mới mutate.

## 5. Tính nguyên tử là ngân sách

Một giao dịch Rome nguyên tử là một giao dịch Solana: khoảng **1,4 triệu compute unit**, một **64 địa chỉ** danh sách tài khoản và một **4 KB** kích thước wire (Solana v1 transactions). Chương trình Rome và CPI của bạn cùng chia sẻ ngân sách đó. Một lệnh chuyển của wrapper chạy khoảng 170K CU trên Hadrian và instruction của bạn cộng thêm phần của nó; hãy đo bằng `computeUnitsConsumed`, không phải EVM `gasUsed`.

Khi mô phỏng quyết định một giao dịch không vừa, Rome chạy nó **lặp** qua nhiều giao dịch Solana, và khi đó một CPI legacy bên trong nó sẽ thất bại. Hãy giữ mỗi lần deposit và withdraw chỉ gồm một lần di chuyển token cộng với một CPI vào chương trình của bạn, và giữ phần Solidity xung quanh chúng thật nhỏ. Hãy tách mọi thứ lớn hơn thành hai giao dịch của người dùng.

Độ sâu CPI: Solana cho phép 4 cấp và Rome dùng một cấp, nên instruction của bạn chạy ở cấp 2 với hai cấp bên dưới nó (chương trình của bạn → SPL Token còn lại một cấp).

## 6. Cấp phát tài khoản

Chương trình của bạn không nhận các tài khoản từ Solidity lúc chạy. Proxy **mô phỏng** mọi giao dịch trước khi gửi, ghi lại mọi tài khoản Solana mà các CPI đã chạm đến, và đặt chúng vào giao dịch Solana. Adapter của bạn đặt tên các tài khoản trong `invoke_signed` danh sách tài khoản; mô phỏng chứng minh chúng phân giải được. Ba điều sau đây:

* Mọi tài khoản mà instruction của bạn chạm đến phải có thể suy ra từ các đầu vào mà adapter có (PDA và sub-PDA của chính nó, program ID của bạn, các mint, địa chỉ của người dùng). `SystemProgram.find_program_address` và `CpiProgram.pdas_batch_derive` thực hiện các phép suy diễn trong Solidity.
* Một tài khoản chưa tồn tại (một vị thế mới, một ATA mới) vẫn phải được nêu tên trong danh sách tài khoản; địa chỉ của nó là thứ đi vào giao dịch Solana.
* Mọi thứ mà giao dịch chạm đến — bao gồm các tài khoản riêng của Rome cho người dùng, adapter và wrapper — phải nằm dưới 64 địa chỉ. Một thiết kế chạm đến mười thị trường trong một lần gọi sẽ không vừa.

Đối với làn ví Solana, `rome_emulateCallAccounts` cung cấp khả năng phát hiện tương tự cho một client; SDK dùng nó.

Hai tài khoản mà một CPI không bao giờ được nêu tên: người trả phí Solana gửi giao dịch (trừ khi nằm trong một instruction System transfer thuần túy) và chính chương trình Rome. Một CPI quay trở lại chương trình Rome sẽ bị từ chối.

## 7. Một lần deposit và một lần withdraw, trong Solidity

Một phác thảo tối thiểu của một adapter trên track legacy. Người dùng đã gửi `approve_spl(adapter, amount, mint)` đến HelperProgram (mục 3). `PRIVACY_PROGRAM` là program ID của bạn; `encodeDeposit` / `encodeWithdraw` xây dựng dữ liệu instruction của bạn (Borsh, little-endian); các account meta theo sau bố cục của instruction của bạn.

```solidity
import {ICrossProgramInvocation, IHelperProgram}
    from "@rome-protocol/rome-solidity/contracts/interface.sol";

contract PrivacyAdapter {
    ICrossProgramInvocation constant Cpi    = ICrossProgramInvocation(0xFF00000000000000000000000000000000000008);
    IHelperProgram          constant Helper = IHelperProgram(0xFF00000000000000000000000000000000000009);
    bytes32 constant SPL_TOKEN = 0x06ddf6e1d765a193d9cbe146ceeb79ac1cb485ed5f5b37913a8cf5857eff00a9; // TokenkegQ...

    bytes32 immutable PRIVACY_PROGRAM;
    bytes32 immutable USDC_MINT;

    constructor(bytes32 program, bytes32 mint) {
        PRIVACY_PROGRAM = program; USDC_MINT = mint;
        Helper.create_pda(address(this));                 // danh tính Solana riêng của adapter
        Helper.create_ata(address(this), USDC_MINT);      // và một tài khoản USDC mà nó sở hữu
    }

    function _salt(address user) internal pure returns (bytes32) { return bytes32(uint256(uint160(user))); }

    function deposit(uint64 amount) external {
        bytes32 self       = Helper.pda(address(this));                   // người ký: thẩm quyền của adapter
        bytes32 adapterAta = Helper.ata(address(this), USDC_MINT);
        bytes32 position   = Helper.pda_with_salt(address(this), _salt(msg.sender)); // sub-PDA theo từng người dùng, cũng ký

        // Kéo từ tài khoản token của người dùng. Thẩm quyền của adapter ký với tư cách SPL
        // delegate mà người dùng đã cấp; đây là một lời gọi track legacy, giống như CPI bên dưới.
        Helper.transfer_spl(Helper.ata(msg.sender, USDC_MINT), adapterAta, amount, USDC_MINT);

        ICrossProgramInvocation.AccountMeta[] memory accs = new ICrossProgramInvocation.AccountMeta[](5);
        accs[0] = ICrossProgramInvocation.AccountMeta(self,       true,  true);
        accs[1] = ICrossProgramInvocation.AccountMeta(position,   true,  true);
        accs[2] = ICrossProgramInvocation.AccountMeta(adapterAta, false, true);                          // nguồn: thuộc sở hữu của thẩm quyền adapter
        accs[3] = ICrossProgramInvocation.AccountMeta(_vaultFor(position), false, true);                 // kho của chương trình bạn
        accs[4] = ICrossProgramInvocation.AccountMeta(SPL_TOKEN, false, false);

        bytes32[] memory salts = new bytes32[](1);
        salts[0] = _salt(msg.sender);
        Cpi.invoke_signed(PRIVACY_PROGRAM, accs, encodeDeposit(amount), salts);
    }

    function withdraw(uint64 amount) external {
        bytes32 position = Helper.pda_with_salt(address(this), _salt(msg.sender));
        bytes32 userAta  = Helper.ata(msg.sender, USDC_MINT);            // đích đến: tài khoản riêng của người dùng
        // ... cùng dạng: chương trình của bạn di chuyển `amount` từ vault sang userAta, được ký bởi `position`
        Cpi.invoke_signed(PRIVACY_PROGRAM, accs, encodeWithdraw(amount), salts);
    }
}
```

Adapter không bao giờ gọi `wUSDC` hợp đồng. Việc kéo là một lời gọi HelperProgram tiêu dùng quyền cấp của người dùng, và token nằm trong một tài khoản token mà `external_auth(adapter)` nó sở hữu, đó là lý do CPI có thể chi tiêu chúng.

Ghi chú về người ký. Rome ký cho đúng hai loại tài khoản: thẩm quyền trần của hợp đồng gọi (`Helper.pda(address(this))`), thứ ký mà không cần được liệt kê trong `các salt`, và một sub-PDA có muối cho mỗi mục trong `các salt`. Mọi salt bạn liệt kê phải xuất hiện trong danh sách tài khoản với vai trò người ký, nếu không lời gọi sẽ thất bại với `không tìm thấy tài khoản người ký được tính từ seed đã cung cấp`. Bất kỳ tài khoản nào khác được đánh dấu là người ký, bao gồm cả thẩm quyền của chính người dùng, sẽ không nhận seed nào từ Rome, và runtime Solana sẽ từ chối CPI. Quyền của người dùng đối với token của họ đến từ delegation, không bao giờ đến từ việc adapter ký thay cho người dùng.

Delegation không cần kéo: nếu chương trình của bạn nên chi tiêu trực tiếp từ tài khoản token của người dùng, người dùng gửi `HelperProgram.approve_spl_raw_delegate(userAta, yourProgramPda, amount, mint, decimals)` trực tiếp đến HelperProgram, đặt PDA của chương trình bạn làm SPL delegate. Rome bridge dùng cách này cho Wormhole. Quy tắc một delegate từ mục 3 cũng áp dụng ở đây: quyền cấp sẽ thay thế quyền cấp của wrapper.

## 8. Kiểm thử

* Triển khai chống lại **Hadrian** (testnet, chain 200010) trước; địa chỉ và RPC ở trong [Địa chỉ hợp đồng](https://docs.rome.builders/vi/tai-lieu-tham-khao/contract-addresses.md) và [registry](https://github.com/rome-protocol/rome-registry).
* `eth_call` và `eth_estimateGas` chạy cùng mô phỏng mà proxy dùng để gửi, vì vậy một CPI thất bại ở đó sẽ thất bại trên chain vì cùng một lý do, và dữ liệu revert mang theo lỗi Solana cơ bản (`lỗi gọi non-evm: …` trong log của chương trình Solana).
* Đọc phía Solana của một giao dịch EVM đã hạ cánh bằng `rome_solanaTxForEvmTx(hash)`; biên lai Solana là nơi chứa CU và log của chương trình bạn.
* Một CPI hoạt động trong `eth_call` nhưng bị từ chối khi gửi thường đã chạm một giới hạn mà mô phỏng báo cáo: giới hạn 64 địa chỉ, ngân sách CU nguyên tử (giao dịch đã chuyển sang lặp), hoặc quy tắc track.

## 9. Tham chiếu

* [Tham chiếu precompile](https://docs.rome.builders/vi/tai-lieu-tham-khao/precompiles.md) — mọi selector trên mọi precompile, cùng lớp dispatch và quy tắc delegatecall của nó.
* [Ràng buộc](https://docs.rome.builders/vi/cac-khai-niem-cot-loi/constraints.md) — các giới hạn ở trên trong một bảng.
* [Tương tác token](https://docs.rome.builders/vi/cac-khai-niem-cot-loi/token-interop.md) — wrapper, các canonical mint, deposit và withdraw.
* Các ứng dụng tham chiếu trong các kho công khai: [cardo](https://github.com/rome-protocol/cardo) (người dùng gọi trực tiếp precompile CPI, dạng B), [rome-dex](https://github.com/rome-protocol/rome-dex) (trực tiếp `invoke` cộng với một router không lưu ký, dạng C), và [aerarium](https://github.com/rome-protocol/aerarium) ("một ứng dụng cho vay Compound III trên một thị trường dùng chung; nó không gọi các chương trình Solana từ Solidity (không CPI), nên đây không phải là một ví dụ về adapter)."


---

# 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/huong-dan-cho-nha-phat-trien/integrate-solana-program.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.
