> 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/konsep-inti/how-solana-and-evm-meet.md).

# Cara Solana dan EVM bertemu di Rome

Bagaimana dompet Solana memanggil kontrak Solidity, alamat EVM memanggil program Solana, dan Rome menangani identitas, token, biaya, serta batas eksekusi.

Halaman ini menjelaskan bagaimana panggilan melintasi antara Solana dan EVM di Rome. Ini mencakup siapa yang menandatangani, di mana token berada, siapa yang membayar, dan aturan Solana mana yang memengaruhi kontrak Solidity.

Kecuali dinyatakan lain, angka dan transaksi di halaman ini berasal dari Hadrian (testnet) per 19 Oktober 2026.

## Apa itu alamat sintetis?

Alamat sintetis adalah identitas EVM dari sebuah public key Solana. Rome menghitungnya sebagai 20 byte terakhir dari `keccak256` dari public key: `keccak256(pubkey)[12..32]`. Pemetaan ini tetap. Disebut sintetis karena tidak ada siapa pun yang memegang kunci secp256k1 untuknya: MetaMask tidak dapat menandatanganinya, dan hanya kunci Solana yang dapat mengotorisasi panggilan darinya.

Pada panggilan kontrak tingkat teratas, keduanya `msg.sender` dan `tx.origin` adalah alamat sintetis. Rome menyimpan nonce EVM di bawah alamat tersebut. Kontrak tidak dapat membedakan identitas ini dari pengguna MetaMask melalui field-field tersebut.

## Bagaimana pengguna Solana memanggil kontrak Solidity?

Dompet mengotorisasi panggilan EIP-1559 yang belum ditandatangani melalui salah satu dari dua jalur. Jalur v1 adalah jalur saat ini. Jalur legacy adalah jalur yang lebih lama: dompet menandatangani dan membayar transaksi Solana yang membawa `DoTxUnsigned`, dan program Rome EVM menurunkan alamat sintetis dari penandatangan Solana itu.

Pada jalur v1, dompet menandatangani pesan yang dapat dibaca berisi `Otorisasi Rome`, sebuah baris baru, dan hash panggilan sebagai `0x` diikuti oleh 64 karakter heksadesimal huruf kecil. Transaksi membawa tanda tangan ini dalam instruksi verifikasi Ed25519 pada indeks 0. Program Rome EVM menurunkan alamat sintetis dari kunci yang mengotorisasi panggilan.

Proksi Rome menyusun transaksi v1. Dompet kemudian menandatanganinya dan mengirimkannya ke Solana. Pada rute relay, Proksi Rome mengirim transaksi dan membayar SOL, dan alamat sintetis membayar gas dari saldo native-nya dalam token gas rantai (USDC di Hadrian dan Rubicon).

Saat dompet membayar langsung, jalur v1 biayanya 15.000 lamport: biaya tanda tangan 5.000 lamport, 5.000 lamport untuk tanda tangan verifikasi Ed25519, dan biaya treasury 5.000 lamport. Legacy `DoTxUnsigned` jalur yang lebih lama tidak memiliki instruksi Ed25519 dan biayanya 10.000 lamport. Kedua rute juga membayar sewa untuk akun yang dibuat. Tidak ada jalur langsung yang mengenakan gas EVM. Sebuah transaksi jalur legacy di Hadrian menelan biaya 10.000 lamport bagi dompet dan melaporkan `gasUsed = 0` dan `effectiveGasPrice = 0`.

Milik SDK `submitRomeTxV1` mengikuti langkah-langkah berikut:

1. Baca nonce alamat sintetis dengan `eth_getTransactionCount`, perkirakan gas, dan bangun panggilan yang belum ditandatangani.
2. Minta dompet menandatangani `Otorisasi Rome` pesan yang dapat dibaca.
3. Minta transaksi dari `rome_composeUnsignedAtomicV1`.
4. Verifikasi payer yang dikembalikan, byte panggilan, otorisasi Ed25519, program yang diizinkan, dan tidak adanya biaya prioritas.
5. Minta dompet menandatangani transaksi v1, kirimkan ke Solana, dan polling Proksi Rome untuk tanda terima EVM.
6. Jika panggilan memerlukan eksekusi iteratif, teruskan melalui `rome_relayUnsignedV1` menggunakan tanda tangan otorisasi yang sama.

Gunakan `fundSyntheticGas` untuk mendanai saldo native yang diperlukan untuk relay atau `msg.value`. Ini menyetorkan token gas dari akun token dompet dan mengkredit saldo native alamat sintetis. Saldo native menggunakan 18 desimal.

Untuk menggunakan token dalam kontrak, SDK mendanai alamat sintetis, memanggil kontrak, dan mengembalikan token yang tersisa. `buildFundLeg` menggunakan `ActivateAta` untuk memindahkan token dari dompet ke akun token alamat sintetis. Panggilan Solidity menggunakan token tersebut melalui sebuah wrapper. `buildSweepLeg` menggunakan `transfer_spl` untuk mengirim token yang tersisa kembali ke dompet.

Dompet harus mendukung penandatanganan transaksi Solana v1. Solflare mendukung ini di Solana devnet; Phantom belum. Setiap panggilan memeriksa dan menambah nonce EVM di bawah alamat sintetis untuk mencegah replay.

Lihat [Panggil EVM dari Solana](https://docs.rome.builders/id/panduan-pengembang/call-evm-from-solana.md), [Bangun aplikasi jalur ganda](https://docs.rome.builders/id/panduan-pengembang/dual-lane-app.md), dan [Rome SDK](https://docs.rome.builders/id/produk/rome-sdk.md).

## Bagaimana pengguna EVM, atau sebuah kontrak, memanggil program Solana?

Setiap alamat EVM memiliki alamat yang diturunkan program Solana yang memiliki akun tokennya dan dapat menandatangani panggilan ke program Solana. Ini adalah PDA otoritas eksternalnya. Program Rome EVM menurunkannya dari seed `EXTERNAL_AUTHORITY` diikuti oleh alamat EVM. Seed tersebut tidak memuat chain ID, jadi chain yang di-host oleh program Rome EVM yang sama berbagi otoritas ini.

Pengguna atau kontrak memanggil precompile CPI di `0xFF…08` dengan ID program target, daftar akun, dan byte instruksi. CPI berarti cross-program invocation. Precompile memanggil program Solana dalam transaksi Solana yang sama.

`invoke` menandatangani untuk PDA otoritas eksternal pemanggil ketika daftar akun menandainya sebagai signer. `invoke_signed` juga mendukung PDA yang diturunkan dengan salt. Setiap PDA yang diberi salt harus muncul dalam daftar akun sebagai signer.

Metode `account_info`, `account_data_at`, `account_u64_at`, `account_lamports`, dan `pdas_batch_derive` adalah pembantu hanya-baca. Mereka tidak memanggil program Solana.

Precompile menolak panggilan yang menargetkan program Rome EVM itu sendiri. Ia juga menolak daftar akun yang berisi ID program Rome EVM. Sebuah CPI tidak boleh menamai fee payer Solana, kecuali di dalam instruksi System biasa `Transfer` .

Sebuah swap RomeDexRouter 2.0.0 di Hadrian mengikuti langkah-langkah berikut:

1. Router memanggil `HelperProgram.create_ata` untuk memastikan akun token output milik pengguna ada.
2. Ia menurunkan akun token input dan output milik pengguna dan menandai PDA otoritas eksternalnya sendiri sebagai signer.
3. Ia memanggil `CPI.invoke` dengan program swap Solana, daftar akun, dan byte instruksi swap.
4. SPL Token memindahkan token dari akun pengguna ke dalam pool dan mengembalikan token output ke akun pengguna yang lain. PDA router menandatangani sebagai delegasi SPL milik pengguna. Router tidak menyimpan token apa pun.
5. Router memeriksa jumlah yang diterima dengan `CPI.account_u64_at(dstAta, 64)`.
6. Tanda terima melaporkan gas 10.001: `5,000 + 5,000 + 1 = 10,001` lamport biaya Solana. Biaya-biaya itu adalah biaya tanda tangan, biaya tol treasury, dan biaya prioritas. Proksi Rome membayar SOL, dan pengguna membayar gas dalam USDC.

Lihat [Panggil Solana dari EVM](https://docs.rome.builders/id/panduan-pengembang/call-solana-from-evm.md), [Integrasikan program Solana](https://docs.rome.builders/id/panduan-pengembang/integrate-solana-program.md), dan [Referensi precompile](https://docs.rome.builders/id/referensi/precompiles.md).

## Siapa yang menandatangani ketika sebuah kontrak memanggil program Solana?

Rome menandatangani dengan PDA otoritas eksternal dari pemanggil langsung precompile. Karena itu sebuah kontrak menandatangani sebagai dirinya sendiri. Hanya panggilan yang dikirim langsung ke precompile oleh EVM milik pengguna sendiri atau alamat sintetis yang menandatangani dengan PDA milik pengguna.

Untuk membiarkan router atau adapter memindahkan token pengguna, pengguna memanggil `approve_spl(spender, amount, mint)`. Ini menetapkan PDA otoritas eksternal kontrak sebagai delegasi SPL dari akun token pengguna. Ini adalah versi Rome dari ERC-20 `approve`.

Di bawah `DELEGATECALL`, precompile menolak PDA otoritas eksternal mentah sebagai signer. Otoritas yang diberi salt menyertakan kontrak yang berjalan dalam derivasi mereka di bawah `DELEGATECALL`.

## Setiap alamat memiliki PDA, jadi mengapa wrapper tidak memisahkan likuiditas?

Bagi dompet, wrapper adalah tampilan dari token SPL-nya. `balanceOf` membaca akun token nyata dompet di Solana. `totalSupply` membaca suplai mint.

Tiga wrapper wUSDC di Hadrian (testnet), 9.0.0 (`0xbce339ba…`), 8.0.0 (`0xae287c43…`), dan Mei 2026 (`0x9fd4d58d…`), menunjukkan saldo yang sama untuk setiap dompet. Ketiganya mengembalikan suplai mint dari `totalSupply`.

Pemegang native Solana dan pemegang EVM menggunakan akun dari mint yang sama. Dompet Solana memiliki akun tokennya secara langsung. PDA otoritas eksternal alamat EVM memiliki akun tokennya. `ActivateAta` dan `transfer_spl` memindahkan token di antara akun-akun ini. Kedua pemegang memperdagangkan melawan akun pool dan cadangan Solana yang sama.

Saldo yang dipegang kontrak memerlukan perlakuan berbeda. Token yang dikirim ke kontrak berada di akun escrow wrapper. Wrapper melacak saldo kontrak. Sebuah pasangan bergaya UniswapV2 di Hadrian memiliki saldo 9.600.566 melalui wrapper 9.0.0 dan 0 melalui wrapper 8.0.0. Gunakan wrapper kanonik dari registry untuk pool, vault, dan pasar pinjaman.

Setiap akun token memiliki satu slot delegasi SPL. Memberikan izin kepada router atau bridge menggantikan pemberian wrapper. Setelah rotasi wrapper, pengguna harus memberikan izin kepada wrapper baru dengan `approve_spl`. Berikan izin lagi kepada wrapper jika delegate lain telah menggantikannya.

Setiap factory mengizinkan satu wrapper per mint. Wrapper dari factory yang berbeda masih dapat membaca akun token dompet yang sama. Lihat [Interoperabilitas Token](https://docs.rome.builders/id/konsep-inti/token-interop.md).

## Bagaimana Rome mengatasi semantik Solana dan EVM yang berbeda?

| Perbedaan                                    | Apa yang dilakukan Rome                                                                                                                                                                                          |
| -------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Akun dideklarasikan di awal vs akses dinamis | Men-emulasi panggilan terlebih dahulu dan menggunakan akun yang disentuh sebagai daftar akun instruksi Solana.                                                                                                   |
| Batas komputasi dan ukuran satu transaksi    | Menggunakan eksekusi atomic (VmAt) ketika panggilan muat. Akun holder membawa payload yang lebih besar, dan eksekusi iteratif (VmIt) membagi pekerjaan ke beberapa transaksi.                                    |
| Kunci akun di seluruh leg                    | Menyegarkan kunci pada akun saldo dan storage setiap leg. Kunci bertahan 3 detik, atau 4 detik ketika transaksi menamai lebih dari 28 akun. Penulisan atomic ke akun yang terkunci gagal dengan `AccountLocked`. |
| Token gas dan biaya                          | Menghitung biaya Solana dalam lamport dan mengonversinya menjadi tagihan token gas dengan harga gas transaksi. Panggilan yang dibayar dompet membayar SOL secara langsung.                                       |
| Blok dan slot                                | Menggunakan slot Solana untuk `block.number` dan clock Solana untuk `block.timestamp`.                                                                                                                           |
| Finalitas                                    | Mengonfirmasi di Solana `terkonfirmasi`. Hercules memeriksa ulang blok yang diindeks pada `terfinalisasi`.                                                                                                       |
| Tanda tangan                                 | Memverifikasi tanda tangan EVM dengan `secp256k1_recover`. Otorisasi Solana menggunakan Ed25519. Keduanya menghasilkan pengirim EVM 20 byte.                                                                     |
| Sewa                                         | Mendanai pembuatan dan pertumbuhan akun Solana melalui fee payer. Membebankan pengirim EVM melalui gas ketika ada penerima biaya.                                                                                |
| Desimal dan lebar integer                    | Menggunakan 18 desimal untuk saldo gas native. Konversi ke unit SPL harus tepat dan muat `u64`. Wrapper menggunakan desimal mint dan menolak jumlah di atas `uint64` maksimum.                                   |
| Reentrancy dan pengukuran gas                | Tidak memiliki meter gas opcode EVM. Stipend 2.300 gas tidak membatasi panggilan, jadi kontrak memerlukan pengaman reentrancy eksplisit.                                                                         |
| Kedalaman CPI                                | Menjalankan program Rome EVM pada depth 1 dan target CPI pada depth 2. Solana mengizinkan nesting hingga depth 5.                                                                                                |
| Atomicitas efek samping Solana               | Menjalankan CPI legacy segera dan membatalkan seluruh transaksi jika frame-nya kemudian revert. Panggilan yang di-cache dicatat selama eksekusi dan dikirim saat commit. Mereka dibuang ketika frame-nya revert. |
| `SELFDESTRUCT` dan opcode yang tidak dikenal | Menonaktifkan `SELFDESTRUCT`. Itu dan opcode lain yang belum diimplementasikan membatalkan seluruh transaksi dengan `IncompatibleVersionEVM`.                                                                    |
| Nonce                                        | Menyimpan dan memeriksa nonce EVM per pengirim di balance PDA-nya. Estimasi gas melewati pemeriksaan nonce.                                                                                                      |

### Akun

Emulator menjalankan panggilan terhadap akun Solana sebelum pengiriman. Ia mencatat setiap akun yang disentuh dan apakah akun itu harus dapat ditulis. Himpunan itu menjadi daftar akun instruksi Solana. Akun yang diperlukan yang hilang dari daftar akan membuat panggilan on-chain gagal.

Cabang yang bergantung pada waktu dapat berubah antara emulasi dan eksekusi. Jika perubahan itu menyebabkan panggilan melampaui anggaran komputasinya, Proksi Rome menyusun ulang sekali pada blok berikutnya.

### Ukuran transaksi dan komputasi

Eksekusi atomic (VmAt) muat dalam satu transaksi Solana, dengan sekitar 1,4 juta unit komputasi dan paling banyak 64 akun. Panggilan juga harus muat dalam batas heap dan jejak instruksi.

Transaksi Solana v1 menampung paling banyak 4.096 byte. Untuk payload transaksi EVM yang lebih besar, Proksi Rome menulis potongan 3.600 byte ke sebuah `TxHolder` akun holder dengan ukuran maksimum 80.000 byte. Biaya tanda tangan setiap potongan dibebankan sebagai gas.

Eksekusi iteratif (VmIt) menyimpan state VM di sebuah `StateHolder` akun holder di antara leg. Sebuah sesi mengizinkan paling banyak 160 iterasi. Planner menghasilkan paling banyak 128 leg, dengan batas opcode setidaknya 500 per leg. CPI legacy memerlukan eksekusi atomic. Panggilan yang di-cache mendukung eksekusi iteratif.

### Gas dan sewa

Satu unit gas Rome merepresentasikan satu lamport biaya Solana. Biaya mencakup biaya tanda tangan, biaya tol treasury 5.000 lamport, biaya prioritas, dan sewa setelah dikurangi pengembalian. `eth_gasPrice` melaporkan wei token gas per lamport. Ketika ada penerima biaya, Rome membebankan pengirim `lamport × tx.gasPrice` dari saldo native.

Fee payer Solana mendanai sewa ketika Rome membuat atau memperbesar akun saldo dan storage. Biaya itu dibebankan kepada pengirim EVM sebagai gas ketika ada penerima biaya. Karena itu transfer pertama ke alamat yang belum pernah dipakai menelan biaya sekitar 1 juta gas. `eth_estimateGas` tidak pernah kurang dari 21.000.

### Blok, waktu, dan finalitas

`block.number` adalah slot Solana. `block.timestamp` adalah stempel waktu Unix dari clock Solana. Rome menangkap keduanya ketika ia membuat state VM dan menyimpannya selama leg iteratif.

`blockhash(n)` adalah `keccak256(bytes32(n))` dalam 256 slot terakhir dan nol di luar itu. Tidak memiliki entropi. `block.coinbase` adalah penerima biaya, atau nol ketika tidak ada.

SDK menunggu `terkonfirmasi`. Hercules memeriksa ulang setiap blok yang diindeks pada `terfinalisasi` dan memuat ulang jika blockhash berubah.

### Revert, reentrancy, dan CPI

CPI legacy dieksekusi segera. Jika sebuah frame yang membuat CPI kemudian revert, Rome membatalkan seluruh transaksi. Solidity `try/catch` tidak dapat menyerap revert itu. Panggilan yang di-cache dicatat selama eksekusi dan dikirim saat commit. Sebuah frame yang revert membuang panggilan yang dicatatnya. Setelah sebuah transaksi menulis melalui satu jalur, penulisan melalui jalur lain ditolak. Setelah penulisan yang di-cache, helper baca legacy juga ditolak: pembacaan akun CpiProgram dan `pdas_batch_derive`, dan `allowance_of`, `). Setiap metode` dan `mint_info`.

Rome tidak memiliki meter gas opcode EVM. `gasleft()` mengembalikan batas gas, atau `U256::MAX` ketika tidak ada penerima biaya. Gas yang diteruskan ke `CALL` atau `CREATE` tidak ditegakkan. Gunakan pengaman reentrancy eksplisit alih-alih mengandalkan stipend 2.300 gas.

Kedalaman stack instruksi Solana adalah 5. Program Rome EVM berjalan pada depth 1, jadi targetnya berjalan pada depth 2 dan dapat nested hingga depth 5. Swap Hadrian menjalankan program swap pada depth 2 dan SPL Token pada depth 3. Perubahan Solana yang tertunda (SIMD-0268) akan menaikkan depth dari 5 ke 9. Itu belum aktif di devnet atau mainnet per 19 Oktober 2026. CPI kembali ke program Rome EVM ditolak.

Lihat [Model Eksekusi](https://docs.rome.builders/id/konsep-inti/execution-model.md), [Batasan](https://docs.rome.builders/id/konsep-inti/constraints.md), [Budget Komputasi](https://docs.rome.builders/id/konsep-inti/compute-budget.md), dan [Batasan yang Diketahui](https://docs.rome.builders/id/keamanan/known-limitations.md).

## Pertanyaan umum

### Apakah MetaMask dan Phantom adalah akun yang sama di Rome?

Tidak. Kunci MetaMask dan kunci Solana menghasilkan dua alamat EVM yang berbeda, dan Rome tidak pernah menautkannya. Kunci MetaMask memberikan alamat Ethereum biasanya. Kunci Solana memberikan [alamat sintetis](#what-is-a-synthetic-address), `keccak256(pubkey)[12..32]`: `2PMoUv…` menjadi `0x45b64dae…`. Pada panggilan tingkat teratas `msg.sender` dan `tx.origin` adalah alamat penandatangan, termasuk alamat sintetis pada rute relay.

Kunci yang berbeda menyebabkan pemisahan itu: dua kunci MetaMask juga merupakan dua akun. Kurva itu hanya berarti tidak ada kunci yang dapat menandatangani alamat kunci lainnya. Tidak ada fitur penautan. `ActivateAta` hanya mendanai alamat sintetis milik penandatangan sendiri. Sebuah `Setoran` instruction dapat mengkredit alamat EVM mana pun dengan gas native, dibayar dari akun token gas milik penandatangan. Proksi hanya membangun setoran ke alamat sintetis milik penandatangan sendiri. Tidak satu pun dari ini membuat dua kunci menjadi satu akun. Sebuah pool melihat dua pemegang, tetapi keduanya berdagang melawan cadangan yang sama; lihat [Apakah likuiditas dibagi](#is-liquidity-shared-between-solana-and-evm-users-or-split).

### Bagaimana akun Solana dan EVM dipetakan?

Rome memetakan setiap kunci Solana ke satu [alamat EVM sintetis](#what-is-a-synthetic-address). Setiap alamat EVM memiliki balance PDA per chain untuk nonce-nya, saldo gas native, dan kode. PDA otoritas eksternalnya memiliki akun tokennya dan menandatangani CPI. Chain pada satu program Rome berbagi otoritas itu.

Akun-akun ini dibaca di Hadrian (testnet):

| Account                        | Alamat MetaMask `0x35153297…a266`                                              | wallet Solana `2PMoUv…`, alamat sintetis `0x45b64dae…127d`                                       |
| ------------------------------ | ------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------ |
| Akun Solana milik dompet       | Tidak ada dari kunci MetaMask                                                  | Akun sistem SOL `2PMoUv…`; akun wSOL milik sendiri `T8gKAAg9pz5eLcerH1Nh52Hn97m1nnGyhY9z4bwtyir` |
| Balance PDA                    | `8zuWEakFcuRRJ5Gju44u6Ptyk22gbNUMbsD8VLEQVS4c`                                 | `EeRr14Feh3Ft7YuyacAVJQd3YSYsKAPTqdMEN43gtBSd`                                                   |
| PDA otoritas eksternal         | `EZSTURZAg3GMqiWN3NBCvMLjEeLSxGH9PGooW6dAG8Kb`                                 | `FMSHMpgdA9rEhzGLSvFniAHT7BmGjJweQqxPiGJJntC1`                                                   |
| Akun token yang digunakan Rome | USDC `8wAzpmag4oL4c6ku6wqQBjxWXYLPoVsek6SyAvrYaxim`, dimiliki oleh `EZSTURZA…` | wSOL `3pPjxR4ho3mVb5AMauVCjqTBUVS2Rif5JAnk9DFukPg2`, dimiliki oleh `FMSHMpgd…`                   |

Token pengguna Solana berada di dua tempat: akun milik sendiri milik dompet dan akun yang dimiliki PDA milik alamat sintetis yang dibaca wrapper. SDK memindahkan token masuk dengan `ActivateAta` dan kembali dengan `transfer_spl`, seperti dijelaskan dalam [Bagaimana pengguna Solana memanggil kontrak Solidity?](#how-does-a-solana-user-call-a-solidity-contract). Sweep `0x95b2502d…` mengembalikan 0,016587 wSOL ke dompet. Alamat MetaMask yang sama memiliki akun token yang berbeda di Hadrian (testnet) dan Rubicon (mainnet) karena mereka berjalan pada program Rome, mint, dan cluster Solana yang berbeda.

### Siapa yang membayar biaya mana ketika pengguna EVM dan pengguna Solana memanggil kontrak yang sama? Apakah satu jalur biaya atau dua?

Rome menggunakan satu model biaya dengan dua cara untuk menyelesaikannya. Satu unit gas Rome adalah satu lamport biaya Solana: biaya tanda tangan, biaya tol treasury 5.000 lamport, biaya prioritas apa pun, dan sewa setelah dikurangi pengembalian.

Pada jalur Solana yang ditandatangani dompet, fee payer Solana membayar biaya itu dalam SOL tanpa biaya gas EVM. Pada panggilan MetaMask dan relay, Proksi Rome membayar SOL di muka. Program membebankan pengirim EVM `lamport × harga gas transaksi` dari saldo native-nya kepada penerima biaya proksi. Token gas adalah USDC di Hadrian (testnet) dan Rubicon (mainnet).

Kedua `suplai` panggilan (USDC dari MetaMask, wSOL dari kunci Solana) menggunakan AavePool 2.0.0 (`0x81e7e7e4…`) di Hadrian (testnet). Masing-masing membuat dua akun.

| Biaya atau penerima                        | Kunci EVM (MetaMask)                                                                  | Kunci Solana (ditandatangani dompet v1)                                                                         |
| ------------------------------------------ | ------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- |
| Tx EVM                                     | `0xc7e6ee8d…`, dari `0x35153297…`                                                     | `0xb0712551…`, dari `0x45b64dae…`                                                                               |
| Siapa yang menandatangani dan membayar SOL | pembayar proksi Rome `GNX1fLhb…`                                                      | Dompet pengguna `2PMoUv…`                                                                                       |
| SOL yang dibelanjakan                      | 2.102.962 lamport = 5.000 tanda tangan + 2 prioritas + 5.000 tol + 2 × 1.046.480 sewa | 2.107.960 lamport = 10.000 biaya tanda tangan (transaksi + verifikasi Ed25519) + 5.000 tol + 2 × 1.046.480 sewa |
| Gas EVM yang dibebankan                    | Pengirim membayar 2.102.962 gas × 13.004.742.450 wei = 0,0273485 USDC                 | `gasUsed` 0, `gasPrice` 0                                                                                       |
| Gas dibayar ke                             | Penerima biaya proksi `0x179d6112…`                                                   | Tidak ada; tidak ada `gasRecipient`                                                                             |
| Penerima tol treasury                      | `7WDWCxvk…`, akun treasury #31                                                        | `3F9eKFpr…`, akun treasury #6                                                                                   |

* **Jalur legacy (jalur yang lebih lama):** `0x350b8e36…` biayanya 1.056.480 lamport bagi dompet: biaya tanda tangan 5.000 + tol 5.000 + sewa 1.046.480, untuk satu akun yang dibuat. Gas EVM adalah 0.
* **Relay:** Aave `pinjam` transaksi `0x18d65e8c…` menggunakan 16 leg Solana. Alamat sintetis membayar 2.177.992 gas = 0,0226594 USDC, menggunakan jalur biaya yang sama seperti pengguna MetaMask. Biaya gas mencakup `16 × 5.002 + 5.000 tol + 2 × 1.046.480 sewa = 2.177.992`. Setiap leg relay juga membawa tanda tangan verifikasi Ed25519. Proksi membayar 5.000 lamport itu per leg dan tidak menagihkannya, jadi panggilan ini menelan biaya 16 × 10.002 lamport dalam biaya bagi proksi.
* **Treasury bersama:** Setiap rute membayar tol 5.000 lamport ke salah satu dari 64 akun treasury rantai itu. Dua panggilan suplai di atas membayar tol mereka ke akun #31 dan #6 dari set yang sama.
* **Harga yang dideklarasikan:** Rome membebankan harga yang dideklarasikan transaksi, `maxFeePerGas` untuk EIP-1559. Tidak ada base fee atau pengembalian selisih. Transaksi kunci EVM langsung menyatakan dari 1× hingga 2× `eth_gasPrice` kutipan 10.403.793.960 wei per lamport, dan masing-masing membayar persis apa yang dideklarasikannya. Gas dihargai per lamport biaya Solana, bukan per opcode EVM.
* **Biaya yang ditandatangani dompet:** Jalur SDK tidak menetapkan biaya prioritas, jadi pengguna tidak membayar biaya komputasi. Mereka membayar biaya tanda tangan, tol, dan sewa dalam SOL. Jalur v1 membayar dua tanda tangan: tanda tangan transaksi dan verifikasi Ed25519.

Lihat [alur panggilan Solana](#how-does-a-solana-user-call-a-solidity-contract) dan [panduan dua jalur](https://docs.rome.builders/id/panduan-pengembang/dual-lane-app.md) untuk rute dompet dan relay.

### Apakah likuiditas dibagi antara pengguna Solana dan EVM, atau dipisahkan?

Dibagi. Kedua jalur memperdagangkan melawan akun mint yang sama. Di Aave di Hadrian (testnet), kunci Solana dan kunci EVM jalur MetaMask keduanya memasok dan meminjam melalui akun escrow wSOL `3yY2FHSG…` (MetaMask: suplai `0xaf460f52…`, pinjam `0x89dbf0b6…`; kunci Solana: suplai `0xb0712551…`, pinjam `0x18d65e8c…`). Ini adalah escrow wrapper wSOL, yang menyimpan cadangan awSOL.

Di rome-dex, dompet Solana menyetorkan likuiditas langsung ke vault yang sama yang digunakan oleh swap router EVM `0xa7f77530…`. Transaksi setoran Solana `2xFSzza7…` tidak berisi program Rome. Hanya saldo yang dipegang oleh kontrak bergantung pada wrapper, jadi gunakan wrapper kanonik dari registry untuk pool dan vault (lihat bagian [PDA dan wrapper](#every-address-has-a-pda-so-why-dont-the-wrappers-split-liquidity)). Jangan ukur likuiditas wSOL dengan `totalSupply`: itu membaca 0 karena mint SOL native melaporkan suplai 0.

### Bagaimana saya memindahkan token dan saldo gas antara alamat MetaMask dan dompet Solana?

* **Dompet Solana ke alamat MetaMask, token:** Buat akun token jika belum ada (create idempotent dari program Associated Token, dengan PDA otoritas eksternal alamat sebagai owner), lalu kirim transfer SPL biasa ke sana. `HelperProgram.ata(address, mint)` mengembalikan alamatnya. Transaksi `2tBhefMJ…` melakukan keduanya dan memindahkan 20 USDC.
* **Dompet Solana ke alamat MetaMask, gas:** Danai alamat sintetis Anda sendiri dengan `fundSyntheticGas`. Lalu kirim transfer nilai native dari alamat sintetis ke alamat MetaMask.
* **Alamat MetaMask ke dompet Solana, token:** Panggil `transfer_spl(bytes32,uint64,bytes32)` di precompile Helper secara langsung dari alamat EVM, dengan akun token penerima yang sudah ada. Atau, panggil `RomeBridgeWithdraw.bridgeOutToSolana`, yang memerlukan grant dan akun token penerima yang sudah ada.
* **Alamat MetaMask ke dompet Solana, gas:** Panggil payable precompile Withdraw `withdrawal(bytes32 to)` dengan jumlah sebagai `msg.value`. Dompet menerimanya sebagai USDC di akun token USDC-nya, yang dibuat Rome jika perlu. `msg.value` harus merupakan kelipatan 10^12 wei. Penerima harus merupakan akun dompet yang sudah ada.

`transfer_spl_to_signer` hanya mencapai dompet Anda sendiri pada jalur Solana yang ditandatangani dompet. Dari MetaMask atau melalui relay, penandatangan adalah proxy payer milik Rome, jadi panggilan gagal atau token masuk ke Rome. Lihat [Referensi precompile](https://docs.rome.builders/id/referensi/precompiles.md).

Satu identitas hanya dapat membelanjakan token milik yang lain melalui pemberian yang eksplisit, `approve_spl` atau ERC-20 `approve`, seperti pada alamat lainnya. Setiap akun token memiliki satu slot delegate. Lihat [Interoperabilitas Token](https://docs.rome.builders/id/konsep-inti/token-interop.md#one-time-grant-per-wallet).

### Apakah alamat saya sama di setiap chain Rome?

Alamat EVM sama di setiap chain karena berasal dari kunci. Nonce dan saldo gas-nya disimpan per chain. Akun tokennya dibagikan oleh chain pada program Rome yang sama dan berbeda antar program dan klaster. Lihat [pemetaan akun](#how-do-solana-and-evm-accounts-map).

### Dompet mana yang berfungsi pada jalur Solana? Apakah Phantom berfungsi?

Belum pada jalur Solana. Jalur Solana menggunakan transaksi Solana v1, dan dompet harus menandatanganinya. Di devnet, Solflare bisa; Phantom belum.

### Apakah explorer menampilkan jalur yang digunakan suatu transaksi?

Sebagian.  [Via explorer](https://docs.rome.builders/id/aplikasi-di-rome/via.md) menunjukkan apakah kunci EVM atau kunci Solana mengirim panggilan: `asal` adalah `ecdsa` atau `solana_unsigned`, dan panggilan dengan kunci Solana membawa `solanaSigner`. Ini tidak membedakan rute legacy, v1, dan relay; ketiganya menampilkan `solana_unsigned`. Panggilan relay adalah yang memiliki nilai bukan nol `gasUsed` dan sebuah `gasRecipient`. Isi ulang gas yang dibuat dengan `fundSyntheticGas` ditampilkan sebagai `ecdsa` tanpa `solanaSigner`.

## Ke mana selanjutnya

* [Arsitektur](https://docs.rome.builders/id/memulai-1/architecture.md)
* [Model Eksekusi](https://docs.rome.builders/id/konsep-inti/execution-model.md)
* [Interoperabilitas Token](https://docs.rome.builders/id/konsep-inti/token-interop.md)
* [Panggil Solana dari EVM](https://docs.rome.builders/id/panduan-pengembang/call-solana-from-evm.md)
* [Panggil EVM dari Solana](https://docs.rome.builders/id/panduan-pengembang/call-evm-from-solana.md)
* [Bangun aplikasi jalur ganda](https://docs.rome.builders/id/panduan-pengembang/dual-lane-app.md)
* [Integrasikan program Solana](https://docs.rome.builders/id/panduan-pengembang/integrate-solana-program.md)
* [Referensi precompile](https://docs.rome.builders/id/referensi/precompiles.md)
* [referensi JSON-RPC](https://docs.rome.builders/id/referensi/json-rpc.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/konsep-inti/how-solana-and-evm-meet.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.
