> 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/08-open-your-solana-program-to-evm-users.md).

# 8. Buka program Solana Anda untuk pengguna EVM

Biarkan pengguna MetaMask memanggil program yang sudah Anda jalankan di Solana, melalui kontrak Solidity tipis dan precompile CPI, tanpa porting dan tanpa salinan kedua dari state Anda.

Anda memiliki program Solana yang berfungsi. Penggunanya memegang wallet Solana. Rome memungkinkan audiens kedua menjangkaunya, yaitu orang yang memegang wallet EVM seperti MetaMask, tanpa Anda menulis ulang program dalam Solidity.

## Apa yang akan Anda pelajari

* Mengapa Anda membuka program Solana untuk pengguna EVM, dan apa yang tetap Anda pertahankan.
* Bagaimana panggilan EVM mencapai program Anda: kontrak Solidity tipis dan precompile CPI.
* Apa yang dilihat program Anda sebagai penandatangan dan akun-akun.
* Bagaimana token pengguna EVM mencapai program Anda dan kembali lagi.
* Batasan yang perlu Anda rancang di sekitarnya: satu jalur, satu transaksi atomik, batas akun.

## Kasus penggunaan

Pelajaran ini melayani sebuah kasus penggunaan dari [Apa yang bisa Anda bangun](https://docs.rome.builders/id/rome-academy/02-what-you-can-build.md): sebuah aplikasi Solana yang sudah ada dan menginginkan lebih banyak pengguna. Pasar pinjam-meminjam, AMM, vault, pasar prediksi, atau program privasi semuanya cocok.

Audiens EVM sangat besar dan sudah memiliki wallet, tooling, dan kebiasaan. Jika Anda mem-port program Anda ke Solidity, Anda harus memelihara dua codebase dan memisahkan state Anda. Di Rome Anda mempertahankan satu program dan satu state. Pengguna EVM menjangkaunya melalui kontrak Solidity kecil, dan pengguna Solana tetap memanggilnya secara native. Keduanya bertransaksi melawan akun yang sama dan likuiditas yang sama. [Pilih core Anda](https://docs.rome.builders/id/konsep-inti/choose-your-core.md) menyebut bentuk ini (b), inti Solana native dengan router CPI tipis.

[rome-dex](https://github.com/rome-protocol/rome-dex) adalah referensinya: pool Solana native, dengan router EVM di depannya.

## Sebelum Anda mulai

* Selesaikan [7. Buka aplikasi EVM Anda untuk dompet Solana](https://docs.rome.builders/id/rome-academy/07-open-to-solana-wallets.md), ide yang sama dari sisi yang lain.
* Ketahui [5. Memanggil Solana dari Solidity](https://docs.rome.builders/id/rome-academy/05-call-solana-from-solidity.md) dan [6. Token di kedua sisi](https://docs.rome.builders/id/rome-academy/06-tokens-on-both-sides.md). Pelajaran ini menyusunnya.
* Pastikan program Anda telah di-deploy ke Solana devnet. Hadrian menyelesaikan di sana, jadi program itu harus ada di klaster tersebut. Lihat [Hadrian](https://docs.rome.builders/id/jaringan/hadrian.md).

## Alur singkatnya

### Langkah 1: letakkan satu kontrak tipis di depan program Anda

Kontrak ini adalah adaptor. Ia tidak menyimpan logika bisnis. Ia memeriksa pemanggil, membangun instruksi Anda, dan memanggil precompile CPI dengan `invoke_signed`. Sisanya tetap berada di program Solana Anda. Mekanisme pemanggilannya ada di [Panggil Solana dari EVM](https://docs.rome.builders/id/panduan-pengembang/call-solana-from-evm.md#calling-custom-solana-programs), dan antarmukanya ada di `contracts/interface.sol` dalam publik [rome-solidity](https://github.com/rome-protocol/rome-solidity) repo.

Adaptor Anda memiliki tiga cara untuk menyimpan posisi pengguna. Panduan ini membandingkannya di [Tiga cara menyimpan posisi pengguna](https://docs.rome.builders/pages/de3c03c10c2c7172c7cd997fea161c30ba9ca94f#id-2.-three-ways-to-hold-a-users-position):

| Bentuk                        | Apa itu                                                                     | Cocok untuk                                                 |
| ----------------------------- | --------------------------------------------------------------------------- | ----------------------------------------------------------- |
| Kontrak adaptor               | Menarik token pengguna, lalu memanggil program Anda sebagai dirinya sendiri | Front yang dapat dipakai ulang untuk program dengan setoran |
| Pengguna memanggil precompile | Otoritas pengguna sendiri menandatangani, tanpa kontrak                     | Pemberian izin sekali pakai dan program sederhana           |
| Router tanpa kustodi          | Tidak pernah memegang token, memakai delegasi pengguna                      | Swap dan aksi sekali jalan lainnya                          |

Pilih adaptor untuk vault atau program pinjam-meminjam, dan router untuk swap.

### Langkah 2: ketahui siapa yang dilihat program Anda

Setiap alamat EVM memiliki identitas Solana, yaitu external-authority PDA miliknya, yang diturunkan di bawah program Rome. Saat sebuah kontrak memanggil precompile, Rome menandatangani dengan otoritas kontrak itu. Program Anda melihat sebuah public key 32-byte yang ditandai sebagai penandatangan. Program itu tidak pernah melihat alamat EVM 20-byte dan tidak pernah melihat pengguna.

Jadi pengguna bukan penandatangan. Untuk membedakan pengguna, adaptor meneruskan nilai per-pengguna di data instruksi, atau meminta Rome untuk juga menandatangani dengan sub-PDA yang diberi salt dan diturunkan dari alamat pengguna. Program Anda kemudian menyimpan satu posisi per sub-PDA. Aturan penandatangan ada di [Setiap alamat EVM memiliki satu identitas Solana](https://docs.rome.builders/pages/de3c03c10c2c7172c7cd997fea161c30ba9ca94f#id-1.-every-evm-address-has-one-solana-identity).

Tulislah program Anda agar bertindak berdasarkan otoritas mana pun yang menandatangani. Dengan begitu, program itu melayani wallet Solana maupun adaptor.

### Langkah 3: pindahkan token pengguna

Di Rome, USDC milik pengguna adalah satu token SPL yang dilihat dari dua sisi, seperti yang ditunjukkan pelajaran 6. Saldo pengguna berada di akun token yang dimiliki oleh otoritasnya. Agar adaptor dapat membelanjakannya, pengguna memberikan delegasi SPL kepada adaptor sebelum deposit. Adaptor menarik token ke akun token miliknya sendiri, lalu memanggil program Anda. Saat keluar, program Anda membayar ke akun token milik pengguna sendiri, dan pengguna melihatnya seketika sebagai saldo ERC-20.

Ada dua jebakan yang penting di sini:

* Sebuah ERC-20 `transferFrom` ke sebuah kontrak hanya mengkredit ledger escrow wrapper tersebut. Kontrak itu tidak mendapatkan akun token untuk dibelanjakan. Gunakan delegasi, bukan wrapper.
* Sebuah akun token hanya memiliki satu delegasi. Pemberian izin Anda menggantikan pemberian izin wrapper, dan transfer token biasa pengguna berhenti sampai mereka memberi izin ke wrapper lagi. Periksa `isEnabled` setelah alur Anda.

Urutan lengkapnya ada di [Token masuk, token keluar](https://docs.rome.builders/pages/de3c03c10c2c7172c7cd997fea161c30ba9ca94f#id-3.-tokens-in-tokens-out).

### Langkah 4: tetap berada dalam batasan

* **Satu jalur.** Panggilan program kustom adalah CPI jalur legacy. Sebuah transaksi tidak boleh mencampurnya dengan panggilan jalur cached, jadi jangan sertakan wrapper cached di dalam transaksi itu.
* **Hanya atomik.** CPI jalur legacy tidak dapat dijalankan dalam transaksi iteratif. Seluruh panggilan harus muat dalam satu transaksi Solana, sekitar 1,4 juta compute unit, 64 alamat, dan 4 KB. Program Anda berbagi anggaran compute itu dengan program Rome.
* **Akun di awal.** Rome meniru panggilan dan menempatkan setiap akun yang disentuhnya ke dalam transaksi Solana. Setiap akun harus dapat diturunkan dari input yang dimiliki adaptor. Akun baru tetap diberi nama.
* **Kedalaman dangkal.** Program Anda berjalan satu tingkat di bawah Rome. Setiap program yang dipanggilnya memakai satu tingkat lagi.
* **Biaya sewa ditanggung pengguna.** Akun yang dibuat instruksi Anda dibayar melalui gas pengguna.

Batasi setiap aksi menjadi satu pergerakan token dan satu CPI ke program Anda. Pecah apa pun yang lebih besar menjadi dua transaksi pengguna. Batas-batasnya ada dalam satu tabel di [Batasan](https://docs.rome.builders/id/konsep-inti/constraints.md).

## Contoh yang dikerjakan

Misalkan program Anda adalah sebuah vault. Seorang pengguna Solana menyetor USDC dan kemudian menariknya. Anda ingin pengguna MetaMask melakukan hal yang sama.

1. Anda men-deploy adaptor yang mengetahui program ID Anda dan mint USDC. Dalam konstruktornya, adaptor itu membuat identitas Solana sendiri dan sebuah akun token untuknya.
2. Seorang pengguna MetaMask mengirim satu transaksi yang memberi adaptor delegasi SPL pada USDC mereka.
3. Pengguna memanggil `deposit`. Adaptor menarik USDC ke akun token miliknya sendiri, lalu memanggil program Anda dengan otoritas miliknya sendiri dan sub-PDA yang diberi salt untuk pengguna itu sebagai penandatangan.
4. Program Anda memindahkan USDC ke vault-nya dan mencatat posisi di bawah sub-PDA.
5. Pemberian izin adaptor menggantikan milik wrapper, jadi aplikasi Anda membaca `isEnabled` pada wrapper untuk pengguna. Itu mengembalikan `false`, dan pengguna mengirim `approve_spl` untuk wrapper lagi. Deposit berikutnya memerlukan pemberian izin baru kepada adaptor.
6. Pengguna memanggil `withdraw`. Adaptor meminta program Anda membayar dari vault langsung ke akun token pengguna. Saldo muncul di MetaMask sebagai token ERC-20.

Pengguna Solana Anda tidak pernah menyentuh adaptor. Mereka memanggil vault secara langsung dan melihat total yang sama. Sketsa Solidity yang cocok ada di [Deposit dan penarikan, dalam Solidity](https://docs.rome.builders/pages/de3c03c10c2c7172c7cd997fea161c30ba9ca94f#id-7.-a-deposit-and-a-withdraw-in-solidity).

Uji di Hadrian terlebih dahulu. `eth_call` dan `eth_estimateGas` menjalankan emulasi yang sama seperti yang dipakai proxy untuk mengirim, jadi CPI yang gagal di sana juga gagal di chain karena alasan yang sama, dan revert membawa error program Anda. Setelah pengiriman, baca sisi Solana dari transaksi dengan `rome_solanaTxForEvmTx`. Lihat [Pengujian](https://docs.rome.builders/pages/de3c03c10c2c7172c7cd997fea161c30ba9ca94f#id-8.-testing).

## Uji diri Anda

Ambil program kecil milik Anda sendiri, atau yang ada di rome-dex, dan tuliskan, tanpa kode:

1. Penandatangan yang dilihat program Anda saat adaptor memanggilnya.
2. Akun-akun yang dinamai oleh satu deposit.
3. Jumlah pergerakan token dan CPI dalam deposit itu.

Lalu deploy adaptor Anda di Hadrian, danai akun token pengguna, kirim grant SPL ke adaptor, dan jalankan deposit melalui `eth_estimateGas` dengan alamat pengguna sebagai `dari`. Estimasi seharusnya berhasil. Jika gagal, data revert menyebutkan error Solana.

<details>

<summary>1. Seorang pengguna MetaMask menyetor melalui adaptor Anda. Siapa yang menandatangani untuk program Anda?</summary>

external-authority PDA adaptor, ditambah sub-PDA yang diberi salt jika adaptor mencantumkannya. Bukan pengguna. Hak pengguna berasal dari delegasi SPL yang mereka berikan.

</details>

<details>

<summary>2. Mengapa tidak menarik USDC pengguna dengan <code>transferFrom</code>?</summary>

Token itu akan mendarat di akun escrow wrapper dan dicatat dalam ledger-nya. Adaptor tidak akan memiliki akun token miliknya sendiri untuk diteruskan ke program Anda.

</details>

<details>

<summary>3. Deposit Anda membesar sampai menghasilkan sepuluh CPI dan Rome menjalankannya secara iteratif. Apa yang terjadi?</summary>

Itu gagal. CPI jalur legacy ditolak dalam transaksi iteratif. Kecilkan aksi menjadi satu pergerakan token dan satu CPI, atau pecah menjadi dua transaksi.

</details>

## Berikutnya

[9. Bangun aplikasi dual-lane](https://docs.rome.builders/id/rome-academy/09-build-a-dual-lane-app.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/08-open-your-solana-program-to-evm-users.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.
