> 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/de/rome-zk-evm/run-a-rollup.md).

# Ein Rollup ausführen

Registriere und betreibe deine eigene Rome-ZK-EVM-Chain auf dem Solana-Devnet mit dem Rollup-Runner v0.3.0.

Die `./rollup` Der Runner startet eine Kette gegen die gemeinsam genutzten Solana-Devnet-Programme von Rome. Du betreibst seinen Knoten und übernimmst seine Solana-Kosten. Du deployst die Settlement-Programme nicht selbst. Die Registrierung ist erlaubnisfrei, aber bewiesene Roots benötigen einen von Rome registrierten, kettenspezifischen Verifizierungsschlüssel.

Diese Seite verwendet **v0.3.0**. Der [vollständige Devnet-Anleitung](https://github.com/rome-protocol/solana-zk-evm/blob/v0.3.0/docs/RUN-ON-DEVNET.md) deckt jede Einstellung sowie jeden Fehler- und Wiederherstellungsschritt ab.

## Bevor du beginnst

Verwende eine x86-64-Linux-Maschine mit bash 4 oder neuer, Git, Docker Engine 28 oder neuer mit Compose, curl, jq, openssl, die Solana-CLI und Python 3.11 oder neuer. Du brauchst einen Solana-Devnet-RPC-Endpunkt, ein finanziertes Solana-Payer-Keypair, das zugleich deine Chain-Authority ist, und einen Sequencer-Signaturschlüssel. Halte beide Dateien privat und für den Container-Benutzer 999 lesbar. Die Anleitung erklärt, wie du sie erstellst.

Budgetiere etwa **7 SOL im Devnet** für den Payer. Die Registrierung bindet 5 SOL; `./rollup check` erwartet mindestens 1 SOL übrig für das Posten und die Miete. Die Einzahlung wird nach dem ersten finalen Root oder zehn geposteten Roots erstattbar. Wenn die Chain vorher zurückgefordert wird, geht die Einzahlung an die Treasury. Die Kette benötigt außerdem eine EVM-Empfängeradresse für Gebühren, die du kontrollierst.

Um Roots abzuwickeln, brauchst du einen Prover-Host mit einer NVIDIA-GPU mit mehr als 30 GB Speicher. Eine 24-GB-Karte ist für den finalen Beweisschritt zu klein. [Prover-Host](https://docs.rome.builders/de/rome-zk-evm/prover-host.md) liefert das RAM- und Festplattenbudget. Der Knoten kann laufen und Batches veröffentlichen, bevor der Prover bereit ist, aber keiner seiner Roots wird final sein.

## Starte den Knoten

Klonen Sie die Release-Version und arbeiten Sie aus ihrem rollup-Verzeichnis:

```sh
git clone --branch v0.3.0 https://github.com/rome-protocol/solana-zk-evm.git
cd solana-zk-evm/deploy/rollup
cp .env.example .env
cp chain.toml.example chain.toml
```

Setze die Solana-RPC-, Signaturdatei-Standorte und `ROME_ZK_TAG=v0.3.0` in `.env`. Behalte `PROGRAMS_JSON=programs.devnet.json`. Setze `ROME_ZK_GUEST_TAG=v0.3.0` und `ZISK_RELEASE=1.3.1-alpha` für den späteren Guest-Build. Binde den RPC für einen lokalen ersten Lauf an Loopback. Lass `PROVER` ungesetzt, bis der Guest und sein Schlüssel bereit sind.

Setze `genesis.fee_recipient` in `chain.toml` zu deiner EVM-Adresse. Wähle keine Chain-ID. Die Abwicklung leitet eine aus dem Payer und seiner Registrierungsanzahl ab; `init` liest sie, bevor irgendetwas gesendet wird. Etwa die Hälfte aller IDs ist für MetaMask zu groß. Wenn deine dazugehört, `init` bricht ab mit `ChainIdNotWalletSafe`; erstelle einen neuen Payer-Schlüssel, setze `PAYER_KEYPAIR_PATH` darauf und führe `init` erneut aus.

Eine neue Chain startet mit null Guthaben. Wenn du einen gedeckten Kontostand deklarierst, um vor geöffneten Einzahlungen Gas zu haben, sperre denselben Betrag an Wrapped SOL im Tresor der Chain, bevor du den Verifizierungsschlüssel anforderst.

```sh
./rollup init
./rollup register --dry-run
./rollup register --confirm
./rollup up
./rollup check
```

`init` rendert die Genesis- und Dienstkonfiguration. `register --confirm` bindet die 5-SOL-Einzahlung und erstellt den Batch-Cursor. `hoch` startet den Sequencer-, Batcher-, Derive- und Verifier-Knoten. `prüfen` nennt jeden fehlenden Dienst und vergleicht dann die Chain-ID, die Heads, den Fortschritt des Batchers, die Inbox und die Roots. Führe es nach einiger Zeit erneut aus, nachdem Batches Zeit hatten zu schließen; seine erste Prüfung des Batch-Fortschritts zeichnet nur eine Stichprobe auf.

Ohne Prover stellt der Sequencer RPC bereit, der Batcher postet Transaktionsdaten in die Inbox und der Derive rekonstruiert die Chain. Ein Inbox-Batch ist kein finaler Settlement-Root. Selbst der Genesis-Root wartet auf einen Beweis.

## Von Batches zu finalen Roots wechseln

Baue den Guest für den Genesis deiner Chain:

```sh
./rollup guest-build
```

Der Build verwendet den v0.3.0-Guest und ZisK 1.3.1-alpha. Er erzeugt das Guest-Programm der Chain und die Metadaten des Verifizierungsschlüssels. Das Berechnen von `programVK` erfordert die ZisK-Proving-Keys und etwa 36 GB RAM. Das Registrieren der Chain registriert keinen Verifizierungsschlüssel. Sende die [Anfrage für den Verifizierungsschlüssel](https://docs.rome.builders/de/rome-zk-evm/verification-key.md) nach dem Build. Rome prüft deinen Genesis und Guest und registriert dann den Schlüssel mit einem Aktivierungs-Slot.

Auf dem Prover-Host setze `PROVER=on` sowie den Guest, die Verifizierungsmetadaten und die ZisK-Einstellungen, die im vollständigen Runbook beschrieben sind. Nachdem der Schlüssel aktiv ist:

```sh
./rollup init
./rollup up
./rollup check
```

Prüfe, ob die `Dienst-Prover` und `Verifizierungsschlüssel` Einträge bestehen. Der Prover arbeitet die Inbox-Batches der Reihe nach ab. Jeder gültige Beweis postet einen Root, der endgültig ist, sobald seine Solana-Transaktion landet.

## Mache den ersten Block

Ohne einen durch Guthaben gedeckten Genesis-Kontostand hat die Chain kein Gas für eine Transaktion, bis Einzahlungen geöffnet werden. Einzahlungen benötigen einen ersten bewiesenen Root. Das Standard- `empty_block_interval_secs = 0` lässt eine untätige Chain ohne Blöcke, also setze es auf `60` unter `[profile]` in `chain.toml` nachdem der Schlüssel aktiv ist und der Prover läuft. Rendern und neu starten:

```sh
./rollup init
./rollup up
./rollup check
```

Sobald der erste Root final ist, setze das Intervall wieder auf `0` und führe `init` und `hoch` erneut aus, es sei denn, du möchtest regelmäßige leere Blöcke. Wenn du sie einschaltest, während du darauf wartest, dass Rome den Schlüssel registriert, entsteht ein Rückstau. Jeder Batch muss der Reihe nach bewiesen werden.

Bei einem 60-Sekunden-Intervall für leere Blöcke und dem 60-Sekunden-Batch-Close erzeugt die Chain etwa einen Batch pro Minute, also etwa 1.440 pro Tag. Im Devnet kostete ein bewiesener Root den Payer etwa **0,003 SOL**: etwa 0,002 SOL an Miete für ausstehende Konten, die 0,001-SOL-Abwicklungsgebühr und zusätzlich eine Transaktionsgebühr. Dieses Tempo liegt vor den Kosten für das Posten in die Inbox bei etwa 4,4 SOL pro Tag. Die Miete für ausstehende Konten bleibt mit den Standardeinstellungen gesperrt. Bei ausgeschalteten leeren Blöcken schließt eine untätige Chain keine Batches ab und verursacht keine Posting-Kosten.

Um Einzahlungen zu akzeptieren, erstelle als Nächstes den Tresor, aktiviere nach seiner Verzögerung die Exit-Konfiguration und öffne eine Einzahlungswarteschlange. Diese Befehle und die Prüfungen befinden sich in [Einzahlungen und Abhebungen](https://docs.rome.builders/de/rome-zk-evm/deposits-and-withdrawals.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/de/rome-zk-evm/run-a-rollup.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.
