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

# Buka kontrak Anda untuk pengguna Solana

Sebarkan kontrak Solidity di Rome (testnet Hadrian, mainnet Rubicon) dan buka untuk dompet Solana — apa yang dibutuhkan kontrak, bagaimana pengguna dompet Solana memanggilnya, alamat per jaringan, dan sebuah ch peluncuran

Satu deployment, dua jenis pengguna. Sebuah kontrak di Rome diakses oleh pengguna MetaMask dengan kunci EVM mereka dan oleh pengguna wallet Solana (misalnya Solflare) dengan kunci Solana mereka — alamat yang sama, state yang sama. Halaman ini adalah jalur end-to-end: deploy, buat kontrak siap untuk Solana, sambungkan jalur Solana di aplikasi Anda, dan rilis di mainnet.

## 1. Deploy di jaringan yang Anda inginkan

Rantai Rome adalah target EVM standar: Hardhat, Foundry, viem, dan ethers bekerja tanpa perubahan (panduan lengkap di [Deploy Solidity Contracts](/id/panduan-pengembang/deploy-solidity.md)).

| Jaringan                                         | ID rantai | RPC                                         | Penjelajah                                                                            | Token gas | Cara mendapatkan gas                                                                                                                                                  |
| ------------------------------------------------ | --------- | ------------------------------------------- | ------------------------------------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [**Rubicon**](/id/jaringan/rubicon.md) (mainnet) | `7531`    | `https://rubicon.mainnet.romeprotocol.xyz/` | [via-rubicon.mainnet.romeprotocol.xyz](https://via-rubicon.mainnet.romeprotocol.xyz/) | USDC      | Jembatani USDC dari Ethereum (CCTP) atau dari Solana dengan [Rome Bridge](https://bridge-api.mainnet.romeprotocol.xyz/); dan akan masuk sebagai gas                   |
| **Hadrian** (testnet)                            | `200010`  | `https://hadrian.testnet.romeprotocol.xyz/` | [via-hadrian.testnet.romeprotocol.xyz](https://via-hadrian.testnet.romeprotocol.xyz/) | USDC uji  | Jembatani USDC uji dari testnet ([Faucet](/id/sumber-daya/faucets.md)) atau bungkus dari wallet devnet Solana di [Aplikasi Rome](https://app.devnet.romeprotocol.xyz) |

Gas adalah USDC dengan 18 desimal di sisi EVM; tidak ada faucet Rome di jaringan mana pun. Operasi tulis membutuhkan lebih banyak gas daripada yang dibayangkan intuisi Ethereum, karena sebagian besar biayanya adalah membuat akun Solana: penerima yang belum pernah dipakai, akun token baru, kontrak yang di-deploy. Gunakan `eth_estimateGas`yang memang dilakukan tooling standar, dan jangan pernah hardcode 21.000. Diukur pada Hadrian, deploy kontrak 10 byte diperkirakan dan menggunakan 1.147.921 gas, dan transfer native ke alamat yang belum pernah dipakai 1.086.961, dibandingkan 21.000 untuk transfer ke alamat yang sudah ada. Rome menagih gas yang benar-benar dipakai, dan pada pengukuran ini tidak pernah melebihi perkiraan. Danai beberapa USDC sebelum deploy pertama. Setelah itu verifikasi source di explorer ([Verifikasi Kontrak](/id/panduan-pengembang/verify-contracts.md); verifier mainnet adalah `https://verify.mainnet.romeprotocol.xyz`).

Kembangkan di Hadrian, lalu deploy ulang artifact yang sama ke Rubicon dengan chain id dan alamat pembungkus mainnet ditukar; tidak ada yang berubah di kontrak antara jaringan. Rubicon belum ada di registry publik, `create-rome-app` atau `rome-cli` jadi alat yang membaca nilai chain dari sana tidak dapat menargetkannya; isi nilainya secara manual dari [Rubicon](/id/jaringan/rubicon.md). Gas di Rubicon adalah USDC sungguhan dengan harga gas sekitar sepuluh kali Hadrian, jadi deployment di sana membutuhkan uang sungguhan.

## 2. Apa yang membuat sebuah kontrak siap untuk Solana

Identitas EVM seorang pengguna Solana adalah **alamat sintetis**, `keccak256(solana_pubkey)[12:]`: sebuah `msg.sender`akun biasa, dengan nonce biasa. Sebagian besar kontrak tidak perlu perubahan sama sekali. Tiga hal yang penting:

* **Ambil nilai sebagai ERC-20, bukan `msg.value`.** Dana pengguna Solana adalah token SPL di wallet mereka, yang di sisi EVM terlihat sebagai pembungkus token (`wUSDC`, `wETH`, `wSOL`). Synthetic tidak menyimpan apa pun saat diam dan aset pengguna datang sebagai pembungkus, jadi tarik dengan `transferFrom` setelah sebuah `approve` dan kembalikan dengan `transfer`. Setiap pengguna memberikan hak delegasi SPL kepada pembungkus satu kali sebelum tarikan pertama ([Sekali saja: berikan hak pada wrapper](/id/panduan-pengembang/dual-lane-app.md#one-time-grant-the-wrapper)). Sebuah `payable` titik masuk hanya bekerja setelah synthetic diberi gas native (jalur relay `rome_composeExternalDepositV1`), yang tidak dilakukan oleh model fund-and-sweep. Vault ERC-20, AMM, atau pasar pinjaman yang sudah ada sudah memiliki bentuk yang tepat.
* **Gunakan pembungkus kanonik.** Setiap chain memiliki satu pembungkus per mint; alamat-alamatnya ada di [Contract Addresses](/id/referensi/contract-addresses.md) (milik Hadrian juga ada di publik [registry](https://github.com/rome-protocol/rome-registry)). Arahkan konstruktor ke alamat-alamat itu; jangan deploy milik Anda sendiri.
* **Sesuaikan dengan anggaran atomik tempat wallet menandatangani.** Wallet Solana menandatangani satu transaksi Solana, jadi panggilan jalur Solana harus muat di dalamnya: sekitar 1,4 juta compute units, 64 akun, 4 KB ([Batasan](/id/konsep-inti/constraints.md)). Diukur pada Hadrian: transfer, approve, dan supply Aave muat; swap Uniswap V3 muat dengan sedikit ruang sisa (sekitar 1,24 juta CU); borrow Aave tidak muat dan memakai jalur relay di bagian berikutnya. Ukur dengan receipt Solana `computeUnitsConsumed`, dengan meminta transaksi dengan `maxSupportedTransactionVersion: 1` (bagian Rome adalah transaksi v1; tanpa itu field akan terbaca 0).

Apa yang tidak Anda perlukan: program Solana, bridge, deployment kedua, atau Solidity khusus Rome apa pun. Jika kontrak juga memanggil program Solana melalui precompile, lihat [Call Solana from EVM](/id/panduan-pengembang/call-solana-from-evm.md).

## 3. Biarkan wallet Solana memanggilnya

Jalur EVM aplikasi Anda tidak berubah (MetaMask + `submitRomeTx`, atau viem/ethers biasa). Untuk jalur Solana ada dua bentuk.

**Jalur SDK — satu transaksi Solana v1 per panggilan.** [`@rome-protocol/sdk`](https://github.com/rome-protocol/rome-sdk-ts) (`submitRomeTxV1`) membuat proxy menyusun satu transaksi Solana v1 untuk panggilan EVM Anda (hingga 64 akun dan 4 KB, tanpa address lookup table; tidak ada instruksi ComputeBudget, treasure wallet, atau penemuan akun dalam kode Anda). Wallet menandatangani dua kali dengan kunci yang sama: pertama pesan otorisasi yang dapat dibaca (`otorisasi Rome` pada satu baris, `0x` dan hash transaksi EVM pada baris berikutnya), yang dicek oleh chain melalui program Ed25519, lalu transaksi. Aplikasi mengirim transaksi yang sudah ditandatangani ke RPC Solana; panggilan mengembalikan hash transaksi EVM dan receipt-nya. Sebelum wallet menandatangani transaksi, SDK memeriksanya: payer adalah satu-satunya penandatangan, hanya program Rome dan verifier Ed25519 yang berjalan, instruksi Rome membawa tepat panggilan yang diotorisasi pengguna, dan tidak ada biaya prioritas. Apa pun selain itu ditolak.

Jika sebuah panggilan tidak muat dalam satu transaksi, composer menolaknya dan SDK menyerahkannya ke proxy untuk di-relay, dengan tanda tangan otorisasi yang sama, sehingga pengguna tetap hanya melihat satu prompt otorisasi. Hasilnya kemudian memiliki `route: "relay"`. Aturan untuk panggilan relay dan panggilan panjang ada di [Panggilan yang direlai dan panggilan panjang](/id/panduan-pengembang/call-evm-from-solana.md#relayed-calls-and-long-calls). Panggilan yang direlay dibayar dalam gas native chain, jadi synthetic memerlukan saldo gas: `fundSyntheticGas(deps, amountWei)` memindahkan token gas chain (USDC di Hadrian dan Rubicon) dari akun token wallet ke dalamnya, dalam satu transaksi v1 yang ditandatangani wallet.

Bagian pendanaan (`buildFundLeg`) dan pembuatan akun token wallet sebelum sweep adalah instruksi Solana biasa; `submitSolanaInstructionsV1` mengirimnya juga sebagai transaksi v1, ditandatangani oleh penandatangan wallet yang sama, tanpa proxy terlibat. Panggilan sweep itu sendiri (`buildSweepLeg`, `HelperProgram.transfer_spl`berjalan melalui `submitRomeTxV1` seperti yang lain, dan proxy menemukan akun token. `submitRomeTxV1` tidak membuat akun synthetic baru dengan sendirinya: sebelum panggilan pertama yang memindahkan nilai, periksa `isSyntheticProvisioned(...)` dan, jika nilainya false, kirim `buildCreatePdaCall(synthetic)` melalui `submitRomeTxV1` sekali. Panduan lengkap deposit dan withdraw beserta kode ada di [Build a dual-lane app](/id/panduan-pengembang/dual-lane-app.md); mekanismenya ada di [Call EVM from Solana](/id/panduan-pengembang/call-evm-from-solana.md). Yang sebelumnya `submitRomeTxSolanaLane`yang membangun transaksi Solana legacy di klien, masih ada di SDK sebagai jalur lama.

**Dari mana setiap `deps` nilai berasal.** Objek SDK `deps` memiliki lima field wajib (sisanya, seperti `fetchImpl` dan timeout, bersifat opsional). Empat berasal dari chain dan satu dari wallet:

| `deps` field | Asalnya dari                                                                                                               | Getter registry (`@rome-protocol/registry` v0.2.0)                                                             |
| ------------ | -------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- |
| `proxyUrl`   | URL RPC chain                                                                                                              | `getChain(chainId).rpcUrl`                                                                                     |
| `chainId`    | ID chain                                                                                                                   | `getChain(chainId).chainId`                                                                                    |
| `programId`  | ID program Rome yang dijalankan chain                                                                                      | `getChain(chainId).romeEvmProgramId`                                                                           |
| `connection` | RPC Solana untuk cluster chain, tempat transaksi yang ditandatangani dikirim (devnet untuk Hadrian, mainnet untuk Rubicon) | `getChain(chainId).solana.rpc` (URL devnet publik untuk Hadrian); untuk mainnet gunakan RPC milik Anda sendiri |
| `signer`     | milik wallet `LaneSigner`, atau sebuah `Keypair` dalam skrip                                                               | tidak ada                                                                                                      |

Pembuat leg mengambil nilai yang tidak ada di `deps`. Milik mereka `mint` (disebut `usdcMint` dalam panduan) adalah mint Solana dari token gas, dari `getTokens(chainId)` (entri dengan `kind: "gas"`, field `mintId`). Alamat pembungkus wUSDC bukan input pembuat leg; Anda menggunakannya untuk panggilan ERC-20, dan itu adalah entri dengan `kind: "spl_wrapper"` dan simbol `wUSDC` (field `address`). Registry mencakup Hadrian. Untuk Rubicon, isi secara manual: `proxyUrl` `https://rubicon.mainnet.romeprotocol.xyz/`, `chainId` `7531`, `programId` `RomePq9X3iAoTr813HR7uRarafFDUJty6GdiEceYpzX`, `mint` `EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v`pembungkus dari tabel di bagian berikutnya, dan RPC mainnet Solana untuk `connection`. [Rubicon](/id/jaringan/rubicon.md) memiliki daftar lengkap.

**Endpoint external-V1 proxy — jalur yang sama tanpa SDK.** SDK membungkus atomic compose, relay, dan deposit gas (`fundSyntheticGas`). Metode RPC mentah tetap tersedia bagi klien yang tidak menggunakan SDK, dan itu mencakup iterative compose, yang tidak dibungkus SDK. Wallet menandatangani satu pesan Ed25519 atas panggilan tersebut (bentuk yang dapat dibaca `Otorisasi Rome\n0x<hash>` atau hash mentah), dan proxy kemudian menyusun transaksi Solana untuk ditandatangani wallet (`rome_composeUnsignedAtomicV1`, `rome_composeUnsignedIterativeV1` + `rome_submitSignedV1Plan`) atau menjalankan seluruh eksekusi sendiri dengan satu tanda tangan wallet (`rome_relayUnsignedV1`, setelah sebuah `rome_composeExternalDepositV1` (milik SDK `fundSyntheticGas`) yang mendanai saldo gas synthetic; panggilan relay menghabiskannya, jadi isi lagi saat mulai menipis). Bentuk metode di [Dukungan JSON-RPC](/id/referensi/json-rpc.md); aturan otorisasi di [Call EVM from Solana](/id/panduan-pengembang/call-evm-from-solana.md#the-external-v1-endpoints). Gunakan relay untuk apa pun yang bersifat iteratif, dan jalur SDK untuk semua yang muat.

Apa pun pilihannya, kontrak melihat transaksi normal dari alamat synthetic dan pengguna tidak pernah memegang kunci EVM.

## 4. Alamat pembungkus per jaringan

| Jaringan         | `wUSDC` pembungkus                           | Pembungkus lain                                                                                          |
| ---------------- | -------------------------------------------- | -------------------------------------------------------------------------------------------------------- |
| Rubicon (7531)   | `0x0952d233b0c254cd375f3bfb3e5869c1a906f9b3` | `wETH` `0x01e8b3573da1d4b7b4b1ce0932cf07c8af0c92e9`, `wSOL` `0xc4e29e0f726a906e93277cbbc37bf27a9848a113` |
| Hadrian (200010) | `0xbce339ba4c3a8de3bb8af1c5539e6ac11da3112d` | `wETH` `0x02aeace038269f9961c93d04dcacd6fb3adfa55f`, `wSOL` `0x39f36444fcb79b3e691544aee2a832ebef54ca9f` |

Token gas native muncul sebagai `0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee` dalam daftar token; itu bukan kontrak ERC-20. Pembungkus membawa desimal mint SPL, bukan 18: wUSDC 6, wETH 8, wSOL 9.

## 5. Daftar periksa peluncuran

1. Sudah di-deploy di Hadrian; jalur EVM berfungsi dari MetaMask.
2. Setiap titik masuk yang memindahkan nilai berbasis ERC-20 dan diarahkan ke pembungkus kanonik chain.
3. Wallet Solana yang menandatangani transaksi v1 (Solflare bisa di devnet saat ini; Phantom belum) menyelesaikan round trip penuh di Hadrian: provisikan synthetic (`create_pda`, sekali) → bagian pendanaan → grant → approve → panggil → bagian sweep, menggunakan jalur SDK; atau jalur relay jika panggilan bersifat iteratif.
4. Setiap `computeUnitsConsumed` dibaca dari receipt Solana dan berada di bawah anggaran atomik, atau panggilan dialihkan melalui relay.
5. Pemberian izin pembungkus ada di alur deposit pertama aplikasi Anda untuk kedua jalur: `isEnabled(user)` diperiksa dan `approve_spl` dikirim sekali ketika nilainya false ([Sekali saja: berikan hak pada wrapper](/id/panduan-pengembang/dual-lane-app.md#one-time-grant-the-wrapper)).
6. Sumber diverifikasi di explorer.
7. Di-deploy ulang di Rubicon dengan alamat pembungkus mainnet. Rubicon tidak ada di registry, jadi `deps` nilainya diisi secara manual dari [Rubicon](/id/jaringan/rubicon.md). Round trip yang sama dijalankan sekali dengan dana sungguhan, menggunakan wallet yang telah Anda cek menandatangani transaksi v1 di mainnet.

## Berikutnya

* [Build a dual-lane app](/id/panduan-pengembang/dual-lane-app.md) — contoh vault, langkah demi langkah, kedua wallet
* [Call EVM from Solana](/id/panduan-pengembang/call-evm-from-solana.md) — alamat synthetic, penemuan akun, endpoint external-V1
* [Deploy Solidity Contracts](/id/panduan-pengembang/deploy-solidity.md) · [Verifikasi Kontrak](/id/panduan-pengembang/verify-contracts.md) · [Contract Addresses](/id/referensi/contract-addresses.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/panduan-pengembang/open-to-solana-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.