> 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/canton-zk-evm/run-it-locally.md).

# Jalankan Ostia Anda sendiri

Jalankan pemeriksaan, uji coba tanpa GPU, demo lokal di GPU, chain yang tetap bertahan setelah restart, dan Ostia pada peserta Canton yang sudah ada.

Secara default, skrip yang disediakan menjalankan jaringan pengujian lokal. Canton menyimpan statusnya dalam memori, sehingga setiap kali dimulai ulang, status tersebut dibuang dan jaringan baru dibuat. Dua mode lain mempertahankan rantai: mode persisten (`CZE_PERSIST=1`) dan Ostia pada participant Canton yang sudah Anda miliki, seperti cara Ostia DevNet berjalan. Demo GPU membuktikan blok. Latihan menggunakan bukti pengganti dan tidak memerlukan GPU.

Halaman ini menjelaskan rilis `v0.1.0`. Baca [panduan jaringan](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/network/README.md) dan [panduan demo](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/demo/README.md)selengkapnya. Jalankan perintah di bawah ini dari direktori root repositori `canton-zk-evm` .

## Yang Anda perlukan

| Pekerjaan                  | Persyaratan                                                                                                                              |
| -------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
| Pemeriksaan repositori     | Docker, `bash`, `curl`, `jq`, `openssl` dan Python 3. Pengujian Rust menggunakan `rust-toolchain.toml`.                                  |
| Pengujian integrasi Canton | Linux x86-64, Java 21, dan akses jaringan.                                                                                               |
| Latihan demo               | Linux x86-64, Docker, Java 21, Rust, dan Python 3.12 atau yang lebih baru.                                                               |
| Pengujian Explorer         | Node 22.18 atau yang lebih baru.                                                                                                         |
| Jaringan dan demo GPU      | Linux x86-64, GPU NVIDIA dengan driver yang terinstal, Docker, Rust, Python 3.12 atau yang lebih baru, `jq`, `curl`, `openssl` dan ZisK. |

File [README repositori](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/README.md#running-the-tests) mencantumkan prasyarat pengujian. Penginstal GPU menggunakan `sudo` dan `apt` di Debian atau Ubuntu dan memerlukan sekitar 100 GB ruang disk kosong. Penginstal ini memasang paket sistem dan mengubah batas penguncian memori. Pengambil alat jaringan memasang Java 21 jika belum tersedia. Lihat [host prover Ostia](https://docs.rome.builders/id/canton-zk-evm/prover-host.md) untuk perangkat keras yang telah diuji; memori GPU minimum belum ditetapkan.

## Jalankan pengujian

Mulai dengan pemeriksaan cepat dari [CONTRIBUTING.md](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/CONTRIBUTING.md#building-and-testing):

```sh
tests/static.sh                  # versi yang dipatok, genesis, dan baris lisensi sesuai
tests/refuses_missing_flag.sh    # peluncuran reth menolak flag yang hilang atau salah
tests/fixtures.sh                # bukti yang direkam konsisten
gateway/build.sh --check         # kode gateway yang tercatat di repositori adalah kode yang dikompilasi menjadi Gateway.sol (Docker)
```

README repositori juga mencantumkan pemeriksaan berikut. Pemeriksaan ini tidak memerlukan GPU:

```sh
tests/udp_control.sh             # pemeriksaan UDP gagal pada kontainer yang memiliki listener UDP (tanpa reth)
tests/discovery.sh               # menjalankan reth yang versinya dipatok, memeriksa bahwa reth tidak memiliki peer, lalu menghentikannya
tests/network_static.sh          # hanya menggunakan reth melalui launch.sh, konfigurasi Canton, dan hasil uji asap yang tercatat
tests/network_checks.sh          # pemeriksaan pin compiler, ID DAR, penghentian pada programVK lain (tanpa GPU)
tests/canton_network.sh          # Canton yang versinya dipatok, paket Daml sungguhan, dan satu Advance (Linux x86-64, Java 21, Python 3; tanpa GPU)
gateway/tests/run.sh             # gateway pada reth sungguhan, dijalankan dengan penemuan peer dinonaktifkan (Docker, curl, jq, Python 3 dengan paket di demo/requirements.txt)
tests/guest-repro.sh             # build guest berjalan di satu folder tetap, sehingga folder sumber tidak mengubah ELF (pengganti untuk alat ZisK; pemeriksaan yang sama pada ZisK sungguhan berhasil pada 2026-10-04, lihat guest/README.md)
tests/demo_static.sh             # pin, sakelar manipulasi, dan penggantian genesis demo, beserta hasilnya yang tercatat (tanpa GPU)
tests/demo_explorer_static.sh    # image explorer dipatok, dan memeriksa apa yang diberikan ke kontainernya (tanpa Docker)
(cd explorer && npm ci && npm test)  # pengujian explorer menggunakan objek tiruan (Node 22.18+; CI menggunakan EXPLORER_NODE_IMAGE di PINS)
(cd guest/rules && cargo test)   # aturan chain dan hashnya (memerlukan Rust)
```

## Simulasikan tanpa GPU

```sh
tests/demo_rehearsal.sh          # demo dan explorer dengan bukti pengganti (Linux x86-64, Docker, Java 21, Rust, Python 3.12+; tanpa GPU)
```

Ini menjalankan reth, Canton, paket Daml, standar token, dan builder yang sesungguhnya. Sidecar memeriksa leg gateway terhadap bukti penyimpanan, sementara komponen pengganti menjawab pemanggilan `verify` untuk bukti tersebut. Simulasi ini tidak membuktikan sebuah blok ataupun memverifikasi bukti zero-knowledge yang sesungguhnya.

Simulasi ini juga memeriksa explorer dan faucet. Pemeriksaan Verify di explorer harus menolak bukti pengganti tersebut. README [demo](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/demo/README.md#the-rehearsal) menjelaskan cakupan simulasi tersebut.

## Jalankan jaringan lokal dengan GPU

Instal ZisK menggunakan `prover/install.sh` sebelum memulai jaringan. Selalu jalankan reth melalui peluncur yang disediakan; `network/up.sh` menggunakannya.

```sh
network/up.sh       # alat, build guest, reth, sidecar, prover, Canton, chain
CZE_SOURCE_COMMIT=$(git rev-parse HEAD) network/smoke.sh    # satu blok kosong, dibuktikan dan dikomit
network/down.sh
```

`up.sh` membangun guest dan menolak kunci program, root ZisK, atau hash aturan yang berbeda dari nilai yang tercatat. Jaringan memiliki satu sinkronisator dan tiga peserta. Peserta operator dan confirmer masing-masing menjalankan sidecar. Peserta bernama users menghosting pihak-pihak pengujian dan reader.

Uji asap mengomit blok kosong, memeriksa head chain dan catatan blok reader, serta memastikan reth menandainya sebagai final. Status dan log disimpan di `state/`, atau di `CZE_STATE_DIR` jika ditetapkan.

## Jalankan lima kasus demo dengan GPU

Gunakan jaringan lokal baru untuk demo:

```sh
demo/prepare.sh
CZE_GENESIS_FILE=$PWD/state/demo/genesis.json network/up.sh
CZE_SOURCE_COMMIT=$(git rev-parse HEAD) network/smoke.sh      # opsional: buat satu blok kosong terlebih dahulu
CZE_SOURCE_COMMIT=$(git rev-parse HEAD) demo/run.sh
network/down.sh
```

Skrip persiapan membuat kunci pengujian dan genesis yang dananya sudah tersedia untuk dijalankan. Demo menjalankan blok penyiapan, deposit, pembayaran, penarikan, penolakan alokasi, dan penolakan bukti yang dimanipulasi. Skrip berhenti jika pemeriksaan gagal dan menulis hasilnya ke `demo/results/`.

Untuk ekspor sumber tanpa `.git`, tetapkan `CZE_SOURCE_COMMIT` ke hash lengkap commit yang digunakan untuk ekspor. Untuk menyertakan faucet, genesis yang sudah didanai harus disiapkan sebelum jaringan dimulai; lihat [Jalankan explorer sendiri](#run-the-explorer-yourself) di bawah ini dan panduan demo lengkap.

## Pertahankan chain saat dimulai ulang

Chain yang digunakan orang harus tetap bertahan setelah crash atau reboot. `up.sh` membuat chain baru setiap kali dijalankan, kecuali Anda meminta mode persisten:

```sh
CZE_PERSIST=1 network/up.sh     # saat pertama dijalankan: chain baru yang dipertahankan
network/down.sh                 # menghentikan semuanya dan mempertahankan datanya
network/restart.sh              # setelah reboot: chain yang sama dijalankan kembali
network/down.sh --wipe          # menghentikan semuanya dan menghapus chain secara permanen
```

Canton menyimpan node-nya di PostgreSQL pada 127.0.0.1, dengan kata sandi yang dibuat di mesin tersebut dalam file berizin 0600. reth menyimpan datanya di `$CZE_STATE_DIR/reth-data` dan menulis setiap blok ke disk saat mengimpornya. `restart.sh` tidak membuat apa pun: skrip ini menjalankan database, reth, sidecar, prover, dan Canton berdasarkan data yang dipertahankan, lalu menyinkronkan reth ke head Canton. Skrip akan berhenti jika database dibuat oleh versi Canton yang berbeda dari versi di `PINS`. Cadangkan database dan `reth-data` secara bersamaan, saat jaringan dihentikan. Panduan [jaringan](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/network/README.md#keeping-the-chain-across-restarts) memuat semua kasus.

## Jalankan pada participant yang sudah ada

Ostia dapat dijalankan pada participant Canton yang sudah ada, seperti validator Splice di Canton Network DevNet, alih-alih di jaringan lokal. Ostia DevNet dijalankan dengan cara ini. `up.sh` kemudian menjalankan reth, prover, dan—jika diminta—satu sidecar, lalu menyiapkan chain pada participant tersebut. Skrip ini tidak menjalankan Canton dan tidak melakukan bootstrap apa pun.

Anda memerlukan:

* Ledger API JSON (v2) milik participant, berupa URL `https` atau URL `http` pada mesin yang sama.
* File token untuk masing-masing dari empat pengguna Ledger API: `ADMIN` (mengunggah paket serta membuat party dan pengguna, sehingga hanya `up.sh` dan `setup.py` yang memerlukannya) serta `OPERATOR`, `CONFIRMER` dan `BUILDER` (pengguna yang dibuat oleh `setup.py` , `ostia-operator`, `ostia-confirmer` dan `ostia-builder`). Setiap token menggunakan HS256 dengan audience `https://canton.network.global` dan ID pengguna sebagai `sub`. Siapa pun yang menjalankan participant akan membuatnya. Ostia tidak pernah membuat, mencetak, atau menyimpan token.
* Sidecar yang dapat dijangkau participant, tetapi tidak dapat dijangkau siapa pun yang lain.

Token berumur pendek, jadi tulis setiap token baru ke file yang sama, menggantikan isinya. Builder membaca ulang filenya pada setiap pemanggilan. `setup.py` dan `propose.py` membaca setiap token satu kali, jadi jalankan keduanya dengan token baru.

Pertama, berikan baris yang diperlukan participant sebagai satu variabel `ADDITIONAL_CONFIG` tambahan pada containernya, lalu mulai ulang:

```sh
network/external/participant-config.sh <sidecar address> 8085
# prints: ADDITIONAL_CONFIG_ZK_EVM=canton.participants.participant.parameters.engine.extensions.canton-zk-evm { address = "<sidecar address>", port = 8085, validate-on-startup = false }
```

Dengan `validate-on-startup` bernilai false, participant tetap dimulai saat sidecar mati; pemeriksaan sebuah blok kemudian gagal dan tidak ada blok yang dikomit. Setelah itu, mulai chain:

```sh
export CZE_CANTON=external CZE_LEDGER_URL=https://<participant's Ledger API>
export CZE_TOKEN_FILE_ADMIN=... CZE_TOKEN_FILE_OPERATOR=... \
       CZE_TOKEN_FILE_CONFIRMER=... CZE_TOKEN_FILE_BUILDER=...
CZE_PERSIST=1 CZE_SIDECAR_LISTEN=<sidecar address>:8085 network/up.sh
```

`CZE_PERSIST=1` diperlukan di sini, karena chain tetap berada di participant dan reth juga harus mempertahankan blok-bloknya. Jika sidecar berjalan di mesin lain, mulai sidecar di sana dengan `network/external/sidecar.sh start <sidecar address>:8085` (alamat yang digunakan participant untuk menjangkaunya, bukan alamat publik), lalu jalankan `up.sh` tanpa `CZE_SIDECAR_LISTEN`. `up.sh` membangun guest, memulai reth dan prover, serta menjalankan `external/setup.py`, yang mengunggah paket, mengalokasikan party, membuat pengguna dengan hak yang hanya sesuai perannya, dan mengusulkan chain. Skrip ini aman dijalankan dua kali. `restart.sh` mengaktifkan kembali chain dan hanya memerlukan token builder. `down.sh --wipe` tidak menyentuh participant: kontrak chain tetap berada di sana sampai operator participant menghapusnya.

Mode ini memiliki tiga aturan:

* **Jangan pernah mengekspos Ledger API.** API ini dapat bertindak sebagai semua party yang di-host participant. Simpan di alamat lokal mesin itu sendiri atau di balik proxy yang memeriksa siapa yang memanggilnya.
* **Atur mode file token ke 0600**, dan jangan simpan di mesin bersama.
* **Operator participant dapat melihat semuanya.** Satu participant meng-host semua party Ostia, sehingga operatornya dapat membaca setiap kontrak dan bertindak atas nama setiap party, termasuk kustodi gateway. Sidecar tunggalnya adalah satu-satunya confirmer. Di Ostia DevNet, operator tersebut adalah Rome: Rome menjalankan participant, validator Canton DevNet miliknya sendiri.

## Jalankan builder terus-menerus

`builder.py once` membuat satu blok. `builder.py run` terus membuat blok:

```sh
python3 builder/builder.py run [--heartbeat-seconds N] [--status-file <path>]
```

Perintah ini membaca [pengaturan](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/builder/README.md#settings) yang sama dengan `once` . Dengan strategi default, `on_demand`, blok dipotong setiap kali ada transaksi yang dapat dimasukkan sedang menunggu, dengan satu blok yang sedang diproses pada satu waktu secara default (`--max-in-flight` menaikkan batasnya). Chain yang sepi tidak membuat blok kecuali `--heartbeat-seconds N` meminta blok kosong setelah N detik tanpa blok; secara default, heartbeat dinonaktifkan. Setelah dua blok berturut-turut ditolak, builder mencurigai adanya transaksi bermasalah dan tidak menyertakannya untuk sementara.

Hanya satu builder yang berjalan pada satu waktu; `run` dan `once` mengunci proses dan menolak untuk memulai jika kunci sedang dipegang proses lain. Sinyal penghentian akan menyelesaikan blok yang sedang diproses lalu keluar. Jalankan builder di bawah pengelola layanan yang memulainya kembali, dengan batas waktu penghentian yang lebih lama daripada waktu yang diperlukan untuk proof dan respons Canton secara keseluruhan. Memulai ulang aman kapan saja: saat dimulai kembali, proses akan kembali ke head Canton dan mengirim ulang transaksi dari blok yang terpotong ke reth. Builder menulis `status.json` dan jurnal di folder kerjanya, dan explorer membaca keduanya.

## Jalankan explorer sendiri

Explorer berjalan sebagai kontainer di samping chain yang ditampilkannya, pada mesin Linux dengan Docker. Explorer memiliki PostgreSQL sendiri, yang dimulai oleh `network/explorer-db.sh`, lalu diisi oleh indexer dari catatan Canton. Pendanaan faucet harus ada di genesis sebelum jaringan dimulai, jadi `setup` harus dijalankan terlebih dahulu:

```sh
explorer/run.sh setup           # membuat kunci faucet dan genesis yang sudah didanai
CZE_GENESIS_FILE=state/faucet/genesis.json network/up.sh
explorer/run.sh start           # lalu buka http://127.0.0.1:8088
explorer/run.sh stop
```

`start` memulai database, menerapkan migrasi, dan memulai indexer sebagai kontainer tersendiri, lalu memulai explorer. Jika tidak ada kunci faucet, faucet dinonaktifkan. Pencairan faucet adalah transaksi ke reth, sehingga baru menjadi final saat builder berjalan. Memulai jaringan atau explorer tidak akan memulai builder. Jalankan builder sekali sebelum `explorer/run.sh start`, atau jalankan `start` kembali setelah builder pertama kali dijalankan; sampai saat itu explorer belum memiliki folder kerja builder dan siklus hidup blok akan tetap kosong. Pada jaringan yang dibuat tanpa `CZE_PERSIST`, `stop` juga menghapus database explorer, termasuk permintaan faucet dan sumber kontrak yang telah diverifikasi. Jaringan persisten akan mempertahankannya.

Secara default, `explorer/run.sh start` menonaktifkan verifikasi kontrak kecuali Anda menetapkan `EXPLORER_VERIFIER=1` (beserta `SOLC_LIST_URL`), serta tidak menyediakan `/rpc` dan tidak menyediakan pemanggilan Read kontrak kecuali Anda menetapkan `PUBLIC_RPC=1`. Pengaturan ini tercantum di bagian header [explorer/run.sh](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/explorer/run.sh).

Pada jaringan lokal yang disediakan, Ledger API tidak memerlukan login. Explorer hanya membaca sebagai pihak reader, tetapi siapa pun yang dapat mengakses participant tersebut juga dapat membaca data pihak-pihak lainnya. Karena itu, jangan pernah memberikan alamat publik kepada kontainer di sana. Pada participant yang sudah ada, berikan kepada explorer file token dengan mode 0600 untuk pengguna reader (`LEDGER_TOKEN_FILE`), `LEDGER_URL` milik participant `dan READER_PARTY`. Kontainer tetap mendengarkan di 127.0.0.1; alamat publik memerlukan proksi milik Anda sendiri. Panduan [penjelajah](https://github.com/rome-protocol/canton-zk-evm/blob/main/explorer/README.md#running-it) memuat semua pengaturan.

## Jalankan dengan campuran realistis

`load/mixed` memuat perangkat yang digunakan dalam pengujian selama satu jam di [Pengukuran](https://docs.rome.builders/id/canton-zk-evm/measurements.md). Perangkat ini menerapkan beberapa jenis token, DEX, token berizin, dan kontrak transfer privat pada sebuah rantai, lalu mengirimkan lalu lintas campuran dari 200 dompet. File [README](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/load/mixed/README.md) memuat langkah-langkahnya. Anda memerlukan Docker dan akun yang memiliki sekitar 12.000 tROME dengan konfigurasi perangkat sebagaimana disediakan. Di rantai Anda sendiri, danai akun tersebut di genesis. Faucet DevNet tidak dapat menyediakan sebanyak itu.


---

# 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/canton-zk-evm/run-it-locally.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.
