> 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/rome-academy/05-call-solana-from-solidity.md).

# 5. Panggil Solana dari Solidity

Gunakan precompile CPI dan Helper milik Rome untuk membaca akun Solana, membuat akun token, dan memanggil program Solana dari kontrak Solidity.

Di Rome, sebuah kontrak Solidity dapat membaca akun Solana dan memanggil program Solana dalam transaksi yang sama. Anda akan membaca saldo token Solana, membuat akun token, dan mempelajari cara membangun pemanggilan program.

## Apa yang akan Anda pelajari

* Apa itu precompile di Rome dan tiga mana yang paling sering akan Anda gunakan.
* Tanda tangan siapa yang dilihat program Solana saat kontrak Anda memanggilnya.
* Cara membaca state Solana dan membuat akun token dari Solidity.
* Aturan yang menentukan apakah pemanggilan Solana berhasil: akun yang dideklarasikan, satu jalur, hanya atomik.

## Sebelum Anda mulai

* Selesaikan [4. Bagaimana Rome menjalankan kode Anda](https://docs.rome.builders/id/rome-academy/04-how-rome-runs-your-code.md). Anggaran atomik dan batas 64 akun penting di sini.
* Pastikan dompet Hadrian Anda terisi dana dan pengaturan deployment dari pelajaran 3 berfungsi. Faucet tercantum di [Faucets](https://docs.rome.builders/id/sumber-daya/faucets.md).
* Instal antarmuka Rome Solidity dari `rome-solidity` repo, seperti dijelaskan di [Deploy Solidity](https://docs.rome.builders/id/panduan-pengembang/deploy-solidity.md#using-the-rome-solidity-sdk).

## Precompile adalah pintunya

Precompile adalah alamat tetap yang menjalankan kode native alih-alih bytecode. Ethereum memiliki beberapa, seperti `ecrecover`. Rome menambahkan precompile yang tugasnya menjangkau Solana. Anda memanggilnya seperti kontrak apa pun, melalui sebuah antarmuka.

Anda akan menggunakan tiga:

| Precompile    | Apa yang diberikannya kepada Anda                                                                              |
| ------------- | -------------------------------------------------------------------------------------------------------------- |
| CpiProgram    | `invoke` dan `invoke_signed` untuk memanggil program Solana apa pun, plus tampilan hanya-baca dari akun Solana |
| HelperProgram | Operasi token dan akun siap pakai: membuat akun token, mentransfer token SPL, menurunkan alamat                |
| System        | Penurunan PDA dan konversi base58                                                                              |

Alamat-alamatnya ada di [Referensi precompile](https://docs.rome.builders/id/referensi/precompiles.md) dan [Alamat kontrak](https://docs.rome.builders/id/referensi/contract-addresses.md). Anda tidak perlu mengetiknya. Mengimpor `interface.sol` dari `rome-solidity` memberi Anda konstanta siap pakai bernama `CpiProgram`, `HelperProgram` dan `SystemProgram`.

## Siapa yang menandatangani

Saat kontrak Anda memanggil precompile, Solana melihat identitas kontrak Anda sendiri, bukan identitas pengguna. Setiap alamat EVM memiliki alamat yang diturunkan program Solana, yaitu PDA otoritas-eksternalnya. Alamat itu memiliki akun token pada alamat tersebut dan menandatangani atas namanya.

Ini adalah aturan yang sama seperti yang Anda kenal dari ERC-20: sebuah kontrak tidak dapat memindahkan aset pengguna kecuali pengguna mengizinkannya. Pelajaran 6 menunjukkan bagaimana pengguna mengizinkannya di Rome. Aturan dan tiga cara untuk menyimpan posisi pengguna ada di [Integrasikan program Solana](https://docs.rome.builders/pages/de3c03c10c2c7172c7cd997fea161c30ba9ca94f#id-1.-every-evm-address-has-one-solana-identity).

## Langkah 1: baca sebelum menulis

Mulailah dengan membaca. Pembacaan tidak mengubah state dan bekerja dalam eksekusi atomik maupun iteratif. Baca sebelum Anda melakukan mutasi: setelah panggilan yang di-cache dijalankan, pembacaan jalur lama akan ditolak untuk sisa transaksi.

```solidity
import "@rome-protocol/rome-solidity/contracts/interface.sol";

contract SolanaPeek {
    // Akun token yang digunakan Rome untuk pemanggil dan mint gas jaringan
    function myTokenAccount() external view returns (bytes32) {
        return HelperProgram.ata(msg.sender, SystemProgram.mint_id());
    }

    // Saldo pemanggil pada akun itu
    function myBalance() external view returns (uint64) {
        return HelperProgram.user_balance(msg.sender, SystemProgram.mint_id());
    }
}
```

Alamat Solana adalah `bytes32` di sini, bukan alamat 20-byte. Pembacaan lainnya, `account_info`, `account_data_at` dan `account_u64_at`, memungkinkan Anda memeriksa akun Solana mana pun. Lihat [Membaca data akun](https://docs.rome.builders/id/panduan-pengembang/call-solana-from-evm.md#reading-account-data).

## Langkah 2: gunakan helper

Untuk tugas umum Anda tidak memerlukan instruksi buatan tangan. Helper membuat akun token, memindahkan token SPL dan lamport, serta mengonversi antara gas dan lamport. Tanda tangannya ada di `contracts/interface.sol`, dan contoh kontrak lengkap ada di [Transfer lamport](https://docs.rome.builders/id/panduan-pengembang/call-solana-from-evm.md#transfer-lamports).

```solidity
function createMyAta() external {
    HelperProgram.create_ata(msg.sender, SystemProgram.mint_id());
}
```

Kontrak yang memanggil Helper bertindak sebagai dirinya sendiri. Token yang dipindahkannya adalah miliknya sendiri, bukan milik pengguna.

## Langkah 3: panggil program Solana apa pun

Untuk program yang tidak dicakup oleh helper, buat sendiri daftar akun dan byte instruksi, lalu panggil `invoke`. Setiap akun adalah pubkey ditambah dua flag, signer dan writable. Data instruksi adalah apa pun yang diharapkan program target, biasanya Borsh.

Kontrak lengkapnya ada di [Memanggil program Solana kustom](https://docs.rome.builders/id/panduan-pengembang/call-solana-from-evm.md#calling-custom-solana-programs). `invoke_signed` menambahkan sub-PDA yang diberi salt saat target membutuhkan lebih dari satu penandatangan dari kontrak Anda. Untuk mendapatkan alamat PDA di dalam Solidity, gunakan `find_program_address` pada precompile System; lihat [Penurunan PDA](https://docs.rome.builders/id/panduan-pengembang/call-solana-from-evm.md#pda-derivation).

## Aturan yang menentukan apakah itu berhasil

* **Deklarasikan setiap akun.** Solana memerlukan daftar akun lengkap sebelum panggilan dijalankan. Proxy menemukannya dengan meniru transaksi Anda terlebih dahulu, jadi setiap akun harus dapat diturunkan dari input yang dimiliki kontrak. Totalnya harus tetap berada dalam batas 64 alamat.
* **Tetap atomik.** Sebuah panggilan yang membuat CPI jalur lama tidak dapat dijalankan secara iteratif. Itu harus muat dalam satu transaksi atomik, jadi batasi setiap aksi menjadi satu perpindahan token dan satu CPI.
* **Pilih satu jalur.** Rome memiliki dua keluarga precompile yang mengubah state Solana: legacy (`CpiProgram`, `HelperProgram`, `Withdraw`) dan cached (yang `...Cached` set). Satu transaksi menggunakan satu keluarga. Hanya jalur legacy yang dapat memanggil program kustom. Baca tabel di [Integrasikan program Solana](https://docs.rome.builders/pages/de3c03c10c2c7172c7cd997fea161c30ba9ca94f#id-4.-one-track-per-contract-and-per-transaction).
* **Jaga kedalaman tetap dangkal.** Pemanggilan Anda ke program Solana menggunakan level CPI, dan begitu pula setiap program yang dipanggilnya secara berantai. Batas kedalaman Solana rendah. [Batasan](https://docs.rome.builders/id/konsep-inti/constraints.md#cpi-constraints) menjelaskan level-levelnya.
* **Tidak ada panggilan balik ke Rome.** Sebuah CPI tidak dapat menyebut atau memanggil program Rome. CPI juga tidak dapat menyebut fee payer Solana kecuali dalam instruksi System transfer biasa.

## Uji diri Anda

Tambahkan `createMyAta` menjadi `SolanaPeek` dan deploy ke Hadrian. Lalu:

1. Panggil `myTokenAccount` dan `myBalance` dengan panggilan baca dari alamat dompet Anda.
2. Kirim transaksi yang memanggil `createMyAta`.
3. Buka transaksi di explorer Hadrian. Lihat [Via explorer](https://docs.rome.builders/id/aplikasi-di-rome/via.md).

Anda seharusnya melihat instruksi Solana di balik panggilan Anda dan unit komputasinya. Panggilan yang mencapai Solana menampilkan program Solana di explorer, bukan hanya panggilan EVM.

<details>

<summary>1. Sebuah kontrak memanggil <code>HelperProgram.transfer_spl</code>. Token siapa yang dipindahkan?</summary>

Milik kontrak itu sendiri. Penandatangan adalah PDA otoritas-eksternal milik kontrak. Untuk memindahkan token pengguna, pengguna harus memberikan hak terlebih dahulu.

</details>

<details>

<summary>2. Mengapa panggilan yang menggunakan <code>invoke</code> harus muat dalam satu transaksi atomik?</summary>

CPI jalur legacy ditolak di dalam transaksi iteratif. Jika panggilan memerlukan lebih dari satu transaksi Solana, maka gagal.

</details>

<details>

<summary>3. Pembacaan mana yang dapat Anda andalkan dalam mode eksekusi apa pun?</summary>

Tampilan hanya-baca: `account_info`, `account_data_at`, `account_u64_at`, `account_lamports`, `pdas_batch_derive` dan pembacaan Helper seperti `allowance_of`. Semuanya tidak memiliki efek samping. Jalankan sebelum mutasi cached apa pun dalam transaksi yang sama.

</details>

## Berikutnya

[6. Token di kedua sisi](https://docs.rome.builders/id/rome-academy/06-tokens-on-both-sides.md)


---

# 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/rome-academy/05-call-solana-from-solidity.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.
