> 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/call-evm-from-solana.md).

# Panggil EVM dari Solana

Biarkan dompet Solana mengendalikan kontrak EVM di Rome — tanpa kunci Ethereum. Dompet menandatangani, dan transaksinya masuk ke Solana.

Kebalikan dari [Panggil Solana dari EVM](https://docs.rome.builders/id/panduan-pengembang/call-solana-from-evm.md): dompet Solana (misalnya Solflare) memanggil kontrak EVM apa pun di Rome secara langsung, dengan **tanpa kunci Ethereum**. Inilah cara [Aerarium](https://docs.rome.builders/id/aplikasi-di-rome/apps.md) memungkinkan pengguna native Solana berbagi kontrak yang sama dengan pengguna EVM.

Cara satu panggilan adalah milik SDK `submitRomeTxV1`, yang membuat proxy menyusun satu transaksi Solana v1 untuk panggilan tersebut; halaman ini menjelaskan mekanismenya.

## Alamat sintetis

Identitas EVM dari dompet Solana adalah **alamat sintetis** — 20 byte terakhir dari `keccak256` dari kunci publik Solana 32 byte-nya:

```
synthetic_evm_address = keccak256(solana_pubkey)[12:]
```

Ini adalah `msg.sender` saat dompet memanggil kontrak, dan identitas stabil tempat nonce dan penyimpanannya berada. Derivasinya dipatok di protokol, jadi sebuah dompet selalu dipetakan ke alamat yang sama.

```javascript
import { syntheticAddress } from "@rome-protocol/sdk";
const from = syntheticAddress(solanaPubkey); // 0x… 20 bytes
```

## Synthetic ini adalah perantara — ia tidak menyimpan token saat tidak aktif

Saldo yang dapat dibelanjakan milik pengguna native Solana berada di **wallet Solana** (sebagai token SPL), ditampilkan 1:1 di sisi EVM sebagai **ERC20SPL wrapper** (mis. `wUSDC`). Synthetic tidak menyimpan apa pun saat tidak digunakan, jadi nilai mengalir *melalui* synthetic itu — setiap langkah ditandatangani dompet Solana:

1. **Provisi (sekali).** PDA otorisasi eksternal dari synthetic yang baru tidak ada sampai `create_pda` dijalankan — dan transfer di bawah ditandatangani oleh PDA itu. `submitRomeTxSolanaLane` memprovisinya secara otomatis pada penggunaan pertama (atau panggil `provisionSynthetic` untuk langkah "Activate" yang eksplisit; periksa dengan `isSyntheticProvisioned`). Dengan `submitRomeTxV1`, periksa `isSyntheticProvisioned` dan kirim `buildCreatePdaCall` melaluinya sekali.
2. **Tahap pendanaan (dompet → synthetic).** Pindahkan token dari ATA dompet ke milik synthetic — `ActivateAta` langkah, dibuat oleh `buildFundLeg`. Sekarang `wrapper.balanceOf(synthetic)` membaca saldo itu, sehingga synthetic membelanjakannya sebagai ERC-20 biasa (`transfer` / `transferFrom`) — **bukan** sebagai native `msg.value`, yang tidak dimilikinya.
3. **Panggilan (`DoTxUnsigned`).** Synthetic menjalankan transaksi EVM — misalnya `approve` lalu sebuah vault `deposit` yang menarik melalui `transferFrom`.
4. **Tahap sweep (synthetic → dompet).** Setelah withdraw / borrow / claim menempatkan token di synthetic, `buildSweepLeg` mendorongnya kembali ke ATA dompet milik pengguna (`HelperProgram.transfer_spl`), sehingga synthetic berakhir nol bersih.

Bagian berikut menjelaskan apa yang versi lama `submitRomeTxSolanaLane` dibuat di sisi klien. `submitRomeTxV1` membuat proxy menyusun transaksi v1 sebagai gantinya, tanpa penemuan akun, ComputeBudget, atau treasure wallet di kode Anda; lihat [endpoint external-V1](#the-external-v1-endpoints) di bawah.

## Bagaimana panggilan dibangun

`submitRomeTxSolanaLane` melakukan semua ini. Mekanismenya:

1. **Bangun transaksi EIP-1559 yang belum ditandatangani** dengan `dari` = alamat sintetis — tanpa tanda tangan secp256k1.
2. **Temukan akun** — panggil [`rome_emulateCallAccounts`](https://docs.rome.builders/id/referensi/json-rpc.md) dengan `dari`, `menjadi`, `data`, **dan `nilai`** (saat panggilan bersifat payable). Menyertakan `nilai` itu penting: proxy menirukan *sebenarnya* panggilan, sehingga setiap penulisan penyimpanan yang bergantung pada nilai — misalnya slot mapping baru — dialokasikan dan akun Solananya dikembalikan. Jika dihilangkan, akun itu tidak ada, dan transaksi gagal dengan *"instruction modified data of a read-only account."*
3. **Susun transaksi Solana:** dua **ComputeBudget** instruksi (EVM Rome membutuhkan batas CU yang dinaikkan ≈1,35 juta dan heap frame besar ≈250 KB — default Solana akan gagal) + **`DoTxUnsigned`** instruksi (RLP yang belum ditandatangani + akun yang ditemukan) + **treasure wallet** (eksekusi membayarnya biaya kecil; penemuan mengabaikannya, jadi SDK menambahkannya).
4. **Dompet menandatangani dan mengirim.** README **Dompet Solana menandatangani transaksi Solana (Ed25519) dan mengirimkannya ke Solana RPC — bukan ke proxy.** Runtime Solana memverifikasi tanda tangan; di on-chain, program menurunkan `msg.sender` dari penandatangan itu. Otoritasnya adalah tanda tangan Solana, bukan Ethereum. (Proxy hanya digunakan untuk emulasi/penemuan pada langkah 2.)

PDA milik pengguna (`["EXTERNAL_AUTHORITY", synthetic_address]`) memiliki akun token mereka dan menandatangani CPI SPL atas nama mereka — jadi pengguna Solana dapat supply, borrow, swap, dan LP sepenuhnya dari dompet Solana mereka.

## Endpoint external-V1

`submitRomeTxV1` adalah cara satu panggilan: ia meminta proxy untuk transaksi v1 yang telah disusun, memeriksanya, meminta dompet menandatanganinya dan mengirimkannya ke Solana RPC, lalu merelay melalui proxy ketika panggilan tidak muat. Proxy menyediakan jalur yang sama seperti metode RPC, jadi klien mana pun dapat menggunakannya tanpa SDK (daftar lengkap di [Dukungan JSON-RPC](https://docs.rome.builders/id/referensi/json-rpc.md)):

* `rome_composeUnsignedAtomicV1(rlp, pubkey, signature)` — satu transaksi Solana v1; dompet menandatanganinya dan aplikasi menyiarkannya ke Solana RPC. Ditolak ketika panggilan tidak muat dalam satu transaksi atomik.
* `rome_composeUnsignedIterativeV1(rlp, pubkey, signature)` — setiap tahap eksekusi (atomik jika muat, jika tidak tahap iteratif); dompet menandatangani masing-masing, `rome_submitSignedV1Plan` menyiarkannya. Batasan pada rencana yang panjang ada di [Panggilan yang direlay dan panggilan panjang](#relayed-calls-and-long-calls).
* `rome_relayUnsignedV1(rlp, pubkey, signature)` — satu tanda tangan dompet, payer proxy menjalankan tahap-tahapnya dan mengembalikan hash tx EVM; synthetic membayar gas Rome, jadi isi dananya sekali dengan `rome_composeExternalDepositV1`.

**Tanda tangan otorisasi.** `rlp` adalah body EIP-1559 mentah yang belum ditandatangani dengan 9 field. Dompet menandatangani, dengan kunci Ed25519-nya, baik 32 byte mentah `keccak256(0x02 ‖ rlp)` atau pesan yang terbaca

```
Otorisasi Rome\n0x<64 lowercase hex chars of that hash>
```

Keduanya diterima; bentuk yang terbaca adalah yang dirender dompet secara jelas di `signMessage` prompt. Program menghitung ulang hash dari body yang dieksekusinya dan mensyaratkan pesan yang ditandatangani persis salah satu dari dua bentuk itu, jadi tanda tangan atas satu body tidak pernah bisa mengotorisasi yang lain, dan nonce body mencegah replay.

## Panggilan yang direlay dan panggilan panjang

Beberapa panggilan tidak muat dalam satu transaksi Solana. Bagian ini membahas apa yang terjadi saat itu, dan batasan apa yang berlaku.

### Saat penyusun atomik menolak

`rome_composeUnsignedAtomicV1` menolak panggilan yang tidak muat dalam satu transaksi atomik. `submitRomeTxV1` lalu merelay panggilan melalui proxy dengan **sama** tanda tangan otorisasi, sehingga dompet tidak diminta lagi. Hasilnya memiliki `route: "relay"` dan tidak ada `tanda tangan Solana`. Setel `relayOnRefusal: false` agar penolakan dikembalikan sebagai error, atau panggil `relayV1` sendiri untuk merelay secara sengaja.

Tiga hal yang perlu diketahui tentang panggilan yang direlay:

* **Synthetic membayar gas.** Pada rute relay, proxy mengirim dan membayar transaksi Solana, dan panggilan dibayar menggunakan token gas native chain dari saldo synthetic. Saldo harus setidaknya `gasLimit × maxFeePerGas`. `fundSyntheticGas(deps, amountWei)` mengisinya dari akun token milik dompet sendiri untuk token gas chain tersebut (USDC pada Hadrian dan Rubicon); dompet menandatangani satu transaksi v1 biasa, dan membutuhkan sedikit SOL untuk biaya Solana. `amountWei` berada dalam wei 18 desimal milik chain dan harus kelipatan 10^12, atau proxy akan menolaknya. Tanpa SDK, `rome_composeExternalDepositV1` membangun transaksi yang sama.
* **Revert tidak melempar error.** Panggilan yang direlay dan revert di sisi EVM tetap diselesaikan secara normal, dengan `receipt.status === "0x0"`. Periksa `receipt?.status === "0x1"` sebelum menganggap panggilan selesai. `receipt` adalah `null` jika receipt tidak muncul tepat waktu.
* **`relayOnRefusal: false` adalah pilihan yang dibuat di SDK, bukan kunci.** Proxy sudah memegang tanda tangan otorisasi untuk payload itu dan dapat menjalankannya melalui salah satu rute, hingga `gasLimit × maxFeePerGas`.

```javascript
const res = await submitRomeTxV1(deps, { to, data, value });
if (res.route === "relay" && res.receipt?.status !== "0x1") {
  // panggilan yang direlay dan revert akan terselesaikan; tidak melempar error
}
```

### Panggilan panjang

Panggilan yang membutuhkan lebih dari satu transaksi berjalan sebagai sesi iteratif: program mengeksekusi sebanyak mungkin langkah EVM yang muat dalam setiap transaksi Solana dan menyimpan statusnya di antara transaksi. Ada dua cara menjalankannya dari dompet Solana:

* **Relay-kan.** `rome_relayUnsignedV1` membutuhkan satu tanda tangan dompet dan payer proxy mengirim setiap tahap. Synthetic membayar gas, seperti di atas.
* **Tandatangani tahap-tahapnya sendiri.** `rome_composeUnsignedIterativeV1` mengembalikan setiap tahap dengan slot tanda tangan kosong, dompet menandatangani masing-masing, dan `rome_submitSignedV1Plan` menyiarkannya secara berurutan. Setiap tahap adalah transaksi Solana terpisah untuk ditandatangani dompet, jadi dompet yang menandatangani satu transaksi dalam satu waktu akan meminta konfirmasi sekali per tahap, di samping tanda tangan otorisasi. Dompet membayar biaya Solana pada setiap tahap.

Batasnya:

| Batas                                                    | Nilai           | Sumbernya                                                                                                               |
| -------------------------------------------------------- | --------------- | ----------------------------------------------------------------------------------------------------------------------- |
| Transaksi dalam satu `rome_submitSignedV1Plan` panggilan | 64              | Proxy menolak rencana yang lebih panjang                                                                                |
| Tahap yang akan direncanakan penyusun iteratif           | 128             | Batas pada penyusun iteratif Rust Rome SDK, yang juga membatasi rencana `rome_composeUnsignedIterativeV1` mengembalikan |
| Iterasi dalam satu sesi                                  | 160             | Program Rome EVM; setelah melewatinya sesi berhenti dilanjutkan, melepaskan kunci akunnya, dan berakhir                 |
| Ukuran transaksi Solana dan akun                         | 4 KB, 64 alamat | Setiap tahap adalah transaksi Solana v1                                                                                 |

Kebanyakan panggilan nyata selesai dengan tahap jauh lebih sedikit daripada batas ini. Batas 64 transaksi pada rencana yang ditandatangani dompet adalah yang paling cepat akan Anda temui. Panggilan yang membutuhkan lebih banyak tahap daripada itu tidak dapat disiarkan melalui `rome_submitSignedV1Plan`.

Panggilan panjang tidak dapat membuat CPI legacy-track. Panggilan yang memutasi pada precompile legacy (`0xff…08`, `0xff…09` dan `0x42…16`) ditolak dalam sesi iteratif dengan `CpiProhibitedInIterativeTx`. Pembacaan state Solana dan precompile cached-track (`0xff…04`, `0xff…05`, `0xff…06`, `0xff…0b`) berfungsi. Panggilan yang membuat CPI legacy-track harus muat dalam satu transaksi atomik, apa pun jalur yang mengirimkannya. Lihat [Batasan](https://docs.rome.builders/id/konsep-inti/constraints.md) dan [Budget Komputasi](https://docs.rome.builders/id/konsep-inti/compute-budget.md).

## Implementasi referensi

* **Aerarium** — menggerakkan Compound v3 (supply / borrow) dari dompet Solana melalui `DoTxUnsigned`. Ini adalah referensi untuk jalur transaksi legacy yang lebih lama yang dijelaskan di atas, bukan untuk `submitRomeTxV1`.
* **Rome DEX** bukan contoh dari halaman ini: sisi Solananya adalah program Solana native yang ditandatangani langsung oleh dompet, dan sisi EVM-nya berbagi pool yang sama.

Aerarium tidak memerlukan dompet kedua — alamat sintetis menjadikan satu kunci Solana sebagai akun EVM kelas utama. Untuk pola v1, ikuti [Bangun aplikasi jalur ganda](https://docs.rome.builders/id/panduan-pengembang/dual-lane-app.md).

## Langkah Berikutnya

* [Panggil Solana dari EVM](https://docs.rome.builders/id/panduan-pengembang/call-solana-from-evm.md) — arah sebaliknya, melalui CPI
* [Interoperabilitas Token](https://docs.rome.builders/id/konsep-inti/token-interop.md) — bagaimana saldo dibagikan di seluruh EVM dan Solana


---

# 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/call-evm-from-solana.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.
