> 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/01-what-you-are-building.md).

# 1. Apa yang Anda bangun di Rome

Rome menjadikan EVM dan Solana satu pasar. Bagaimana satu kontrak melayani dompet EVM dan Solana, serta aplikasi yang Anda bangun dalam kursus ini.

Rome menjadikan EVM dan Solana satu pasar. Anda menulis Solidity, menerapkannya dengan Hardhat atau Foundry, dan kontraknya berjalan di Solana. Pelajaran ini memberi gambaran yang Anda perlukan untuk dua belas pelajaran berikutnya. Anda akan membuat vault USDC yang menerima deposit dari dompet EVM dan Solana.

## Yang akan Anda pelajari

* Apa itu Rome, dan mengapa state-nya adalah state Solana.
* Dua jalur dompet: kunci EVM dan kunci Solana, satu kontrak.
* Apa itu aplikasi dua jalur, dan contoh yang Anda buat di pelajaran 9.
* Dua jaringan yang Anda gunakan: Hadrian untuk pengujian dan Rubicon untuk produksi.

## Sebelum memulai

Ini adalah pelajaran pertama. Baca [peta kursus](https://docs.rome.builders/id/rome-academy/academy.md) agar Anda tahu di mana kursus ini berakhir. Tidak ada hal lain yang diperlukan. Anda belum memerlukan dompet.

## Gagasannya

EVM dan Solana adalah dua pasar. Rome menjadikannya satu.

Rome menjalankan chain EVM di dalam Solana, sehingga protokol EVM apa pun dapat diterapkan sekali lalu dibuka untuk dompet Solana. Kontrak Solidity di Rome memanggil program Solana secara langsung, sehingga pengguna EVM dapat mengakses Kamino dan DEX Solana. Solgate menghubungkan aset Solana ke chain EVM AggLayer dalam dua arah, baik di mainnet maupun testnet. Di testnet, pendaftaran token SPL tidak memerlukan izin. USDC menggunakan CCTP.

Rome menjalankan kontrak Solidity dengan menyematkan interpreter EVM dalam program Solana. Saat Anda menerapkan kontrak, kode dan penyimpanannya menjadi akun Solana. Saat seseorang memanggilnya, interpreter berjalan di dalam runtime Solana. Sebuah pemanggilan dapat menjangkau program Solana mana pun dalam transaksi yang sama, dan jika satu langkah saja gagal, seluruh transaksi dibatalkan.

State-nya adalah state Solana. Di dalam Rome, token SPL milik dompet dan pembungkus ERC-20-nya membaca akun token yang sama, sehingga tidak ada yang dicetak atau dikunci di antara keduanya.

Baca [Satu pasar](https://docs.rome.builders/id/memulai-1/one-market.md) untuk memahami gagasan ini melalui empat kapabilitas dan [Apa itu Rome?](https://docs.rome.builders/id/memulai-1/what-is-rome.md) untuk gambaran lengkap. Baca sekilas [Mengapa Rome?](https://docs.rome.builders/id/memulai-1/why-rome.md) jika Anda ingin membandingkannya dengan pendekatan lain.

## Dua jalur

Dua jenis pengguna dapat memanggil kontrak yang sama.

|                                 | Jalur EVM                                                | Jalur Solana                                                        |
| ------------------------------- | -------------------------------------------------------- | ------------------------------------------------------------------- |
| Dompet                          | MetaMask atau dompet EVM apa pun                         | Dompet Solana                                                       |
| Kunci                           | Kunci EVM                                                | Kunci Solana                                                        |
| Identitas di dalam kontrak Anda | Alamat biasa                                             | Alamat sintetis yang diturunkan dari kunci Solana                   |
| Cara pemanggilan dikirim        | Transaksi EVM yang ditandatangani, dikirim ke proxy Rome | Transaksi Solana yang ditandatangani oleh dompet, dikirim ke Solana |

Di kedua jalur `msg.sender` adalah alamat biasa dan kontraknya tetap sama. Pengguna Solana tidak memerlukan kunci EVM. Rome tidak pernah menghubungkan kedua identitas tersebut. Kunci MetaMask dan kunci Solana adalah dua akun berbeda, sebagaimana dua kunci MetaMask juga merupakan akun yang berbeda.

[Cara Solana dan EVM bertemu di Rome](https://docs.rome.builders/id/konsep-inti/how-solana-and-evm-meet.md) menjelaskan alamat sintetis, siapa yang menandatangani, dan siapa yang membayar. Anda akan membahasnya lagi di pelajaran 4. Untuk saat ini, baca dua bagian pertamanya.

## Aplikasi yang Anda buat

Aplikasi dua jalur adalah satu kontrak Solidity yang digunakan langsung oleh pengguna EVM dan pengguna Solana. Contoh dalam kursus ini adalah vault sederhana. Pengguna menyetor USDC, lalu menariknya kembali nanti.

Kontrak ini adalah vault ERC-20 biasa. Kontrak mengambil token dengan `transferFrom` dan mengembalikannya dengan `transfer`. Kontrak ini tidak menyimpan apa pun yang khusus untuk Rome. USDC milik pengguna Solana muncul di sisi EVM sebagai pembungkus ERC-20 dari token SPL tersebut, sehingga dua pemanggilan yang sama berfungsi untuk kedua jalur.

Anda akan membuatnya di pelajaran 9. Panduan yang menjadi acuannya adalah [Membuat aplikasi dua jalur](https://docs.rome.builders/id/panduan-pengembang/dual-lane-app.md). Pelajaran 3 hingga 8 memberikan setiap komponen yang dibutuhkan:

1. Melakukan deployment ke Hadrian (pelajaran 3).
2. Cara Rome mengeksekusi panggilan (pelajaran 4).
3. Memanggil program Solana (pelajaran 5).
4. Token dan wrapper (pelajaran 6).
5. Jalur dompet Solana (pelajaran 7).
6. Arah sebaliknya: program Solana Anda diakses dari dompet EVM (pelajaran 8).

Pelajaran 10 dan 11 membawa aplikasi ke pengguna nyata dan uang sungguhan. Pelajaran 12 adalah ikhtisar singkat tentang langkah yang lebih besar: blockchain Rome Anda sendiri.

Pelajaran berikutnya, [Apa yang bisa Anda bangun](https://docs.rome.builders/id/rome-academy/02-what-you-can-build.md), menunjukkan kasus penggunaan yang didukung oleh pola ini.

## Kedua jaringan

* **Hadrian** adalah testnet publik. Transaksinya diselesaikan di Solana Devnet, dan USDC-nya adalah USDC uji coba. Bangun semuanya di sini terlebih dahulu.
* **Rubicon** adalah mainnet. Transaksinya diselesaikan di Solana mainnet, dan biaya gasnya dibayar dengan USDC sungguhan.

Keduanya membayar biaya gas dengan USDC. Rubicon menjalankan EVM yang sama, sehingga artefak kontrak yang sama dapat di-deploy ke keduanya. ID chain, URL RPC, dan tautan penjelajah tersedia di [Hadrian](https://docs.rome.builders/id/jaringan/hadrian.md) dan [Rubicon](https://docs.rome.builders/id/jaringan/rubicon.md). Pelajaran akan mengarahkan Anda ke sana agar informasi tersebut tidak perlu diulang.

## Lihat cara kerjanya

Aplikasi Rome menunjukkan penerapan gagasan ini. [Aplikasi di Rome](https://docs.rome.builders/id/aplikasi-di-rome/apps.md) mencantumkan aplikasi-aplikasi tersebut. Ada dua yang patut Anda buka sekarang:

* Rome DEX, satu pool yang menjadi tempat perdagangan bagi dompet EVM maupun Solana.
* Aerarium, pasar pinjam-meminjam yang dapat digunakan kedua jenis pengguna untuk memasok aset dan meminjam.

Buka salah satunya dan lihat layar koneksi dompetnya. Layar itu menawarkan kedua jenis dompet.

## Uji pemahaman Anda

Coba jawab tanpa melihat, lalu buka jawabannya.

1. Di mana kode kontrak disimpan setelah Anda melakukan deployment di Rome?
2. Pengguna Solana dan pengguna MetaMask sama-sama memanggil vault Anda. Apa nilai `msg.sender` yang diterima vault untuk masing-masing pengguna?
3. Jaringan mana yang Anda gunakan untuk membangun terlebih dahulu, dan mengapa?

<details>

<summary>Jawaban</summary>

1. Di akun Solana yang dimiliki oleh program EVM Rome. Kontrak berjalan di dalam runtime Solana.
2. Alamat biasa. Untuk pengguna MetaMask, alamat tersebut adalah alamat EVM mereka. Untuk pengguna Solana, alamat tersebut adalah alamat sintetis yang diturunkan dari kunci Solana mereka.
3. Hadrian. USDC-nya adalah USDC uji coba, jadi kesalahan tidak menimbulkan biaya. Rubicon adalah jaringan produksi dan biaya gasnya dibayar dengan USDC sungguhan.

</details>

## Berikutnya

[2. Apa yang bisa Anda bangun: kasus penggunaan yang penting](https://docs.rome.builders/id/rome-academy/02-what-you-can-build.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/01-what-you-are-building.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.
