> 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/panduan-pengembang/integrate-solana-program.md).

# Integrasikan program Solana

Integrasikan program Solana dengan Rome EVM — siapa penandatangan Solana, bagaimana nilai mencapai program Anda dan kembali lagi, aturan lintasan tunggal, atomik vs iteratif, dan penyediaan akun.

Panduan ini ditujukan bagi tim program Solana yang ingin pengguna Rome EVM menggunakan program mereka — program privasi, pinjam-meminjam, atau vault yang seharusnya menyimpan nilai untuk akun EVM. Ini dibangun di atas [Panggil Solana dari EVM](https://docs.rome.builders/id/panduan-pengembang/call-solana-from-evm.md) (mekanika precompile) dan menjawab pertanyaan yang muncul setelah program sungguhan berada di sisi lainnya: *siapa* menandatangani, *bagaimana* token masuk dan keluar, dan *yang mana* batas yang membentuk desain.

Alur yang digunakan sepanjang panduan ini: sebuah akun EVM memindahkan USDC ke program Anda ("shield" atau "deposit"), program Anda menyimpannya untuk pengguna itu, dan nanti melepaskannya kembali ("unshield" atau "withdraw"). Ganti verba tersebut dengan istilah Anda sendiri.

## Setiap alamat EVM memiliki satu identitas Solana

Rome menurunkan sebuah akun Solana untuk setiap alamat EVM — baik pengguna maupun kontrak — yang disebut **otoritas eksternal**:

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

Ia memiliki associated token account milik alamat tersebut (di situlah `wUSDC.balanceOf(addr)` membaca darinya) dan merupakan kunci yang menandatangani CPI yang dibuat atas nama alamat itu. Program Anda melihat pubkey Solana 32-byte; ia tidak pernah melihat H160.

**Siapa yang menandatangani ditentukan oleh siapa yang memanggil precompile:**

| Precompile ini dipanggil oleh                                                   | Penandatangan Solana                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| ------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Sebuah **kontrak**, dengan `CALL`                                               | README **milik kontrak sendiri** otoritas eksternal (`external_auth(contract)`), ditambah sub-PDA dengan salt milik kontrak apa pun yang dimintanya                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| Sebuah **pengguna**, dalam transaksi yang dikirim langsung ke alamat precompile | README **milik pengguna sendiri** otoritas eksternal                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| Sebuah kontrak melalui `DELEGATECALL`                                           | Otoritas mentah ditolak (`DelegatecallOwnerAuthority`). `invoke` tanpa penandatangan, dan `invoke_signed` dengan sub-PDA bersalt, tetap dijalankan — tetapi sub-PDA tersebut dinamespace berdasarkan alamat kontrak yang berjalan (`["EXTERNAL_AUTHORITY", caller, running_contract, salt]`), jadi `pda_with_salt` tidak menurunkannya. Pada HelperProgram, hanya selector pembuatan dan pendanaan yang lolos (`create_ata*`, `create_pda*`, `swap_gas_to_lamports`, `init_spl_mint`, `create_and_init_mint`); mereka dikecualikan karena targetnya terikat pada pemanggil atau didanai oleh operator, bukan karena mereka tidak menandatangani apa pun |

Konsekuensinya adalah aturan ERC-20 yang sudah Anda kenal: **sebuah kontrak tidak dapat memindahkan aset pengguna sendirian.** Ia bertindak sebagai identitasnya sendiri, dan pengguna memberi hak kepadanya terlebih dahulu. Untuk token yang harus bergerak di sisi Solana, pemberian hak itu adalah delegasi SPL pada token account milik pengguna; ERC-20 dari wrapper `approve` hanyalah allowance di sisi EVM yang dihormati oleh transfer milik wrapper itu sendiri. Begitulah cara kerja wrapper token milik Rome, dan begitu juga cara kerja adapter Anda (bagian 3).

Sub-PDA bersalt: `invoke_signed` mengambil daftar `bytes32` salt bytes32, dan Rome menandatangani dengan `["EXTERNAL_AUTHORITY", caller_h160, salt]` untuk masing-masing (bump ditambahkan; pemanggil adalah kontrak pada panggilan langsung). `HelperProgram.pda_with_salt(addr, salt)` mengembalikan alamat dari Solidity. Gunakan satu salt per pengguna (misalnya alamat pengguna) ketika program Anda menginginkan akun pemilik yang berbeda untuk setiap posisi.

Pendanaan: PDA otoritas eksternal tidak harus sudah ada untuk memiliki ATA (`create_ata` bersifat idempoten dan pembayar biaya Solana dalam transaksi menanggung rentanya). PDA tersebut harus ada dan memegang lamports hanya ketika ia mendanai akun yang dibuat oleh instruksi Anda. `HelperProgram.create_pda(addr)` membuatnya sebagai System `CreateAccount`, jadi panggil sekali saja; ia tidak idempoten. `swap_gas_to_lamports(n)` mengkredit PDA alamat tersebut dengan `n` lamports dari pembayar biaya Solana pada transaksi, dan pemanggil membayarnya dalam gas Rome: setiap efek CPI pada track legacy terhadap saldo pembayar biaya ditambahkan ke biaya transaksi dan dibebankan kepada pengguna pada harga gas, sama seperti sewa untuk akun yang dibuat oleh CPI dibebankan. Langkah provisioning pada lane Solana dijelaskan di [Panggil EVM dari Solana](https://docs.rome.builders/id/panduan-pengembang/call-evm-from-solana.md); kontrak menyiapkan PDA miliknya sendiri di konstruktor atau panggilan pertamanya.

## 2. Tiga cara untuk menyimpan posisi pengguna

**A. Kontrak adapter (direkomendasikan untuk adapter yang dapat digunakan ulang).** Satu kontrak Solidity menjadi front-end bagi program Anda. Pengguna memberi otoritas adapter delegasi SPL pada token account mereka; adapter menarik token ke token account yang dimilikinya, memanggil program Anda sebagai dirinya sendiri, dan mengaitkan posisi pengguna di dalam program Anda dengan sub-PDA per pengguna atau dengan identifier yang diteruskannya dalam data instruksi. Saat keluar, adapter menyuruh program Anda melepaskannya ke token account milik pengguna sendiri. Adapter adalah satu-satunya identitas Solana yang perlu diketahui program Anda. Pemberian hak itu adalah delegasi SPL, bukan ERC-20 `approve`; bagian 3 menjelaskan mengapa dan berapa biayanya bagi pengguna.

**B. Pengguna sebagai penandatangan Solana.** Front end mengirim transaksi dari akun EVM pengguna **langsung ke precompile CpiProgram** (`to = 0xff…08`, calldata = yang telah di-encode ABI `invoke` atau `invoke_signed`), sehingga otoritas eksternal milik pengguna sendiri menandatangani dan program Anda mengaitkan posisi dengannya. Tidak ada kontrak adapter dan tidak ada delegasi, tetapi setiap tindakan adalah transaksi calldata yang buram di dompet, dan apa pun yang dibutuhkan alur selain CPI (ATA, transfer sebelumnya) adalah transaksi terpisah. Ini cocok untuk pemberian sekali pakai (misalnya milik pengguna `approve_spl` ke wrapper) dan untuk program sederhana, bukan untuk alur multi-langkah. [Cardo](https://github.com/rome-protocol/cardo) menggunakan bentuk ini: front end-nya mengirim `invoke` langsung ke precompile dari dompet pengguna.

**C. Router tanpa kustodi.** Kontrak yang tidak pernah memegang token pengguna. Pengguna memberi otoritas router delegasi SPL pada token account miliknya sendiri; router melakukan CPI ke program Anda dengan otoritas itu sebagai transfer authority, sehingga token berpindah dari token account pengguna ke akun program Anda (atau kembali ke milik pengguna), dan router tidak menyimpan apa pun di antara panggilan. Router menurunkan setiap akun di sisi pengguna dari `msg.sender`, jadi pemberian hak satu pengguna tidak dapat diarahkan ke akun pengguna lain, dan ia memanggil satu program tetap dengan bentuk instruksi tetap alih-alih bertindak sebagai `invoke` passthrough umum.  `RomeDexRouter` di [rome-dex](https://github.com/rome-protocol/rome-dex) ditulis dengan cara ini; lane EVM rome-dex juga menawarkan `invoke` jalur langsung mentah dengan bentuk B. Ia membutuhkan pemberian hak yang sama seperti A, dengan biaya satu-delegasi yang sama (bagian 3), dan tanpa langkah pull.

Sisa panduan ini mengikuti A; C menggunakan pemberian hak yang sama dan aturan penandatanganan yang sama.

## 3. Token masuk, token keluar

USDC di Rome adalah satu mint SPL yang dilihat dari dua sisi:  `wUSDC` wrapper ERC-20 di sisi EVM dan ATA milik otoritas eksternal di sisi Solana. Untuk alamat milik pengguna sendiri, keduanya adalah saldo yang sama: `wUSDC.balanceOf(user)` membaca ATA pengguna. Tidak ada yang berpindah atau tersinkronisasi antara kedua tampilan itu.

**Saldo wrapper milik kontrak bukanlah token account yang dikendalikan kontrak.** Factory men-deploy `SPL_ERC20_cached` untuk mint biasa, dan milik Hadrian `wUSDC` adalah salah satunya. Wrapper itu tidak dapat menandatangani untuk kontrak, jadi ketika `wUSDC.transferFrom(user, adapter, amount)` atau `transfer` mengirim token ke kontrak, token SPL berpindah ke **token account escrow milik wrapper sendiri** (`escrow_ata()`), dan wrapper mencatat jumlah per kontrak di penyimpanannya. `wUSDC.balanceOf(adapter)` mengembalikan catatan itu, sebuah buku besar escrow, bukan saldo dari token account yang dimiliki oleh `external_auth(adapter)`. Adapter Anda tidak dapat menyerahkan token itu ke program Anda dalam CPI; token tersebut hanya dapat keluar lagi melalui wrapper. Jadi adapter yang mendanai dirinya dengan `transferFrom` tidak memiliki apa pun yang dapat dibelanjakan di sisi Solana.

Jalur yang berfungsi adalah delegasi SPL:

* **Pemberian.** Pengguna mengirim `approve_spl(adapter, amount, mint)` sebagai transaksi **langsung ke HelperProgram** (`to = 0xff…09`), di mana `mint` adalah milik wrapper `mint_id()`. Otoritas milik pengguna sendiri menandatangani, dan delegate yang diset pada token account pengguna adalah otoritas eksternal milik adapter.
* **Masuk.** Milik adapter `deposit(amount)` menarik dengan overload delegate `HelperProgram.transfer_spl(srcAta, dstAta, amount, mint)`, dengan ATA pengguna sebagai sumber dan ATA milik adapter sendiri (`HelperProgram.ata(address(this), mint)`, dibuat sekali dengan `create_ata`) sebagai tujuan. Otoritas adapter menandatangani sebagai delegate. Token sekarang berada dalam token account yang dimiliki oleh `external_auth(adapter)`, yaitu akun yang disebut oleh CPI Anda; penandatangan dan sumbernya milik adapter sendiri, jadi tidak diperlukan izin tambahan. Mereka tidak muncul di `wUSDC.balanceOf(adapter)`.
* **Keluar.** Instruksi withdraw program Anda mentransfer ke **milik pengguna** ATA, `HelperProgram.ata(user, mint)`. Penerimaan tidak memerlukan tanda tangan dari pengguna, dan saldo langsung terlihat sebagai `wUSDC.balanceOf(user)`. Jika ATA mungkin belum ada, buat dulu dengan `HelperProgram.create_ata(user, mint)` (idempoten).

**Satu token account hanya memiliki satu delegate.** Pemberian hak di atas menggantikan pemberian hak milik wrapper pada akun itu. Sampai pengguna memberi wrapper lagi, setiap `wUSDC` `transfer` atau `transferFrom` keluar dari alamat mereka akan revert dengan error SPL `0x4`. Setelah alur apa pun yang menggunakan pemberian hak ini, panggil `wUSDC.isEnabled(user)`; ketika mengembalikan `false`, minta pengguna mengirim `approve_spl(wrapper, 2^64-1, mint)` ke HelperProgram lagi, yaitu pemberian maksimum yang menjadi dasar perancangan wrapper (lihat [Sekali pakai: beri wrapper](https://docs.rome.builders/id/panduan-pengembang/dual-lane-app.md#one-time-grant-the-wrapper)). Pemberian yang dibatasi akan merusak `wUSDC` transfer normal pengguna setelah habis, dan `isEnabled` tetap `true` selama masih ada sisanya, sehingga aplikasi tidak akan tahu kapan harus meminta lagi.

Untuk memeriksa wrapper mana yang dimiliki suatu mint, baca `wrapper_kind_by_mint(mint)` (alamat factory ada di `contracts.json` di [registry](https://github.com/rome-protocol/rome-registry)). `1` adalah wrapper cached yang dijelaskan bagian ini. `2` adalah wrapper direct-CPI yang di-deploy factory untuk mint Token-2022 dengan transfer hook yang aktif; panduan ini tidak membahasnya. Registry `tokens.json` mencantumkan alamat wrapper dan mint tetapi bukan jenisnya.

## 4. Satu track per kontrak, dan per transaksi

Rome memiliki dua keluarga precompile yang mengubah state Solana, dan **sebuah transaksi menggunakan tepat salah satunya** — runtime menolak transaksi yang mencampur panggilan mutating dari keduanya, bahkan lintas kontrak.

| Track      | Precompile                                                                                          | Efek masuk                                                                                   | Bekerja dalam eksekusi iteratif                                                           |
| ---------- | --------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- |
| **Legacy** | `CpiProgram` `0xff…08` (`invoke`, `invoke_signed`), `HelperProgram` `0xff…09`, `Withdraw` `0x42…16` | Segera, sebagai CPI sungguhan di dalam langkah EVM                                           | **Tidak** — CPI legacy dalam transaksi iteratif gagal dengan `CpiProhibitedInIterativeTx` |
| **Cached** | `SplCached` `0xff…05`, `ASplCached` `0xff…06`, `SystemCached` `0xff…04`, `WithdrawCached` `0xff…0b` | Dipentaskan dalam overlay dan dikomit sebagai CPI di akhir transaksi; revert EVM membuangnya | Ya                                                                                        |

Artinya bagi integrasi program:

* **Memanggil instruksi program Anda sendiri hanya boleh di track legacy.** Track cached tidak memiliki `invoke`; ia mencakup transfer SPL, pembuatan ATA, operasi system-program, dan penarikan gas.
* Jadi langkah yang mendanai adapter juga harus di track legacy jika berjalan dalam transaksi yang sama dengan CPI.  `transferFrom` adalah panggilan track cached, sehingga tidak dapat berbagi transaksi dengan CPI Anda (dan, seperti ditunjukkan bagian 3, itu hanya akan mengkredit buku besar escrow). Tarik dengan `HelperProgram.transfer_spl(userAta, adapterAta, amount, mint)` sebagai gantinya, setelah pengguna menjadikan adapter sebagai delegate SPL (`approve_spl`, dikirim oleh pengguna langsung ke HelperProgram). Pull dan CPI keduanya berada di track legacy, jadi keduanya berjalan dalam satu transaksi.
* **Jauhkan wrapper dari transaksi itu.** Jangan panggil fungsi mutating wrapper (`wUSDC.transfer`, `transferFrom`) dari adapter dalam transaksi yang sama dengan CPI legacy. Periksa `isEnabled(user)` dan saldo dari front end dengan `eth_call`.
* **Dan transaksi CPI harus atomik.** Itulah batas yang menjadi dasar desain ini.

Pembacaan berada di luar aturan: `account_info`, `account_data_at`, `account_u64_at`, `account_lamports`, `pdas_batch_derive` dan `HelperProgram.user_balance` / `). Setiap metode` adalah pembacaan akun yang sudah dimuat (tanpa CPI), diizinkan pada track mana pun dan pada kedua mode eksekusi. Letakkan pemeriksaan awal Anda di sana. Satu aturan urutan: setelah mutasi cached dipicu dalam sebuah transaksi, pembacaan track legacy diblokir untuk sisa transaksi itu — baca dulu, baru mutasi.

## 5. Atomik adalah anggarannya

Transaksi atomik Rome adalah satu transaksi Solana: sekitar **1,4 juta compute unit**, sebuah **64-alamat** daftar akun dan **4 KB** transaksi Solana v1). Program Rome dan CPI Anda berbagi anggaran itu. Transfer wrapper berjalan sekitar 170K CU di Hadrian dan instruksi Anda menambah CU sendiri; ukur dengan receipt Solana `computeUnitsConsumed`, bukan EVM `gasUsed`.

Ketika emulasi memutuskan transaksi tidak muat, Rome menjalankannya **secara iteratif** melintasi beberapa transaksi Solana, dan CPI legacy di dalamnya kemudian gagal. Batasi setiap deposit dan withdraw pada satu perpindahan token plus satu CPI ke program Anda, dan buat Solidity di sekitarnya tetap kecil. Pecah apa pun yang lebih besar menjadi dua transaksi pengguna.

Kedalaman CPI: Solana mengizinkan 4 level dan Rome memakai satu, jadi instruksi Anda berjalan di level 2 dengan dua level di bawahnya (program Anda → SPL Token menyisakan satu).

## 6. Provisioning akun

Program Anda tidak menerima akunnya dari Solidity saat runtime. Proxy **mengemulasi** setiap transaksi sebelum mengirimnya, mencatat setiap akun Solana yang disentuh CPI, dan menempatkannya di transaksi Solana. Adapter Anda menamai akun-akun dalam `invoke_signed` daftar akun; emulasi membuktikan bahwa semuanya ter-resolve. Tiga hal berikut berlaku:

* Setiap akun yang disentuh instruksi Anda harus dapat diturunkan dari input yang dimiliki adapter (PDA dan sub-PDA miliknya sendiri, ID program Anda, mint, alamat pengguna). `SystemProgram.find_program_address` dan `CpiProgram.pdas_batch_derive` melakukan derivasi di Solidity.
* Akun yang belum ada (posisi baru, ATA baru) tetap harus disebut dalam daftar akun; alamatnya itulah yang masuk ke transaksi Solana.
* Semua yang disentuh transaksi — termasuk akun milik Rome sendiri untuk pengguna, adapter, dan wrapper — harus tetap di bawah 64 alamat. Desain yang menyentuh sepuluh market dalam satu panggilan tidak akan muat.

Untuk lane dompet Solana, `rome_emulateCallAccounts` mengekspos penemuan yang sama ke klien; SDK menggunakannya.

Dua akun yang tidak boleh disebut oleh CPI: pembayar biaya Solana yang mengirim transaksi (kecuali di dalam instruksi transfer System biasa) dan program Rome itu sendiri. CPI kembali ke program Rome ditolak.

## 7. Sebuah deposit dan sebuah withdraw, dalam Solidity

Sketsa minimal adapter pada track legacy. Pengguna sudah mengirim `approve_spl(adapter, amount, mint)` ke HelperProgram (bagian 3). `PRIVACY_PROGRAM` adalah ID program Anda; `encodeDeposit` / `encodeWithdraw` membangun data instruksi Anda (Borsh, little-endian); account meta mengikuti tata letak instruksi Anda.

```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));                 // identitas Solana milik adapter sendiri
        Helper.create_ata(address(this), USDC_MINT);      // dan akun USDC yang dimilikinya
    }

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

    function deposit(uint64 amount) external {
        bytes32 self       = Helper.pda(address(this));                   // penandatangan: otoritas adapter
        bytes32 adapterAta = Helper.ata(address(this), USDC_MINT);
        bytes32 position   = Helper.pda_with_salt(address(this), _salt(msg.sender)); // sub-PDA per pengguna, juga menandatangani

        // Tarik dari token account milik pengguna. Otoritas adapter menandatangani sebagai SPL
        // delegate yang diberikan pengguna; ini adalah panggilan track legacy, seperti CPI di bawah.
        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);                          // sumber: dimiliki oleh otoritas adapter
        accs[3] = ICrossProgramInvocation.AccountMeta(_vaultFor(position), false, true);                 // vault program Anda
        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);            // tujuan: akun milik pengguna sendiri
        // ... bentuk yang sama: program Anda memindahkan `amount` dari vault ke userAta, ditandatangani oleh `position`
        Cpi.invoke_signed(PRIVACY_PROGRAM, accs, encodeWithdraw(amount), salts);
    }
}
```

Adapter tidak pernah memanggil `wUSDC` kontrak. Pull adalah panggilan HelperProgram yang membelanjakan delegasi pengguna, dan token berada di token account yang `external_auth(adapter)` memilikinya, itulah sebabnya CPI dapat membelanjakannya.

Catatan tentang penandatangan. Rome menandatangani tepat dua jenis akun: otoritas mentah kontrak pemanggil (`Helper.pda(address(this))`), yang menandatangani tanpa dicantumkan dalam `salts`, dan satu sub-PDA bersalt untuk setiap entri di `salts`. Setiap salt yang Anda cantumkan harus muncul di daftar akun sebagai penandatangan, atau panggilan gagal dengan `akun penandatangan yang dihitung dari seed yang diberikan tidak ditemukan`. Akun lain yang ditandai sebagai penandatangan, termasuk otoritas milik pengguna sendiri, tidak mendapat seed dari Rome, dan runtime Solana menolak CPI. Hak pengguna atas token mereka berasal dari delegasi, bukan dari adapter yang menandatangani sebagai pengguna.

Delegasi tanpa pull: jika program Anda harus membelanjakan langsung dari token account pengguna, pengguna mengirim `HelperProgram.approve_spl_raw_delegate(userAta, yourProgramPda, amount, mint, decimals)` langsung ke HelperProgram, dengan menyebut PDA program Anda sebagai delegate SPL. Jembatan Rome menggunakan ini untuk Wormhole. Aturan satu-delegate dari bagian 3 juga berlaku di sini: pemberian hak itu menggantikan milik wrapper.

## 8. Pengujian

* Deploy ke **Hadrian** (testnet, chain 200010) terlebih dahulu; alamat dan RPC ada di [Contract Addresses](https://docs.rome.builders/id/referensi/contract-addresses.md) dan [registry](https://github.com/rome-protocol/rome-registry).
* `eth_call` dan `eth_estimateGas` jalankan emulasi yang sama seperti yang digunakan proxy untuk mengirim, sehingga CPI yang gagal di sana juga gagal di chain karena alasan yang sama, dan data revert membawa error Solana yang mendasarinya (`non-evm call error: …` di log program Solana).
* Baca sisi Solana dari transaksi EVM yang sudah landed dengan `rome_solanaTxForEvmTx(hash)`; receipt Solana adalah tempat CU dan log program Anda berada.
* CPI yang berhasil di `eth_call` tetapi ditolak saat dikirim biasanya menyentuh batas yang dilaporkan emulasi: batas 64 alamat, anggaran CU atomik (transaksi menjadi iteratif), atau aturan track.

## 9. Referensi

* [Referensi precompile](https://docs.rome.builders/id/referensi/precompiles.md) — setiap selector pada setiap precompile, beserta kelas dispatch dan aturan delegatecall.
* [Batasan](https://docs.rome.builders/id/konsep-inti/constraints.md) — batas-batas di atas dalam satu tabel.
* [Interoperabilitas Token](https://docs.rome.builders/id/konsep-inti/token-interop.md) — wrapper, canonical mint, deposit, dan withdraw.
* Aplikasi referensi di repositori publik: [cardo](https://github.com/rome-protocol/cardo) (pengguna memanggil precompile CPI secara langsung, bentuk B), [rome-dex](https://github.com/rome-protocol/rome-dex) (langsung `invoke` plus router tanpa kustodi, bentuk C), dan [aerarium](https://github.com/rome-protocol/aerarium) (aplikasi pinjam-meminjam Compound III di atas satu market bersama; ia tidak memanggil program Solana dari Solidity (tanpa CPI), jadi itu bukan contoh 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/id/panduan-pengembang/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.
