> 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/13-build-on-solgate.md).

# 13. Bangun di Solgate

Bangun di Solgate, jembatan dan rute pesan antara Solana, Ethereum, dan chain AggLayer. Pelajari apa yang dapat melintasi jaringan, cara pesan mengalir, biayanya, dan cara beralih dari Hadrian ke Rubicon.

Rome menjadikan EVM dan Solana satu pasar. Solgate adalah jembatan dan jalur pesan di antara keduanya. Solgate membawa token Solana ke Ethereum dan rantai AggLayer, serta token EVM ke Solana. Solgate juga membawa pesan antarkontrak, dan kontrak Rome yang menerima pesan dapat memanggil program Solana dalam transaksi yang sama. Pelajaran ini menjelaskan aset yang dapat melintasi jaringan, alur pesan, hal yang perlu diperiksa pada kontrak penerima, serta cara mulai membangun di Hadrian sekarang dan meluncurkannya di Rubicon. [Pelajaran 10](https://docs.rome.builders/id/rome-academy/10-from-other-chains.md) membahas Rome Bridge, yang membawa masuk USDC. Solgate adalah jalur untuk token lain dan pesan.

## Yang akan Anda pelajari

* Token apa saja yang melintasi jaringan ke masing-masing arah, dan bagaimana token yang belum memiliki mint Solana dapat dibuat agar bisa dijembatani.
* Arti Verified dan Unverified, serta cara pengguna menambahkan token ke dompet mereka.
* Alur pesan dari Ethereum ke Rome lalu ke program Solana, dan sebaliknya.
* Waktu dan biaya yang diukur di Hadrian dan Sepolia.
* Aturan yang harus dipatuhi kontrak penerima, dan jenis pesan yang tidak cocok untuknya.
* Alasan menggunakan Solgate dan hal yang Anda andalkan untuk masing-masing arah.
* Cara memulai di Hadrian dan perubahan yang terjadi di Rubicon.

## Sebelum memulai

* Selesaikan [10. Membawa pengguna dan dana dari rantai lain](https://docs.rome.builders/id/rome-academy/10-from-other-chains.md). Anda perlu memahami konsep klaim jembatan.
* Baca [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). Kontrak penerima yang memanggil Solana menggunakan precompile CPI, dan token Solana di Rome adalah mint itu sendiri.
* Siapkan dompet Hadrian yang berisi dana, dompet EVM dengan ETH Sepolia, dan dompet Solana dengan SOL devnet. Langkah 7 mencantumkan faucet.

## Pelajaran

### Langkah 1. Ketahui aset yang melintasi jaringan

Solgate membawa satu bentuk setiap token untuk masing-masing rantai, yaitu bentuk yang tercatat di rantai. Tentukan arahnya terlebih dahulu.

**Dari Solana ke Ethereum dan rantai AggLayer**

| Token                                                                                                                                    | Dapat melintasi?                                                                    |
| ---------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------- |
| SOL                                                                                                                                      | Ya, sebagai "Wrapped SOL (Rome)"                                                    |
| Token SPL klasik, termasuk meme coin                                                                                                     | Ya. Di testnet, pilih atau tempel mint-nya; pengiriman pertama akan mencantumkannya |
| Token-2022 yang satu-satunya kemampuan tambahannya adalah pembekuan                                                                      | Di testnet. Belum tersedia di mainnet                                               |
| Token-2022 dengan biaya transfer                                                                                                         | Tidak dapat dibawa                                                                  |
| Token-2022 lainnya (hook transfer, delegasi permanen)                                                                                    | Tetap berada di Solana dan Rome, tempat EVM Rome tetap menggunakannya               |
| Mint yang tidak dapat ditransfer, NFT                                                                                                    | Tidak                                                                               |
| Token yang dibawa ke Solana oleh jembatan lain, jika AggLayer menjangkau rantai asalnya (misalnya ETH yang dijembatani melalui Wormhole) | Jangan dijembatani dua kali. Jembatani aset aslinya dari rantai asal                |
| USDC                                                                                                                                     | Berpindah melalui CCTP milik Circle, bukan Solgate                                  |

**Dari Ethereum dan rantai AggLayer ke Solana**

| Token                                                                                           | Dapat melintasi?                                                                |
| ----------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------- |
| ETH                                                                                             | Ya, sebagai "Ether (Rome)", dengan 9 desimal di Solana                          |
| ERC-20 standar                                                                                  | Ya, sebagai "\<name> (Rome)", mint SPL klasik. Di testnet, penyiapan tanpa izin |
| ERC-20 dengan biaya saat transfer                                                               | Ya. Jembatan mencatat jumlah yang diterimanya.                                  |
| Token yang penerbitnya menjalankan rutenya sendiri ke Solana (CCTP milik Circle dan sejenisnya) | Gunakan rute penerbit                                                           |
| Token berizin (ERC-3643 dan sejenisnya)                                                         | Hanya rute milik penerbit                                                       |
| Token rebasing                                                                                  | Tidak. Bridge wrapper non-rebasing                                              |
| Salinan yang dibuat bridge lain, saat AggLayer menjangkau chain asalnya                         | Tidak di-bridge dua kali                                                        |

Aturan yang berlaku untuk setiap token:

* Solgate membawa satu bentuk dari setiap token per chain. Bentuk yang dibuat bridge lain tetap terpisah dan tidak pernah digabungkan.
* Setiap token yang dibuat Rome diberi nama "\<origin name> (Rome)" dan tetap menggunakan simbol dari token asalnya.
* Solana menyimpan suplai dalam 64 bit, jadi token dengan lebih dari 9 angka desimal memiliki 9 angka desimal di Solana. Jumlah dipindahkan dalam satuan penuh Solana. Sisa di bawah satu satuan tetap berada di bridge sebagai jaminan.
* Mint Solana yang dibuat Rome tidak memiliki otoritas pembekuan. Satu-satunya otoritas mint-nya adalah kontrak token di Rome.
* Di Rome, token Solana adalah mint-nya. Saldo Rome milik sebuah dompet adalah akun token Solana-nya sendiri, tanpa salinan wrapped kedua.
* Saat ini, token yang dibuat di chain Rome tidak dibawa oleh Solgate.

Token yang belum memiliki mint Solana dapat dibuat agar bisa di-bridge melalui beberapa langkah yang ditandatangani. Di testnet, siapa pun dapat melakukannya dari dompet EVM atau Solana. Di mainnet, Rome mencantumkan token tersebut.

1. **Token asal EVM.** Kirim token ke Hadrian terlebih dahulu. Klaim pertamanya di sana akan membuat salinan Rome-nya. Lalu buka **Tambahkan token** dan tempelkan bentuk apa pun: kata, alamat chain asal, alamat Rome, atau mint Solana.
2. **Tanda tangani langkah-langkah bernomor.** Langkah-langkahnya adalah penyiapan, logo opsional, dan penyelesaian. Dompet Solana hanya membayar dalam SOL dan tidak memerlukan gas Rome, karena relay Rome mengirimkan transaksi penyelesaian untuknya. Kartu menampilkan seluruh biaya sebelum Anda menandatangani. Biaya penyiapan Hadrian adalah 1 USDC atau 0,06 SOL, ditambah biaya jaringan.
3. **Token asal Solana.** Pilih atau tempelkan mint di Bridge. Pengiriman pertamanya akan menambahkan token itu ke bridge dan mencantumkannya sebagai langkah satu kali.

Logo bersifat opsional, gratis, dan memerlukan satu tanda tangan tambahan. Ukuran file harus di bawah 256 KB dan gunakan PNG, karena dompet Solana mungkin tidak menampilkan SVG. Anda dapat menambahkannya nanti dari Token saya.

### Langkah 2. Beri tahu pengguna mana yang Terverifikasi, dan izinkan mereka menambahkan token

Token Terverifikasi tercantum dalam daftar terverifikasi Rome. Token lain yang disiapkan melalui jalur terbuka akan ditandai **Belum terverifikasi**. Tab **Token** mencantumkan semua token. Pengguna dapat mencari berdasarkan nama, simbol, atau alamat apa pun. Setiap baris menampilkan logo, tag, dan rute, serta dapat diperluas untuk melihat alamat per chain dengan tautan salin dan penjelajah, **Tambahkan ke dompet** dan **Bridge**. Opsi "Hanya terverifikasi" aktif secara default.

Kriteria Terverifikasi: kontrak asli di chain asalnya, yang dibuktikan dengan pencantuman di CoinGecko atau CoinMarketCap, atau di situs penerbit; memiliki logo; dan tidak menyamar sebagai token terverifikasi.

Dompet dan penjelajah menjalankan pemeriksaan masing-masing. Di mainnet Solana, urutan yang umum adalah pencantuman di CoinGecko atau CoinMarketCap, lalu pembaruan reputasi Solscan dan verifikasi Jupiter. Solflare secara otomatis menetapkan tag-nya sendiri.

Dompet EVM menyediakan opsi **Tambahkan ke dompet** sekali klik (EIP-747) pada baris Token, di Token saya, dan di layar kedatangan. Dompet Solana membaca nama, simbol, dan logo token dari metadata on-chain-nya.

### Langkah 3. Ikuti pesan

Kontrak apa pun di Ethereum atau chain AggLayer dapat mengirim pesan ke kontrak di Rome, dan sebaliknya. State Rome tersimpan di Solana, sehingga kontrak Rome penerima dapat memanggil program Solana mana pun dalam transaksi yang sama, dengan tanda tangan PDA miliknya sendiri—akun Solana yang hanya dapat ditandatangani oleh kontrak tersebut. Program Solana juga dapat mengirim pesan keluar melalui Rome dengan cara yang sama.

Anda memerlukan fitur pengiriman pesan saat pelakunya adalah kontrak (DAO, eksekutor tata kelola, vault, escrow, atau Safe), atau saat Solana harus bertindak di chain EVM. Pengguna dengan dompet EVM tidak memerlukannya, karena alamat yang sama dapat langsung digunakan di Rome.

```
Chain Ethereum / AggLayer               Rome (EVM, state di Solana)                  Solana
pengirim ─ bridgeMessage(rome, rcvr, …, data) ─► komite Rome memublikasikan exit root
                                          siapa pun: claimMessage(proof, data)
                                          └► rcvr.onMessageReceived(origin, net, data)
                                               └► CPI opsional melalui 0xFF..08,
                                                  ditandatangani oleh PDA penerima ──────► program apa pun

Program Solana ─ CPI ke program EVM Rome, ditandatangani oleh PDA-nya ─► bridgeMessage(dest, rcvr, data)
                                          Sertifikat Rome difinalisasi di Ethereum ─► siapa pun dapat melakukan klaim di jaringan tujuan
```

Untuk pesan masuk, pengirim memanggil `bridgeMessage`. Komite Rome memublikasikan exit root Ethereum ke Rome. Setelah itu, siapa pun dapat memanggil `claimMessage` dengan bukti tersebut, lalu bridge memanggil `onMessageReceived` pada receiver Anda. Untuk pesan keluar, program Solana memanggil program EVM Rome, yang kemudian memanggil `bridgeMessage`. Sertifikat Rome difinalisasi di Ethereum, lalu siapa pun dapat melakukan klaim di jaringan tujuan.

### Langkah 4. Baca waktu yang terukur

Leg ini berjalan di Hadrian dan Sepolia.

| Leg                                                      | Hasil                                                                            | Waktu hingga dapat diklaim        | Biaya di Hadrian                                       |
| -------------------------------------------------------- | -------------------------------------------------------------------------------- | --------------------------------- | ------------------------------------------------------ |
| Kontrak Sepolia → kontrak Rome                           | Terkirim                                                                         | 133–158 dtk                       | $0.096 ke receiver baru, $0.0007 setelahnya            |
| Sepolia → kontrak Rome → program Memo Solana, satu klaim | Memo berjalan, PDA receiver menandatangani                                       | 158 dtk                           | $0.096 ke receiver baru                                |
| Nilai ETH beserta pesan ke Rome                          | Tiba sebagai saldo wrapped-ETH biasa                                             | 396 dtk (saat lonjakan pengujian) | $0.19                                                  |
| Token dan pesan dalam satu transaksi Sepolia             | 5 dari 5 terkirim, token diklaim terlebih dahulu                                 | Tidak tercatat                    | $0.175 + $0.119                                        |
| Receiver menolak, lalu menerima                          | Simulasi API menolak klaim, jadi tidak ada yang dikirim; klaim berhasil kemudian | 412 dtk                           | $0.0007 untuk klaim yang diterima                      |
| Kontrak Rome → kontrak Sepolia                           | Terkirim dan diklaim                                                             | 317 dtk                           | Pengiriman $0.0007; 446.636 gas untuk klaim di Sepolia |
| Program Solana → Rome → keluar                           | Dikirim melalui satu transaksi Solana; belum diklaim di Sepolia                  | t/a                               | 5.000 lamport + biaya Rome (tidak tercatat)            |

Sebuah `bridgeMessage` Sepolia dengan pembaruan exit root paksa menggunakan 395K hingga 400K gas. Gas chain sumber tidak termasuk dalam biaya Hadrian di atas.

Belum diuji: mainnet, pesan L2 AggLayer, wallet Solana sebagai pengirim, nilai yang dikirim keluar dari Rome, nilai beserta pemanggilan Solana, receiver tata kelola yang realistis, dan klaim iteratif.

### Langkah 5. Tulis receiver yang aman

* **Periksa pemanggil dan asalnya.** `msg.sender` haruslah bridge. `(originNetwork, originAddress)` harus merupakan pengirim yang Anda percayai.
* **Klaim hanya dapat dilakukan sekali, dan itu hak Anda.** Klaim yang dibatalkan tetap dapat diklaim dan bisa dicoba lagi, sementara peran penghapus exit root pada bridge dapat membatalkan klaim. Simpan nonce Anda sendiri.
* **Klaim tidak dilakukan secara otomatis.** Aplikasi Anda menjalankan claimer, atau pengguna yang mengklaim. Claimer membayar gas penerima.
* **Nilai yang masuk** tiba sebagai ETH terbungkus di Rome. **Nilai yang keluar** hanya dikirim sebagai ETH terbungkus (`bridgeMessageWETH`, dalam kelipatan 1e9 wei), dan jalur ini belum pernah dijalankan. USDC gas Rome berpindah melalui CCTP, tidak pernah melalui AggLayer.
* **Penerima yang memanggil Solana menerima pesan bernilai nol.** Kirim nilai sebagai token terpisah dalam transaksi sumber yang sama, lalu periksa di penerima apakah token itu sudah tiba.
* **Ukur penggunaan komputasi Anda.** Transaksi Solana mengizinkan sekitar 1,35 juta CU, dan estimasi gas menolak transaksi di atas sekitar 1,25 juta. Klaim Memo-CPI menggunakan 813.199 CU, sehingga tersisa sekitar 0,44 hingga 0,54 juta CU untuk pekerjaan Solana tambahan. Instruksi yang lebih besar dan jumlah akun yang lebih banyak belum diukur. Untuk pekerjaan yang lebih berat, seperti swap DEX atau peminjaman, simpan pesan terlebih dahulu, lalu jalankan dalam transaksi kedua.
* **Jaga agar pesan tetap kecil.** Klaim pesan 16 byte saja sudah menghasilkan calldata sekitar 2,4 KB.
* **Batasi apa yang dapat dibuka oleh satu pesan dari Rome** di chain tujuan, dengan batas atau penundaan. Pesan keluar hanya mengandalkan penanda tangan Rome.

Pesan tidak cocok untuk intent, pengisian cepat, likuidasi, dan umpan harga. Perjalanan dari Sepolia ke Rome memakan waktu 133 hingga 412 detik, dan rute L2 AggLayer menambahkan waktu penyelesaian chain itu sendiri. Pesan juga tidak cocok untuk pekerjaan Solana yang berat dalam satu klaim, atau untuk membeli token Solana melalui pesan.

### Langkah 6. Pahami alasan menggunakan Solgate dan hal yang Anda andalkan

* **Penyelesaian dilakukan melalui AggLayer Polygon di Ethereum.** Rome menjalankan kontrak bridge AggLayer Polygon tanpa modifikasi. Sertifikat keluar Rome diselesaikan di Ethereum menggunakan bukti pesimistis AggLayer.
* **Tidak ada jaringan validator bridge terpisah.** Pihak-pihak yang terlibat adalah Ethereum, AggLayer, dan kunci milik Rome sendiri: komite 2-dari-3 untuk arah masuk, serta penanda tangan AggLayer milik Rome untuk arah keluar.
* **Hanya ada satu pasar.** Di Rome, token Solana menggunakan mint yang sama, bukan salinan terbungkus. Saldo wallet Solana di Rome berada di akun tokennya sendiri, dan kontrak Rome memindahkan token SPL yang sama.
* **Dapat diprogram di kedua sisi.** Pesan EVM dapat menjalankan program Solana dalam transaksi tempat pesan itu tiba. Program Solana dapat mengirim pesan keluar melalui Rome.
* **Di testnet, penyiapan dapat dilakukan tanpa izin dari kedua jenis wallet.** Wallet Solana hanya membayar SOL. Token EVM menjadi mint SPL klasik tanpa otoritas pembekuan, dan hanya kontraknya di Rome yang dapat mencetaknya.
* **Hanya ada satu bentuk untuk tiap chain; tidak ada pembungkusan ulang token terbungkus.** Rome menandai token yang dibuatnya dengan "(Rome)", mempertahankan token yang memiliki rute ke penerbitnya pada rute tersebut, dan tidak pernah menjembatani ulang salinan milik bridge lain.
* **Hanya ada satu koneksi ke AggLayer.** Bridge terpadu yang sama menjangkau Ethereum dan setiap chain AggLayer yang dicantumkan aplikasi.
* **Bandingkan model kepercayaannya.** Wormhole, LayerZero, CCIP, dan lainnya juga menghubungkan chain Solana dan EVM, masing-masing dengan model kepercayaannya sendiri. Bandingkan tabel di bawah dengan model mereka sesuai kebutuhan Anda.

| Arah                                | Hal yang Anda andalkan                                                                                                                                                                                                                                             |
| ----------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Ethereum → Rome                     | Ethereum, ditambah komite 2-dari-3 yang mengirim exit root Ethereum ke Rome. Safe milik Rome mengelolanya, dengan timelock                                                                                                                                         |
| Chain AggLayer → Rome               | Hal-hal di atas, ditambah sertifikat chain tersebut yang diselesaikan di Ethereum                                                                                                                                                                                  |
| Rome → Ethereum atau chain AggLayer | Penanda tangan AggLayer milik Rome. Bukti pesimistis membatasi jumlah setiap token yang berasal dari chain lain hingga jumlah yang masuk. Pesan dan token yang asal AggLayer-nya adalah Rome (SOL dan token Solana lainnya) hanya mengandalkan para penanda tangan |

### Langkah 7. Mulai di Hadrian

Aplikasinya ada di [solgate.testnet.romeprotocol.xyz](https://solgate.testnet.romeprotocol.xyz). Fitur yang tersedia: Bridge, Tambah token, Token, Klaim, Aktivitas, dan Cara kerjanya. Daftar chain aktif tersedia di `GET /v1/chains`.

| Chain            | Jaringan AggLayer | ID Chain | Catatan                                                                                                                     |
| ---------------- | ----------------- | -------- | --------------------------------------------------------------------------------------------------------------------------- |
| Rome Hadrian     | 74                | 200010   | RPC `https://hadrian.testnet.romeprotocol.xyz/`, penjelajah `via-hadrian.testnet.romeprotocol.xyz`; status di Solana devnet |
| Ethereum Sepolia | 0                 | 11155111 | Klaim sendiri                                                                                                               |
| Katana Bokuto    | 37                | 737373   | Klaim sendiri                                                                                                               |
| Billions Testnet | 32                | 6913     | Klaim sendiri                                                                                                               |

Token uji:

* **SOL Solana devnet.** faucet.solana.com. Dompet Solana tidak memerlukan apa pun lagi di Solgate.
* **Gas Hadrian (USDC).** USDC testnet dari faucet Circle (faucet.circle.com), yang dikirim ke alamat EVM Anda sebagai gas Hadrian menggunakan Rome Bridge testnet (bridge-api.devnet.romeprotocol.xyz). Pilih testnet sumber yang tercantum di Rome Bridge.
* **ETH Sepolia.** Faucet Sepolia publik mana pun.
* **Token ERC-20 Sepolia yang sudah diverifikasi di Hadrian.** Token faucet Sepolia Aave (DAI, USDT, WBTC, AAVE, EURS). Atau deploy token Anda sendiri dan siapkan konfigurasinya.

Kontrak dan kode untuk dibaca:

* Bridge Rome Hadrian: `0x5366e5864cb9dba587a706d8dd48cfdc40b961af` (jaringan 74). Bridge Sepolia: `0x528e26b25a34a4A5d0dbDa1d57D318153d2ED582` (jaringan 0).
* Bridge Polygon: `github.com/agglayer/agglayer-contracts`. Baca `AgglayerBridge.sol` dan `AgglayerBridgeL2.sol` (`bridgeMessage`, `bridgeMessageWETH`, `claimMessage`) serta `IBridgeMessageReceiver` antarmuka (`onMessageReceived`).
* Precompile Solana milik Rome: `github.com/rome-protocol/rome-solidity`, `contracts/interface.sol`. CPI ke program apa pun berada di `0xFF00…0008`, dan precompile token SPL berada di `0xff00…0005`.
* Alamat token per chain: `GET /v1/tokens`. Chain: `GET /v1/chains`. Sakelar live: `GET /v1/switches`.

API pesan tersedia di Hadrian.

| Panggil                                      | Gunakan                                                                                                                                                                                              |
| -------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `POST /v1/transfers` `{ networkId, txHash }` | Catat pengiriman yang Anda tambang. `networkId` adalah jaringan asalnya                                                                                                                              |
| `GET /v1/transfers?wallet=<address>`         | Entri Anda                                                                                                                                                                                           |
| `GET /v1/transfers?tx=<hash>`                | Entri untuk satu pengiriman, token terlebih dahulu                                                                                                                                                   |
| `GET /v1/transfers/:id`                      | Satu entri, beserta tahapnya: sent → certified → settled → ready\_to\_claim → claimed → received                                                                                                     |
| `GET /v1/transfers/:id/claim`                | Transaksi klaim, disimulasikan terlebih dahulu. Jika receiver akan mengalami revert, hasilnya adalah `message_would_fail`. Simulasi ini tidak mendeteksi klaim yang melampaui batas komputasi Solana |

### Langkah 8. Beralih dari Hadrian ke Rubicon

Rubicon adalah chain mainnet utama Rome, dengan state di mainnet Solana dan penyelesaian di AggLayer pada mainnet Ethereum. Solgate aktif di Rubicon di [solgate.romeprotocol.xyz](https://solgate.romeprotocol.xyz), bersama Ethereum, X Layer, dan Katana, dan Rome mencantumkan token-token di sana. Apa pun yang Anda bangun di Hadrian dapat dipindahkan dengan ID chain dan alamat yang telah diubah. Ukur ulang waktu dan biaya di mainnet karena angka Hadrian adalah angka testnet. Panduan umum untuk berpindah ada di [11. Rilis ke Rubicon](https://docs.rome.builders/id/rome-academy/11-ship-to-rubicon.md).

Di mainnet: pengiriman dua arah dan klaim di Solana untuk SOL, ETH, USDT, WBTC, dan OKB; klaim otomatis deposit ETH dari Ethereum ke dompet EVM di Rubicon; tab Tokens; filter Activity; serta kartu Arrived. Pelacakan pesan, penyiapan token tanpa izin dari kedua dompet, dan jalur listing untuk token yang berasal dari Solana berjalan di testnet dan belum tersedia di mainnet. Lihat [Menggunakan Solgate](https://docs.rome.builders/id/aplikasi-di-rome/solgate/using.md).

Perubahan di mainnet:

* Biaya gas sungguhan: USDC di Rubicon (bawa masuk melalui Rome Bridge) dan ETH di Ethereum.
* Waktu kedatangan mengikuti penyelesaian mainnet: Ethereum ke Solana sekitar 120 detik, Solana ke Ethereum sekitar 6 menit, X Layer dari Solana sekitar 18 menit, Katana dari Solana sekitar 4 menit, dan Katana ke Solana sekitar 65 menit. [Menggunakan Solgate](https://docs.rome.builders/id/aplikasi-di-rome/solgate/using.md#times) mencantumkannya.
* Di mainnet, Phantom dan Solflare menambahkan instruksi mereka sendiri ke transaksi.
* Dompet dan penjelajah blockchain menjalankan pemeriksaan token mereka sendiri (langkah 2).
* Model kepercayaannya sama, dengan komite dan kumpulan penanda tangan mainnet Rome.

Bangun sekarang di Hadrian. Rilis di Rubicon saat Anda siap.

## Uji pemahaman Anda

Lakukan uji coba pulang-pergi kecil di Hadrian.

1. Deploy ERC-20 uji di Sepolia, bridge sebagian ke Hadrian, lalu jalankan **Tambahkan token** menggunakan dompet EVM. Baca total pada kartu sebelum menandatangani.
2. Buat mint SPL di devnet Solana, pilih di Bridge menggunakan dompet Solana, kirim ke Ethereum Sepolia, lalu klaim di sana.
3. Tulis receiver dengan dua pemeriksaan dan nonce. Kirim satu pesan kepadanya dari kontrak Sepolia, lalu klaim menggunakan `GET /v1/transfers/:id/claim`.

Lalu jawab:

* Dua nilai apa yang diperiksa receiver sebelum memercayai sebuah pesan?
* Sebuah receiver memanggil Solana dan juga harus menerima nilai. Bagaimana cara mengirimkannya?
* Mengapa pesan tidak cocok untuk likuidasi?

<details>

<summary>Jawaban</summary>

* `msg.sender`, yang harus berupa bridge, dan `(originNetwork, originAddress)`, yang harus berupa pengirim tepercaya.
* Kirim pesan dengan nilai nol. Kirim nilainya sebagai token terpisah dalam transaksi sumber yang sama, lalu periksa di sisi penerima bahwa token tersebut telah diterima.
* Perjalanan dari Sepolia ke Rome memerlukan waktu 133 hingga 412 detik, dan rute AggLayer L2 menambahkan waktu penyelesaian milik chain tersebut. Likuidasi tidak bisa menunggu selama itu.

</details>

## Berikutnya

Ide untuk dikembangkan, beserta titik awal masing-masing, tersedia di [Ide Solgate](https://docs.rome.builders/id/aplikasi-di-rome/solgate/ideas.md). Halaman referensinya adalah [Membangun di Solgate](https://docs.rome.builders/id/aplikasi-di-rome/solgate/builders.md) untuk token dan [Messaging di Solgate](https://docs.rome.builders/id/aplikasi-di-rome/solgate/messaging.md) untuk pesan.

[Kembali ke peta kursus](https://docs.rome.builders/id/rome-academy/academy.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/13-build-on-solgate.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.
