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

# Kendi Ostia'nızı çalıştırın

Kontrolleri, GPU olmadan yapılan provayı, GPU üzerinde yerel demoyu, yeniden başlatmalardan sağ çıkan bir zinciri ve mevcut bir Canton katılımcısı üzerindeki Ostia’yı çalıştırın.

Varsayılan olarak sağlanan betikler yerel bir test ağı çalıştırır. Canton durumunu bellekte tutar; bu nedenle her yeniden başlatma durumu siler ve yeni bir ağ oluşturur. Diğer iki mod zinciri korur: kalıcı mod (`CZE_PERSIST=1`) ve zaten sahip olduğunuz bir Canton katılımcısı üzerinde Ostia; Ostia DevNet bu şekilde çalışır. GPU demosu blokları kanıtlar. Prova, temsili bir kanıt kullanır ve GPU gerektirmez.

Bu sayfada şu sürüm açıklanmaktadır: `v0.1.0`. Kılavuzun tamamını okuyun: [ağ kılavuzu](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/network/README.md) ve [demo kılavuzu](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/demo/README.md). Aşağıdaki komutları şu dizinin kökünden çalıştırın: `canton-zk-evm` deposu.

## Gerekenler

| Çalışma                     | Gereksinimler                                                                                                           |
| --------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
| Depo kontrolleri            | Docker, `bash`, `curl`, `jq`, `openssl` ve Python 3. Rust testleri şu dosyayı kullanır: `rust-toolchain.toml`.          |
| Canton entegrasyon testleri | Linux x86-64, Java 21 ve ağ erişimi.                                                                                    |
| Demo provası                | Linux x86-64, Docker, Java 21, Rust ve Python 3.12 veya üzeri.                                                          |
| Gezgin testleri             | Node 22.18 veya üzeri.                                                                                                  |
| GPU ağı ve demo             | Linux x86-64, sürücüsü yüklenmiş bir NVIDIA GPU, Docker, Rust, Python 3.12 veya üzeri, `jq`, `curl`, `openssl` ve ZisK. |

Test önkoşulları [depo README dosyasında](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/README.md#running-the-tests) listelenmiştir. GPU yükleyicisi şunları kullanır: `sudo` ve `apt` Debian veya Ubuntu'da çalışır ve yaklaşık 100 GB boş disk alanına ihtiyaç duyar. Sistem paketlerini yükler ve bellek kilitleme sınırlarını değiştirir. Ağın araç indiricisi, yüklü değilse Java 21'i yükler. Test edilen donanım için bkz. [Ostia kanıtlayıcı ana makinesi](https://docs.rome.builders/tr/canton-zk-evm/prover-host.md) ; gereken en düşük GPU belleği henüz belirlenmemiştir.

## Testleri çalıştırın

Önce şu dosyadaki hızlı kontrolleri çalıştırın: [CONTRIBUTING.md](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/CONTRIBUTING.md#building-and-testing):

```sh
tests/static.sh                  # pinler, genesis ve lisans satırları birbiriyle uyumlu
tests/refuses_missing_flag.sh    # reth başlatması eksik veya yanlış bir bayrağı reddeder
tests/fixtures.sh                # kaydedilmiş kanıt tutarlıdır
gateway/build.sh --check         # depodaki gateway kodu, Gateway.sol dosyasının derlediği kodla aynıdır (Docker)
```

Depodaki README dosyasında bu kontroller de yer alıyor. GPU gerektirmezler:

```sh
tests/udp_control.sh             # UDP dinleyicisi olan bir kapsayıcıda UDP kontrolü başarısız olur (reth gerekmez)
tests/discovery.sh               # sabitlenmiş reth'i başlatır, eşinin olmadığını kontrol eder ve durdurur
tests/network_static.sh          # reth yalnızca launch.sh üzerinden; Canton yapılandırması ve kaydedilmiş smoke testi sonucu
tests/network_checks.sh          # derleyici sabitleme kontrolü, DAR kimliği, başka bir programVK üzerinde durdurma (GPU gerekmez)
tests/canton_network.sh          # sabitlenmiş Canton, gerçek Daml paketi ve bir Advance (Linux x86-64, Java 21, Python 3; GPU gerekmez)
gateway/tests/run.sh             # eş keşfi kapalı olarak başlatılan, gerçek bir reth üzerindeki gateway (Docker, curl, jq, demo/requirements.txt içindeki paketlerle Python 3)
tests/guest-repro.sh             # guest derlemesi sabit bir klasörde çalışır; bu nedenle kaynak klasör ELF'yi değiştirmez (ZisK araçlarının yerine kullanılan araçlar; gerçek ZisK ile aynı kontrol 2026-10-04 tarihinde başarıyla geçti, bkz. guest/README.md)
tests/demo_static.sh             # demonun sabitlemeleri, kurcalama anahtarı ve genesis geçersiz kılması ile kaydedilmiş sonuçları (GPU gerekmez)
tests/demo_explorer_static.sh    # explorer imajları sabitlenmiştir ve kapsayıcısına verilenler (Docker gerekmez)
(cd explorer && npm ci && npm test)  # explorer testleri, sahteler kullanılarak (Node 22.18+; CI, PINS içindeki EXPLORER_NODE_IMAGE değerini kullanır)
(cd guest/rules && cargo test)   # zincir kuralları ve bunların karması (Rust gerekir)
```

## GPU olmadan prova yapın

```sh
tests/demo_rehearsal.sh          # demo ve explorer, yerine kullanılan bir kanıtla (Linux x86-64, Docker, Java 21, Rust, Python 3.12+; GPU gerekmez)
```

Bu işlem gerçek reth'i, Canton'u, Daml paketini, token standardını ve oluşturucuyu çalıştırır. Sidecar, gateway'in adımlarını depolama kanıtlarıyla denetlerken, yerine kullanılan bir bileşen kanıtın `verify` çağrısını yanıtlar. Prova ne bir bloğu kanıtlar ne de gerçek bir sıfır bilgi kanıtını doğrular.

Ayrıca explorer'ı ve faucet'i de kontrol eder. Explorer'ın Verify kontrolü, yerine kullanılan kanıtı reddetmelidir.  [demo README dosyası](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/demo/README.md#the-rehearsal) provanın kapsamını açıklar.

## GPU ile yerel ağı başlatın

Ağı başlatmadan önce ZisK'yi şu komutla yükleyin: `prover/install.sh` Ağı başlatırken daima sağlanan başlatıcı üzerinden reth'i çalıştırın; `network/up.sh` bu başlatıcıyı kullanır.

```sh
network/up.sh       # araçlar, guest derlemesi, reth, sidecar'lar, prover, Canton, zincir
CZE_SOURCE_COMMIT=$(git rev-parse HEAD) network/smoke.sh    # kanıtlanıp işlenen bir boş blok
network/down.sh
```

`up.sh` guest'i derler ve kaydedilmiş değerlerden farklı bir program anahtarı, ZisK kökü veya kurallar karması kullanmayı reddeder. Ağda bir senkronizatör ve üç katılımcı bulunur. Operatör ve onaylayıcı katılımcıların her biri bir sidecar çalıştırır. users adlı katılımcı, test taraflarını ve okuyucuyu barındırır.

Smoke testi boş bir bloğu işler; zincirin baş bloğunu ve okuyucunun blok kaydını kontrol eder, ayrıca reth'in bloğu kesinleşmiş olarak işaretlediğini doğrular. Durum ve günlükler `state/`dizinine, `CZE_STATE_DIR` ayarlanmışsa oraya yazılır.

## Beş demo senaryosunu GPU ile çalıştırın

Demo için yeni bir yerel ağ kullanın:

```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      # isteğe bağlı: önce bir boş blok
CZE_SOURCE_COMMIT=$(git rev-parse HEAD) demo/run.sh
network/down.sh
```

Hazırlık betiği, çalıştırma için test anahtarları ve bakiyesi yüklenmiş bir genesis oluşturur. Demo; kurulum bloğunu, yatırma işlemini, ödemeyi, çekimi, tahsis reddini ve kurcalanmış kanıtın reddini çalıştırır. Bir kontrol başarısız olursa betik durur ve sonuçlarını `demo/results/`.

.git olmadan kaynak dışa aktarımı için `.git`ayarlayın: `CZE_SOURCE_COMMIT` değerini dışa aktarımda kullanılan commit'in tam karmasına ayarlayın. Faucet'i de dahil etmek için, bakiyesi yüklenmiş genesis ağ başlamadan önce hazırlanmalıdır; bkz. [Gezgini kendiniz çalıştırın](#run-the-explorer-yourself) aşağıda ve demo kılavuzunun tamamında.

## Yeniden başlatmalarda zinciri koruyun

Kullanılan bir zincir, çökme veya yeniden başlatma durumunda da çalışmaya devam etmelidir. `up.sh` kalıcı modu istemediğiniz sürece her çalıştırmada yeni bir zincir oluşturur:

```sh
CZE_PERSIST=1 network/up.sh     # ilk başlatma: saklanacak yeni bir zincir
network/down.sh                 # her şeyi durdurur ve verileri saklar
network/restart.sh              # yeniden başlatmanın ardından: aynı zincir yeniden çalışır
network/down.sh --wipe          # her şeyi durdurur ve zinciri kalıcı olarak siler
```

Canton, düğümlerini 127.0.0.1 adresindeki PostgreSQL'de tutar; parola makinede oluşturularak izinleri 0600 olan bir dosyaya yazılır. reth verilerini şurada tutar: `$CZE_STATE_DIR/reth-data` ve içe aktardığı her bloğu diske yazar. `restart.sh` hiçbir şey oluşturmaz: veritabanını, reth'i, yan bileşenleri, prover'ı ve Canton'u saklanan veriler üzerinden başlatır ve reth'i Canton'un son bloğuna getirir. Veritabanları, şu dosyadaki Canton sürümünden farklı bir sürümle oluşturulmuşsa çalışmayı durdurur: `PINS`. Veritabanlarını ve `reth-data` ağ durdurulmuşken birlikte yedekleyin. [Ağ kılavuzunda](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/network/README.md#keeping-the-chain-across-restarts) tüm senaryolar açıklanmıştır.

## Mevcut bir katılımcıda çalıştırma

Ostia, yerel ağda çalışmak yerine hâlihazırda çalışan bir Canton katılımcısında (örneğin Canton Network DevNet'teki bir Splice doğrulayıcısında) çalışabilir. Ostia DevNet bu şekilde çalışır. `up.sh` daha sonra reth'i, prover'ı ve isterseniz bir yan bileşeni başlatır ve zinciri bu katılımcıda kurar. Canton başlatmaz ve önyükleme yapmaz.

Gerekenler:

* Katılımcının JSON Ledger API'si (v2); bu API'ye bir `https` URL'si veya aynı makinede bulunan bir `http` URL'si üzerinden erişilebilir olmalıdır.
* Dört Ledger API kullanıcısının her biri için bir belirteç dosyası: `ADMIN` (paketi yükler, tarafları ve kullanıcıları oluşturur; bu nedenle yalnızca `up.sh` ve `setup.py` bu belirtece ihtiyaç duyar) ve `OPERATOR`, `CONFIRMER` ve `BUILDER` (oluşturduğu kullanıcılar: `setup.py` , `ostia-operator`, `ostia-confirmer` ve `ostia-builder`). Her belirteç HS256 kullanır; audience değeri `https://canton.network.global` , kullanıcının kimliği ise `sub`. Bunları katılımcıyı işleten kişi oluşturur. Ostia hiçbir zaman token oluşturmaz, yazdırmaz veya saklamaz.
* Katılımcının erişebileceği ve başka hiç kimsenin erişemeyeceği bir sidecar.

Token'lar kısa ömürlüdür; bu nedenle her yeni token'ı aynı dosyanın üzerine yazın. Builder her çağrıda dosyasını yeniden okur. `setup.py` ve `propose.py` her token'ı bir kez okur, bu yüzden bunları yeni token'larla başlatın.

Önce katılımcıya ihtiyaç duyduğu satırı, konteynerinin bir başka `ADDITIONAL_CONFIG` değişkeni olarak verin ve katılımcıyı yeniden başlatın:

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

Eğer `validate-on-startup` false ise sidecar çalışmadığında da katılımcı başlar; ancak bu durumda blok kontrolü başarısız olur ve hiçbir blok işlenmez. Ardından zinciri başlatın:

```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` burada gereklidir, çünkü zincir katılımcıda kalır ve reth'in de bloklarını koruması gerekir. Sidecar başka bir makinede çalışıyorsa onu orada şu komutla başlatın: `network/external/sidecar.sh start <sidecar address>:8085` (adres, herkese açık bir adres değil, katılımcının sidecar'a eriştiği adres olmalıdır) ve `up.sh` komutunu şu değişken olmadan çalıştırın: `CZE_SIDECAR_LISTEN`. `up.sh` guest'i derler, reth'i ve prover'ı başlatır ve şu komutu çalıştırır: `external/setup.py`. Bu komut paketi yükler, tarafları tahsis eder, kullanıcıları yalnızca rollerinin haklarıyla oluşturur ve zinciri önerir. İki kez çalıştırılmasında sakınca yoktur. `restart.sh` zinciri yeniden başlatır ve yalnızca builder'ın token'ına ihtiyaç duyar. `down.sh --wipe` katılımcıya dokunmaz: zincirin sözleşmeleri, operatörü bunları kaldırana kadar orada kalır.

Bu mod için üç kural geçerlidir:

* **Ledger API'yi asla dış erişime açmayın.** API, katılımcının barındırdığı her taraf adına işlem yapabilir. API'yi makinenin kendi adresinde veya çağıranları denetleyen bir proxy'nin arkasında tutun.
* **Token dosyalarını 0600 izinleriyle tutun** ve paylaşılan makinelerde bulundurmayın.
* **Katılımcının operatörü her şeyi görür.** Tek bir katılımcı tüm Ostia taraflarını barındırır; dolayısıyla operatör her sözleşmeyi okuyabilir ve gateway'in saklama işlemleri dahil her taraf adına işlem yapabilir. Bu katılımcının tek sidecar'ı, tek onaylayıcıdır. Ostia DevNet'te bu operatör Rome'dur: katılımcıyı, yani kendi Canton DevNet doğrulayıcısını çalıştırır.

## Builder'ı sürekli çalıştırın

`builder.py once` bir blok oluşturur. `builder.py run` ise blok oluşturmaya devam eder:

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

Aynı [ayarları](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/builder/README.md#settings) şu komut gibi okur: `once`. Varsayılan stratejide, `on_demand`, işlenebilecek işlemler beklediğinde bir blok oluşturur; varsayılan olarak aynı anda yalnızca bir blok işlenir (`--max-in-flight` bu sayıyı artırır). Sakin bir zincirde, `--heartbeat-seconds N` N saniye boyunca blok oluşturulmamışsa boş bir blok isteyene kadar blok oluşturulmaz; varsayılan olarak bu özellik kapalıdır. Art arda iki blok reddedildikten sonra oluşturucu, soruna bir işlemin neden olduğundan şüphelenir ve bu işlemi bekleme süresi boyunca dışarıda bırakır.

Aynı anda yalnızca bir oluşturucu çalışabilir; `run` ve `once` kilit alır ve başka bir süreç kilidi tutuyorsa başlamayı reddeder. Durdurma sinyali, sürmekte olan bloğu tamamlayıp çıkar. Oluşturucuyu, yeniden başlatan bir servis yöneticisi altında çalıştırın ve durdurma zaman aşımını bir kanıt ile Canton'ın yanıtının toplam süresinden uzun tutun. Yeniden başlatma her zaman güvenlidir: sonraki başlangıçta Canton'ın baş noktasına dönülür ve kesintiye uğrayan bloğun işlemleri yeniden reth'e gönderilir. Oluşturucu, `status.json` dosyasını ve çalışma klasöründe bir günlük dosyası yazar; gezgin her ikisini de okur.

## Gezgini kendiniz çalıştırın

Gezgin, gösterdiği zincirin yanında, Docker yüklü bir Linux makinesinde kapsayıcı olarak çalışır. Gezginin kendine ait PostgreSQL veritabanı vardır; bu veritabanı, indeksleyicinin Canton kayıtlarından doldurduğu `network/explorer-db.sh`komut dosyasıyla başlatılır. Musluğun fonları, ağ başlamadan önce genesis dosyasında bulunmalıdır; bu yüzden önce `setup` çalıştırılır:

```sh
explorer/run.sh setup           # musluğun anahtarını ve fonlanmış bir genesis dosyasını oluşturur
CZE_GENESIS_FILE=state/faucet/genesis.json network/up.sh
explorer/run.sh start           # ardından http://127.0.0.1:8088 adresini açın
explorer/run.sh stop
```

`start` veritabanını başlatır, geçişleri uygular ve indeksleyiciyi ayrı bir kapsayıcı olarak, ardından gezgini başlatır. Musluk anahtarı yoksa musluk devre dışıdır. Musluk ödemesi reth'e gönderilen bir işlemdir; bu nedenle ancak oluşturucu çalıştığında kesinleşir. Ağı veya gezgini başlatmak, oluşturucuyu başlatmaz. Önce oluşturucuyu bir kez çalıştırıp ardından `explorer/run.sh start`komutunu çalıştırın ya da ilk oluşturucu çalıştırmasından sonra `start` komutunu yeniden çalıştırın; o zamana kadar gezginin oluşturucu çalışma klasörü bulunmaz ve blok yaşam döngüsü boş kalır. Şu ayar olmadan oluşturulmuş bir ağda `CZE_PERSIST`, `stop` komutu, musluk istekleri ve doğrulanmış sözleşme kaynaklarıyla birlikte gezginin veritabanını da siler. Kalıcı bir ağda bu veritabanı korunur.

Varsayılan `explorer/run.sh start` komutunda, `EXPLORER_VERIFIER=1` ayarını `SOLC_LIST_URL`ile birlikte yapmadığınız sürece sözleşme doğrulaması kapalıdır. Ayrıca, `/rpc` uç noktası ve sözleşmeleri okuma çağrıları, `PUBLIC_RPC=1`ayarını yapmadığınız sürece kullanılamaz. Ayarlar, şu dosyanın başlığında listelenmiştir: [explorer/run.sh](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/explorer/run.sh).

Sağlanan yerel ağda Ledger API'si oturum açma gerektirmez. Gezgin yalnızca okuyucu tarafı olarak okuma yapar; ancak bu katılımcıya erişebilen herkes, onun diğer taraflarını da okuyabilir. Bu nedenle kapsayıcıya asla genel erişime açık bir adres vermeyin. Mevcut bir katılımcıda, gezgin için okuyucu kullanıcısına ait 0600 izinli bir belirteç dosyası (`LEDGER_TOKEN_FILE`), katılımcının `LEDGER_URL` ve `READER_PARTY`. Kapsayıcı hâlâ 127.0.0.1 adresini dinler; herkese açık bir adres için kendi proxy’niz gerekir.  [Gezgin kılavuzunda](https://github.com/rome-protocol/canton-zk-evm/blob/main/explorer/README.md#running-it) tüm ayarlar bulunur.

## Gerçekçi bir trafik karışımıyla yük oluşturun

`load/mixed` klasörü,  [Ölçümler](https://docs.rome.builders/tr/canton-zk-evm/measurements.md)sayfasındaki bir saatlik çalıştırmanın arkasındaki araç setini içerir. Bu araç seti, bir zincire çeşitli türlerde token’lar, bir DEX, izin gerektiren bir token ve özel transfer sözleşmesi dağıtır; ardından 200 cüzdandan karma trafik gönderir. Adımlar  [README](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/load/mixed/README.md) dosyasında yer alır. Docker’a ve araç setinin varsayılan yapılandırmasıyla yaklaşık 12.000 tROME bulunduran bir hesaba ihtiyacınız vardır. Kendi zincirinizde bu hesabı genesis sırasında fonlayın. DevNet musluğu bu miktarı sağlayamaz.


---

# 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/tr/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.
