> 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/memulai/ecosystem.md).

# Ekosistem & repos

Setiap repo Rome publik, apa fungsinya, dan bagaimana semuanya tersusun — peta untuk menavigasi permukaannya.

Permukaan publik Rome adalah sekumpulan repositori: beberapa **fondasi** paket yang menjadi landasan Anda, sebuah scaffolder, aplikasi referensi untuk dipelajari, dan dua layanan yang dipanggil aplikasi Anda. Halaman ini adalah peta — apa itu setiap repo dan bagaimana semuanya saling cocok.

Dua tetangga menjawab pertanyaan yang berbeda, dan halaman ini menautkan keduanya alih-alih mengulangnya:

* [Arsitektur](/id/memulai/architecture.md) menjelaskan **protokol** — bagaimana EVM berjalan di dalam program Solana.
* Setiap repo menyertakan **`AGENTS.md`** (mis. [rome-sdk-ts/AGENTS.md](https://github.com/rome-protocol/rome-sdk-ts/blob/main/AGENTS.md)) yang mengarahkan berdasarkan **apa yang Anda mulai dari** (kontrak Solidity, program Solana, greenfield, dari-rumah) ke satu contoh yang paling dekat dengan kasus Anda.

Halaman ini adalah level di antara: **seluruh permukaan** dan bagaimana bagian-bagiannya terhubung.

## Permukaan sekilas

### Fondasi — bangun di atas ini

| Repo                                                            | Apa itu                                                                                                                                                                | Gunakan saat                                                      |
| --------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------- |
| [rome-registry](https://github.com/rome-protocol/rome-registry) | `@rome-protocol/registry` — proyeksi fakta chain hidup yang hanya-baca dan dihasilkan (id, RPC, alamat, mint token, program id, feed oracle, ALT).                     | Anda membutuhkan fakta chain yang nyata — jangan pernah hardcode. |
| [rome-sdk-ts](https://github.com/rome-protocol/rome-sdk-ts)     | `@rome-protocol/sdk` — jalur tulis TypeScript: `submitRomeTx` + penentuan ukuran fee, kedua jalur, encoder PDA/ATA + CPI, binding precompile, sebuah `/bridge` client. | Anda menulis kode aplikasi atau frontend.                         |
| [rome-solidity](https://github.com/rome-protocol/rome-solidity) | interface precompile Solidity, wrapper SPL/ERC-20, dan adapter oracle — toolkit sisi kontrak.                                                                          | Anda menulis kontrak.                                             |

Nama `@rome-protocol/…` di atas adalah nama paket, tetapi paket-paket tersebut tidak dipublikasikan ke npm. Instal dari GitHub (perintahnya ada di setiap bagian di bawah [Lapisan fondasi, lebih dekat](#the-foundation-layer-up-close)); path impor dalam kode Anda tetap sama.

### Rome ZK EVM rollups

| Repo                                                            | Apa itu                                                    | Gunakan saat                                              |
| --------------------------------------------------------------- | ---------------------------------------------------------- | --------------------------------------------------------- |
| [solana-zk-evm](https://github.com/rome-protocol/solana-zk-evm) | Program ZK rollup, node, prover, dan dokumentasi operator. | Anda menjalankan chain EVM yang settlement-nya di Solana. |
| [rome-zk-guest](https://github.com/rome-protocol/rome-zk-guest) | Source guest batch yang dibangun untuk genesis tiap chain. | Anda membangun guest dan meminta verification key-nya.    |

### Canton ZK EVM

| Repo                                                                                                                    | Apa itu                                                                                                                            | Gunakan saat                                                                                                                               |
| ----------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
| [canton-zk-evm](https://github.com/rome-protocol/canton-zk-evm/blob/a84e84e439a5cc669c0ae61facf7c8c995d9d564/README.md) | Ostia, rilis awal Canton zkEVM yang melakukan settlement atas blok EVM yang telah dibuktikan dan aksi Canton dalam satu transaksi. | Anda menjalankan demo lokal atau mempelajari gateway dan pemeriksaan proof-nya. Lihat [Canton ZK EVM](/id/canton-zk-evm/canton-zk-evm.md). |

### Aplikasi referensi — belajar lewat contoh

| Repo                                                                    | Apa itu                                                                                             | Gunakan saat                                                 |
| ----------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------- | ------------------------------------------------------------ |
| [rome-dex](https://github.com/rome-protocol/rome-dex)                   | AMM dua jalur — pool native Solana dengan router EVM tipis.                                         | Membuka jalur yang lain; sebuah **native-core** contoh.      |
| [aerarium](https://github.com/rome-protocol/aerarium)                   | Peminjaman dua jalur — inti Comet Solidity yang dijangkau pengguna Solana melalui synthetic sender. | Membuka jalur yang lain; sebuah **Solidity-core** contoh.    |
| [cardo](https://github.com/rome-protocol/cardo)                         | Pengguna EVM yang menjalankan dApp Solana (swap/stake/lend/perps) melalui CPI.                      | Sebuah aplikasi CPI-ke-Solana yang lengkap untuk dipelajari. |
| [appia](https://github.com/rome-protocol/appia)                         | DeFi lintas-VM yang berfokus pada posisi; pengguna mengaksesnya dari chain asal mereka.             | Sebuah **dari-rumah** aplikasi.                              |
| [rome-aave-v3-demo](https://github.com/rome-protocol/rome-aave-v3-demo) | Supply/borrow/repay Aave v3, dideploy tanpa perubahan.                                              | Aplikasi EVM penuh yang berjalan apa adanya.                 |

### Fork kontrak — protokol yang dikenal, dideploy di Rome

| Repo                                                                              | Apa itu                          | Gunakan saat                            |
| --------------------------------------------------------------------------------- | -------------------------------- | --------------------------------------- |
| [compound-on-rome-comet](https://github.com/rome-protocol/compound-on-rome-comet) | Pasar uang Compound III (Comet). | Membuat fork protokol EVM yang dikenal. |
| [rome-aave-v3](https://github.com/rome-protocol/rome-aave-v3)                     | Fork kontrak Aave v3.            | Membuat fork protokol EVM yang dikenal. |

### Layanan — aplikasi Anda memanggil ini

| Repo                                                                        | Apa itu                                                                                               | Gunakan saat                                   |
| --------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------- | ---------------------------------------------- |
| [rome-bridge-api](https://github.com/rome-protocol/rome-bridge-api)         | Orkestrator off-chain + sponsor fee untuk bridge on-chain. Tidak menyimpan kunci apa pun.             | Pendanaan sebuah wallet, atau alur dari-rumah. |
| [rome-oracle-gateway](https://github.com/rome-protocol/rome-oracle-gateway) | Feed harga Solana (Pyth, Switchboard) yang diekspos ke EVM melalui Chainlink `AggregatorV3Interface`. | Anda membutuhkan feed harga.                   |

### Scaffold — mulai di sini

| Repo                                                                | Apa itu                                                                                                                                                               | Gunakan saat           |
| ------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------- |
| [create-rome-app](https://github.com/rome-protocol/create-rome-app) | `npx github:rome-protocol/create-rome-app` — membuat scaffold aplikasi dua jalur yang sudah terhubung ke registry + SDK, dengan pemeriksaan kedua jalur yang didanai. | Memulai aplikasi baru. |

## Bagaimana semuanya tersusun

```mermaid
flowchart TD
    REG["rome-registry — fakta chain hidup"]
    SDK["rome-sdk-ts — tulis, CPI, client bridge"]
    SOL["rome-solidity — interface precompile, wrapper SPL, adapter oracle"]
    CRA["create-rome-app — scaffolder"]
    APP["aplikasi Anda — frontend + kontrak"]
    BAPI["rome-bridge-api — orkestrator off-chain, tidak menyimpan kunci apa pun"]
    OG["rome-oracle-gateway — feed harga Solana"]

    CRA -->|men-scaffold, sudah terhubung| APP
    REG -->|fakta, tidak pernah di-hardcode| APP
    SDK -->|jalur tulis & CPI| APP
    SOL -->|diimpor oleh kontrak Anda| APP
    APP -->|SDK / client bridge| BAPI
    APP -->|membaca via AggregatorV3Interface| OG
    OG -.->|adapter ada di| SOL
    CRA -.->|menghubungkan| REG
    CRA -.->|menghubungkan| SDK
```

Tulang punggungnya adalah tiga fondasi dan sebuah scaffolder:

* [**rome-registry**](https://github.com/rome-protocol/rome-registry) adalah sumber tunggal fakta hidup. [**rome-sdk-ts**](https://github.com/rome-protocol/rome-sdk-ts) adalah jalur tulis — dan `/bridge` subpath-nya adalah client yang dipakai aplikasi Anda untuk berbicara ke `rome-bridge-api`. [**rome-solidity**](https://github.com/rome-protocol/rome-solidity) adalah apa yang diimpor kontrak Anda (dan fork); adapter oracle yang `rome-oracle-gateway` juga dideploy di sana. Ketiganya independen satu sama lain — pilih yang dibutuhkan aplikasi Anda.
* [**create-rome-app**](https://github.com/rome-protocol/create-rome-app) mengikat dua yang pertama bersama untuk aplikasi baru, sehingga proyek baru langsung membaca registry dan menulis melalui SDK.

Aplikasi referensi adalah pengecualian yang patut diketahui: **mereka mendahului paket-paket yang diekstrak.** cardo memakai paket registry; appia memproyeksikan registry ke JSON statis saat build time; dan keduanya memaketkan jalur tulis mereka sendiri alih-alih mengimpor SDK. Baca mereka untuk mempelajari polanya — tetapi sebuah **baru** aplikasi sebaiknya mulai dari `create-rome-app` + paket-paketnya, bukan dengan meng-clone sebuah aplikasi.

## Navigasi berdasarkan apa yang Anda butuhkan

* **Fakta chain hidup** (id, address, mint, program id) → [rome-registry](https://github.com/rome-protocol/rome-registry). Jangan hardcode.
* **Menulis kode aplikasi** (sebuah write, sebuah panggilan CPI, sebuah bridge) → [rome-sdk-ts](https://github.com/rome-protocol/rome-sdk-ts); referensi di [Rome SDK](/id/produk/rome-sdk.md).
* **Menulis kontrak** → [rome-solidity](https://github.com/rome-protocol/rome-solidity); lihat [Deploy Solidity Contracts](/id/panduan-pengembang/deploy-solidity.md).
* **Memanggil program Solana dari kontrak Solidity** → precompile CPI di [rome-solidity](https://github.com/rome-protocol/rome-solidity) (`interface.sol`); [cardo](https://github.com/rome-protocol/cardo) adalah contoh yang lengkap.
* **Contoh yang berfungsi** dari aplikasi AMM, lending, CPI, atau dari-rumah → aplikasi referensi di atas; masing-masing repo `AGENTS.md` mengarah berdasarkan titik awal.
* **Men-scaffold aplikasi baru** → [create-rome-app](https://github.com/rome-protocol/create-rome-app).
* **Feed harga** → [rome-oracle-gateway](https://github.com/rome-protocol/rome-oracle-gateway) (lihat [portal Oracle Gateway](/id/aplikasi-di-rome/oracle-gateway.md)).
* **Pengguna di chain lain** → [Dari rumah](/id/panduan-pengembang/from-home.md) + [rome-bridge-api](https://github.com/rome-protocol/rome-bridge-api).
* **Menentukan sisi mana yang menyimpan logika Anda** → [Pilih inti Anda](/id/konsep-inti/choose-your-core.md).

## Lapisan fondasi, lebih dekat

### rome-registry — fakta hidup, publik sejak desain

Registry ini **dihasilkan** dari sumber internal Rome: sebuah allowlist hanya mengeluarkan apa yang memang dimaksudkan untuk publik, **mengganti** endpoint internal dengan padanan publiknya, dan **default-denies** semuanya yang lain — jadi aman-publik sejak desain. Per chain, ia menerbitkan `chain.json` / `tokens.json` / `contracts.json` / `oracle.json` / `bridge.json` / `alts.json`serta Solana `program` dan deployment aplikasi per-protokol.

Instal dari GitHub, dipin ke tag rilis: `npm install github:rome-protocol/rome-registry#v0.2.0`. Anda membacanya melalui getter — `getChain`, `getTokens`, `getContracts`, `getOracle`, `getBridge`, `getAlts`, dan `getPrograms(network)` (program id dikunci berdasarkan network, bukan chain id). Paket ini adalah ESM biasa (belum ada tipe TypeScript ter-bundel saat ini).

Dua hal yang perlu diketahui sebelum menghubungkannya:

* **`getTokens()` tidak mengembalikan `assetRef`.** Untuk menemukan wrapper sebuah token, cocokkan pada **mint** (`mintId`) — mis. wrapper token gas adalah entri yang berbagi mint-nya.
* **Ini membaca JSON dari disk (`node:fs`) — ini tidak aman untuk browser.** Dalam aplikasi web, proyeksikan nilai yang Anda perlukan ke file JSON statis saat build time dan impor itu di client. (Inilah tepatnya yang dilakukan `create-rome-app` dan appia.)

Alamat kontrak dikembalikan sebagai daftar versi per kontrak; pilih yang statusnya `status` adalah `live`. [Membaca daftar kontrak](/id/referensi/contract-addresses.md#reading-the-contracts-list) menunjukkan caranya. Fakta yang tidak dibaca aplikasi Anda secara langsung juga muncul di referensi [Contract Addresses](/id/referensi/contract-addresses.md) .

### rome-sdk-ts — jalur tulis, kedua jalur

Instal dari GitHub: `npm install github:rome-protocol/rome-sdk-ts#v0.4.0`.

`@rome-protocol/sdk` (v0.4.0) membungkus semua yang dibutuhkan sebuah write Rome sehingga Anda tidak perlu merakit calldata atau fee secara manual:

* **`submitRomeTx`** — jalur tulis lane EVM: mengukur gas dari `eth_estimateGas` (dipadding, dengan batas cadangan saat estimasi gagal) dan menyediakan fee EIP-1559.
* **`submitRomeTxV1`** — hal yang sama, untuk **wallet Solana** yang menjalankan aplikasi EVM Anda: satu transaksi Solana v1 per panggilan, dua prompt wallet. Synthetic sender tidak menyimpan apa pun saat tidak aktif; `buildFundLeg`/`buildSweepLeg` memindahkan nilai masuk dan keluar sebagai ERC-20 (`wUSDC`), **bukan** native `msg.value`; instruksi Solana biasa di sekitar sebuah panggilan (fund leg, pembuatan token-account wallet sebelum sweep) lewat `submitSolanaInstructionsV1` sebagai transaksi v1 juga. `submitRomeTxSolanaLane` adalah jalur yang lebih awal, yang membangun transaksi Solana legacy di client dan otomatis menyiapkan synthetic baru (`create_pda`) pada penggunaan pertama.
* **Derivasi PDA/ATA, CPI `invoke`/`invoke_signed` encoder, binding precompile**, dan sebuah **`/bridge`** subpath (`@rome-protocol/sdk/bridge`) — client bridge quote-first.

API lengkap + contoh: [Rome SDK](/id/produk/rome-sdk.md), dan panduannya [Call Solana from EVM](/id/panduan-pengembang/call-solana-from-evm.md), [Call EVM from Solana](/id/panduan-pengembang/call-evm-from-solana.md), dan [Build a dual-lane app](/id/panduan-pengembang/dual-lane-app.md).

### rome-solidity — toolkit sisi kontrak

Instal dari GitHub, bukan npm. Dengan npm atau Hardhat: `npm install github:rome-protocol/rome-solidity`. Dengan Foundry: `forge install rome-protocol/rome-solidity`, lalu tambahkan remapping `@rome-protocol/rome-solidity/=lib/rome-solidity/` ke `foundry.toml` (di bawah `[profile.default]`, sebagai `remappings = [...]`), sehingga `@rome-protocol/rome-solidity/contracts/interface.sol` ter-resolve. Nama paket di `package.json` adalah `@rome-protocol/rome-solidity`, jadi path impor yang sama bekerja untuk keduanya.

Yang diimpor kontrak Anda:

* **`contracts/interface.sol`** — interface precompile yang terikat ke alamatnya: **CPI** `ICrossProgramInvocation` (`0xFF…08`), **Helper** `IHelperProgram` (`0xFF…09`, pembuatan ATA/PDA, transfer SPL, gas↔lamports), **Withdraw** `IWithdraw` (`0x42…16`), dan **System** (`0xFF…07`). Sebuah keluarga yang dioptimalkan gas **cached** juga ada di sini; sebuah kontrak memakai satu jalur secara konsisten. Tabel alamat lengkap: [Contract Addresses](/id/referensi/contract-addresses.md).
* **Wrapper SPL/ERC-20** — `SPL_ERC20` (berbasis CPI) dan `SPL_ERC20_cached` (jalur cached, dipakai di devnet); setiap mint SPL sudah menjadi ERC-20 melalui ini.
* **Adapter oracle** (`contracts/oracle/`) — adapter Pyth/Switchboard `rome-oracle-gateway` dideploy, dibaca melalui `IAggregatorV3Interface`.
* Contoh yang lengkap di `contracts/examples/`.

Bagian Solidity SDK dari [Rome SDK](/id/produk/rome-sdk.md) menunjukkan pola impor dan binding precompile dalam kode.

## Berikutnya

* [Pilih inti Anda](/id/konsep-inti/choose-your-core.md) — sisi mana yang menyimpan logika Anda.
* [Quickstart](/id/memulai/quickstart.md) — deploy kontrak pertama Anda.
* [create-rome-app](https://github.com/rome-protocol/create-rome-app) — scaffolding aplikasi dua jalur.
* Setiap repo `AGENTS.md` — rute berdasarkan titik awal ke contoh terdekat.


---

# 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/memulai/ecosystem.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.