> 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/canton-zk-evm/measurements.md).

# Messungen

Aufgezeichnete Messwerte für Beweis und Abwicklung mit ihren Daten, ihrer Hardware und ihren Grenzen.

Diese Seite enthält sechs Messreihen, die neueste zuerst: DevNet-Durchsatz (2026-10-25), den größten Block, den der Prover erhalten hat (2026-10-25, auf einer Benchmark-Maschine), die einstündige gemischte Last auf Ostia DevNet (2026-10-24), die Budgets des Explorers, die lokale Demo (2026-10-05) und den Prover-Benchmark (2026-10-03). Dabei wurden unterschiedliche Dinge gemessen. Beim Benchmark vom 2026-10-03 kam der unveränderte Reth-Gast aus dem Upstream zum Einsatz. Bei den anderen Prover- und Ostia-Läufen wurde Ostias eigener Gast verwendet, einschließlich seiner Chain-Regeln-Prüfung und des Gateways.

Diese Seite beschreibt das Release `v0.1.0` und, sofern ausdrücklich angegeben, den Stand von DevNet: für die nachfolgenden Zahlen vom 2026-10-25 und für die Tabelle „Jetzt festgeschrieben“ vom 2026-11-19. [Status](https://docs.rome.builders/de/canton-zk-evm/status.md) nennt den Commit, auf dem DevNet jetzt läuft. Lies den vollständigen [Metrikbericht](https://github.com/rome-protocol/canton-zk-evm/blob/main/docs/METRICS.md), die [einstündigen Ergebnisse](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/load/mixed/RESULTS-2026-10-24.md) und die [Demo-Ergebnisse](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/demo/README.md#results).

In Ostias Tools werden zwei Zeitintervalle als „Commit“ bezeichnet. Beide beginnen, wenn der Builder `Advance`sendet. Die Home- und Stats-Karte des Explorers endet mit Cantons Antwort an den Builder. Die Kachel auf der Blockseite und die Spalte „Commit“ in den einstündigen Ergebnissen enden mit Cantons Erfassungszeitpunkt für den Block. Auf dieser Seite wird jeweils das Intervall genannt, auf das sich ein Zitat bezieht.

## Ostia DevNet: Durchsatz, 2026-10-25

Diese Läufe wurden direkt auf Ostia DevNet mit einem Teilnehmer, einem Builder und einem Prover ausgeführt. Die Rohprotokolle wurden nicht veröffentlicht; die Zahlen stammen aus den Laufnotizen. Jede gesendete Transaktion wurde finalisiert, und keine der Transaktionen, die erfolgreich sein sollten, wurde zurückgesetzt. Beim morgendlichen Schub von 20.000 Überweisungen gingen vier Transaktionen im Transaktionspool von Reth verloren und wurden erneut gesendet.

**Morgens, 08:11 bis 08:45 UTC: Der Builder füllt Blöcke anhand des verbrauchten Gases.** Die Änderung bestand darin, das von Transaktionen verbrauchte statt des von ihnen angegebenen Gases zu zählen. Ein Block war auf 65,536 Rohbytes an Transaktionen begrenzt.

| Last                                                      | Alter Builder  | Neuer Builder bei Sättigung                                | Begrenzender Faktor                                                      |
| --------------------------------------------------------- | -------------- | ---------------------------------------------------------- | ------------------------------------------------------------------------ |
| Gemischt: 17 Transaktionsarten, jeweils etwa 254 Rohbytes | etwa 7,5 Tx/s  | etwa 10,9 Tx/s (10,1 über das gesamte Auslastungsfenster)  | die Begrenzung auf 65,536 Byte, nicht das Gas (17 M von 30 M verbraucht) |
| Einfache Überweisungen: jeweils 21,000 Gas                | nicht gemessen | etwa 26 Tx/s (595 pro Block, ungefähr alle 23 s ein Block) | dieselbe Begrenzung (12,5 M von 30 M Gas verbraucht)                     |

Bei einer Senderate von 10 Tx/s konnte die gemischte Last Schritt halten, bei 15 fiel sie zurück; der Rückstand war in etwa zwei Minuten abgebaut. **Seit Daml-Paket 0.2.0 wurde die gemischte Last nicht erneut gemessen.**

**Mittags, 11:36 bis 11:46 UTC: nach Paket 0.2.0.** Das Paket ging bei Block 1453 (11:29 UTC) live. Jeder Lauf bestand aus einem Schub von 9.000 einfachen Überweisungen, die innerhalb von etwa 25 Sekunden von einem Konto gesendet wurden, während ein weiterer Treiber im Hintergrund 3 Transaktionen pro Sekunde sendete. „Kontinuierlich“ reicht vom Schnitt des ersten vollständigen Blocks bis zur Finalisierung des letzten vollständigen Blocks.

| Begrenzung der Rohbytes pro Block | Überweisungen pro Block | Proof  | Commit p50 / p95 | Vom Schnitt des Blocks bis zur Finalisierung, p50 | Kontinuierlich | Gesamter Schub     |
| --------------------------------- | ----------------------- | ------ | ---------------- | ------------------------------------------------- | -------------- | ------------------ |
| 131,072                           | 1,191                   | 12,1 s | 6,7 s / 7,7 s    | 20,2 s                                            | 59 Tx/s        | 46 Tx/s            |
| 196,608                           | 1,428                   | 13,3 s | 7,8 s / 8,6 s    | 22,4 s                                            | 64 Tx/s        | 48 Transaktionen/s |

Commit-Lauf ab der Übermittlung `Advance` bis zur Antwort von Canton. Bei 196.608 Byte wird das Byte-Limit nicht erreicht: Zuerst greift das Gas-Limit von 30.000.000, und zwar bei 1.428 einfachen Transfers (29.988.000 Gas). Eine weitere Erhöhung des Byte-Limits ändert bei einfachen Transfers nichts. Die Erhöhung von 131.072 auf 196.608 brachte nur 8 % mehr (59 auf 64 Transaktionen/s): Der Block wuchs um 20 %, aber auch der Proof (12,1 auf 13,3 s) und der Commit dauerten länger. Vom Erstellen bis zur Finalisierung dauert ein Block etwa 20 bis 23 Sekunden; Proof und Commit erfolgen nacheinander, während jeweils ein Block in Bearbeitung ist. Den Laufnotizen zufolge gab es für jede Übermittlung ein eindeutiges Ergebnis und bei keinem der beiden Bursts JSON-API-Timeouts.

Den Laufnotizen zufolge verringerte Paket 0.2.0 den Daml-Aufwand des Participants pro KB des serialisierten `Advance` Arguments. Pro Durchlauf – es gibt zwei – sank er von etwa 23 ms (Übermittlung) und 22 ms (Prüfung) auf geschätzte 4,7 bis 4,8 ms bzw. 3,4 bis 4,1 ms; bei einem typischen Block also um etwa 3 ms. Bei gewöhnlichen Blöcken mit 35 bis 54 Transaktionen `Advance` betrug der Median unter 0.2.0 3,9 s (Blöcke 1453 bis 1457), gegenüber 6,4 s unter 0.1.0 (Blöcke 1440 bis 1452).

Einfache Transfers sind die günstigsten Transaktionen überhaupt; 64 Transaktionen/s ist daher kein Richtwert für eine hohe Auslastung mit Verträgen. Unter jedem Limit wurde ein einzelner Burst ausgeführt, daher liegen keine Streuungsdaten vor.

## Der größte Block, den der Prover erhalten hat, 2026-10-25

Dies ist eine Benchmark-Maschine, kein DevNet: eine temporäre Maschine mit einer NVIDIA RTX PRO 6000 Blackwell Server Edition GPU (96 GB), 48 vCPUs und 176 GiB RAM. Sie lief von 03:35 bis 04:35 UTC und wurde anschließend gelöscht. ZisK 1.3.1-alpha hat Blöcke mit einfachen Transfers mithilfe von Ostias Guest v0.1.0 bewiesen. Jeder erfolgreiche Proof wurde geprüft. Keiner dieser Blöcke wurde an Canton übermittelt; die letzte Spalte zeigt die Größe der Daten, die ein Commit übertragen würde.

| Transfers im Block | Gas       | Proof-Zeit | Spitzenauslastung des Prover-Speichers (Host) | `Advance` Argument |
| ------------------ | --------- | ---------- | --------------------------------------------- | ------------------ |
| 1,000              | 21 Mio.   | 9,3 s      | 49 GB                                         | 237 KB             |
| 5,000              | 105 Mio.  | 25,3 s     | 55 GB                                         | 1,16 MB            |
| 10,000             | 210 Mio.  | 44,0 s     | 63 GB                                         | 2,31 MB            |
| 20,000             | 420 Mio.  | 86,2 s     | 76 GB                                         | 4,61 MB            |
| 45,557             | 957 Mio.  | 206,8 s    | 110 GB                                        | 10,49 MB           |
| 50,000             | 1,05 Mrd. | 228,4 s    | 108 GB                                        | 11,5 MB            |
| 62,500             | 1,31 Mrd. | 283,8 s    | 122 GB                                        | 14,4 MB            |

Ein Block mit 62.500 Transfers und 1,31 Milliarden Gas wurde in 284 s bewiesen und bestand die Verifizierung. Blöcke mit 75.000 und 100.000 Transfers scheiterten am 300-Sekunden-Limit des ZisK-Koordinators, nicht am Speicher. Jeder zusätzliche Transfer kostete etwa 4,5 ms Proof-Zeit, also rund 220 Transfers pro Sekunde. Das Gas-Limit von DevNet lag am 2026-10-25 bei 30.000.000, daher sind seine Blöcke deutlich kleiner. Unter dem standardmäßigen Canton-Anfragelimit von 10 MiB wären allein aufgrund der Anfragengröße höchstens 45.557 Transfers möglich; das ist eine Berechnung anhand der obigen Größen, das eigene Limit von DevNet wurde nicht ermittelt. Der Daml-Aufwand des Participants würde einen solchen Block zuerst ausbremsen: Bei etwa 3 bis 5 ms pro KB und Durchlauf unter 0.2.0 bedeutet ein 10,49-MB-Argument über die beiden Durchläufe hinweg ungefähr 60 bis 105 Sekunden Aufwand (eine Extrapolation aus Blöcken mit bis zu etwa 330 KB) – deutlich mehr als das JSON-API-Timeout von 20 Sekunden. Daher wurde diese Größe nicht an Canton übermittelt; mit der aktuellen Konfiguration wäre dies auf DevNet auch nicht möglich.

## Ostia DevNet: gemischte Last über eine Stunde, 2026-10-24

Der Lasttest wurde einmal gegen den öffentlichen RPC von [Ostia DevNet](https://docs.rome.builders/de/canton-zk-evm/devnet.md) (Chain 770101) ausgeführt, von 12:59:28 bis 13:59:58 UTC. Die Chain erzeugte die Blöcke 224 bis 448, die ausschließlich die Transaktionen des Lasttests enthalten. Es wurden 13.496 Transaktionen von 200 Wallets und 4 verifizierten ERC-3643-Inhabern gesendet, verteilt auf 25 Aktionsarten: ERC-20-, ERC-721- und ERC-1155-Transfers und -Mints, ERC-3643- (T-REX-)Transfers, Uniswap-V2-Swaps und Liquiditätsaktionen, Merces-Transfers mit clientseitig erstellten Proofs sowie absichtliche Reverts. Alle 13.496 wurden finalisiert, keine ging verloren. Der RPC lehnte beim Senden weitere 5 Transaktionen wegen einer Nonce-Lücke ab.

Der Treiber sendete jeweils zehn Minuten lang 2, 3, 4 und 4,5 Transaktionen pro Sekunde und anschließend zwanzig Minuten lang 4,5. Die Chain verarbeitete in den sechs Zehn-Minuten-Fenstern 1,95, 2,98, 3,95, 4,58, 4,48 und 4,54 Tx/s. **Das RPC-Kontingent eines Clients begrenzte die Rate, nicht die Chain.** Das öffentliche RPC erlaubt einem Client 300 Aufrufe pro Minute; der Treiber hielt sich an 285. Der größte Block enthielt 84 Transaktionen, und der höchste Gasverbrauch eines Blocks betrug 7,89 Mgas bei einem Limit von 30 Mgas. Der Prover war in keinem Zehn-Minuten-Fenster länger als 0,56 des Fensters ausgelastet. Dieser Lauf hat das Limit der Chain nicht ermittelt.

| Blöcke in der Stunde         | Median    | p95       | Maximum   |
| ---------------------------- | --------- | --------- | --------- |
| Transaktionen in einem Block | 69        | 79        | 84        |
| Gas in einem Block           | 5,29 Mgas | 6,77 Mgas | 7,89 Mgas |
| Sekunden zwischen Blöcken    | 17        | 18        | 19        |

### Proof und Zeit bis zur Finalisierung

Die Proof-Zeit ist die Zeit, die der Prover für den Block benötigt. „Block bis zur Finalisierung“ misst die Zeit von der Erstellung des Blocks bis zu seiner Finalisierung auf Canton. „Commit“ misst die Zeit vom Absenden durch den Builder `Advance` bis zum Zeitpunkt, zu dem Canton den Block erfasst.

| Transaktionen im Block | Blöcke | Proof p50 / p95 (s)     | Block bis zur Finalisierung p50 / p95 (s) | Commit p50 / p95 (s) |
| ---------------------- | ------ | ----------------------- | ----------------------------------------- | -------------------- |
| 1 bis 10               | 2      | 7.41 / 7.47             | 8.52 / 8.61                               | 1.09 / 1.11          |
| 11 bis 100             | 223    | 9.03 / 9.21             | 11.01 / 11.95                             | 2.03 / 2.86          |
| 101 und mehr           | 0      | kein Block dieser Größe |                                           |                      |

Die Proof-Zeit stieg mit der Blockgröße nur leicht an: etwa 7,9 s bei den 36 Blöcken mit 19 bis 30 Transaktionen und etwa 9,1 s bei den 76 Blöcken mit 76 bis 84 Transaktionen. Eine Transaktion wartet länger, als die Verarbeitung ihres Blocks dauert. Gemessen vom Annehmen einer Transaktion durch das RPC bis zur Finalisierung ihres Blocks und für die ersten drei Transaktionen jedes Blocks (673 Transaktionen) betrugen der Median 19,5 s, p95 27,1 s und der Höchstwert 28,8 s.

### Was ein Block auf Canton kostet

Jeder Block ist ein `Advance` -Befehl, und der dadurch verursachte Datenverkehr entspricht dem Wert `paidTrafficCost` in den Abschlussberichten. Dieser Wert ist bei allen 225 Blöcken vorhanden: Der Median beträgt 15.654 Byte, p95 16.612 Byte und der Höchstwert 16.822 Byte. Die Stunde verursachte 3.285.181 Byte Datenverkehr, also etwa 3,3 MB. Der größte Teil des Datenverkehrs eines Blocks ist fest und beträgt etwa 8,4 KB; jede Transaktion fügt etwa 100 Byte hinzu (Schätzung über die Stunde: etwa 8.400 + 103 pro Transaktion). Ein Block mit 1 bis 10 Transaktionen verursachte im Median 7.928 Byte, einer mit 61 bis 100 Transaktionen 16.052 Byte.

### Was nicht funktioniert hat

* **RedStone hat keinen Preis aufgezeichnet.** Der `PriceVault` -Contract ist bereitgestellt. Der Treiber fragte 80-mal bei den öffentlichen Gateways von RedStone signierte Preise an und erhielt keine, weil diese anonyme Anfragen ablehnen. Er sendete keinen `record` -Aufruf. Zum Aufzeichnen von Preisen ist eine Vereinbarung mit dem Datendienst von RedStone erforderlich, die für diesen Lauf nicht bestand.
* **57 gezielt herbeigeführte Reverts traten nicht auf.** Im Swap-Testfall mit einer Ausgabe unter dem Mindestwert wurde der Mindestwert mit 6 Dezimalstellen für einen Token festgelegt, der 18 hat. Daher wurden alle diese Swaps ausgeführt. Dies war ein Fehler im Lasttreiber und ist inzwischen behoben. Die anderen gezielt herbeigeführten Fälle schlugen wie vorgesehen fehl: insgesamt 288 von 345.
* **4 Transaktionen schlugen fehl, obwohl sie hätten erfolgreich sein sollen.** Drei Swaps und ein Unwrap schlugen fehl, weil das Wallet keine Token dieses Typs besaß. Der Treiber hatte Token aus einem Swap verbucht, den das RPC beim Senden abgelehnt hatte. Die Ursache liegt in der Buchführung des Treibers, nicht in der Chain.
* **5 Sendevorgänge wurden wegen einer Nonce-Lücke abgelehnt.** Zwei Transaktionen eines Wallets wurden gleichzeitig gesendet, und die spätere traf zuerst ein. Der Treiber sendet die Transaktionen eines Wallets jetzt in Nonce-Reihenfolge. Die Fehlerbehebungen wurden noch nicht über eine volle Stunde getestet.

### Die aktuellen Zahlen

Die [Statistikseite](https://ostia.devnet.romeprotocol.xyz/stats) des Explorers zeigt diese Werte für ein beliebiges Zeitfenster und `/api/stats/summary` stellt sie bereit. In den 24 Stunden bis zum 25.10.2026, 01:34 UTC, erzeugte die Chain 417 Blöcke. Bei hoher Auslastung lagen zwischen den Blöcken im Median 16,6 s. Die Proof-Zeit betrug im Median 8,0 s. Eine Transaktion brauchte von der Annahme bis zur Finalisierung im Median 19,2 s (p95: 28,4 s). Die Werte auf der Statistikseite werden fortlaufend aktualisiert und beschreiben daher jeweils die vergangenen 24 Stunden.

## Budgets des Explorers

Die Tests des Explorers überprüfen sieben Budgets, B1 bis B7. Die Werte stammen aus CI-Läufen auf einem gemeinsam genutzten GitHub-Runner mit einer Testdatenbank, nicht von DevNet. Der Lauf mit 3.000.000 Transaktionen wird bei jedem Pull Request ausgeführt; der Lauf mit 10.000.000 Transaktionen wurde einmal durchgeführt, und zwar in der im Design angegebenen Größe. Für B1 und B2 gibt es außerdem Messungen auf dem Referenzrechner des Explorers. Das Repository kennzeichnet sie als vorläufig, da weder der Commit noch der Befehl aufgezeichnet wurden.

| Budget                                                                                                            | Zielwert                                                                             | Messwert                                                                                                                 |
| ----------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------ |
| B1 Indexierung des aufwendigsten Blocks, den das 30-Mgas-Limit zulässt, erste Phase (Blöcke, Transaktionen, Logs) | Höchstens 2.750 ms                                                                   | 806 ms p50 auf dem Referenzrechner, 23.10.2026; 2.116 ms auf dem Runner, letzter Lauf                                    |
| B2 Beide Phasen dieses Blocks (in der zweiten werden Salden und Token-Transfers abgeleitet)                       | Höchstens 12.750 ms                                                                  | 3.998 ms p50 auf dem Referenzrechner; auf dem Runner 10,9 bis 13,0 s über sechs Läufe, bei einem Grenzwert von 16.000 ms |
| B3 API bei 200 Anfragen pro Sekunde: Block, Transaktion oder Adresse, p95                                         | Höchstens 100 ms                                                                     | 22 ms bei 3.000.000 Transaktionen; 40 ms bei 10.000.000                                                                  |
| B3 Transaktionsseite einer Adresse; Listenseite; Suche; `getLogs`                                                 | Höchstens 300, 200, 100 und 500 ms                                                   | 18, 14, 7 und 12 ms bei 3.000.000; 34, 30, 18 und 19 ms bei 10.000.000                                                   |
| B4 Ein neuer finaler Block an 2.000 Live-Stream-Clients, p95                                                      | Höchstens 500 ms                                                                     | 63 ms; 100 ms                                                                                                            |
| B5 Kaltstart einer Seite bei 10 Mbit/s und 100 ms Round-Trip-Zeit: Startseite, Block, Transaktion                 | Largest Contentful Paint höchstens 2,0 s, höchstens 200 KB gzip-komprimiertes Skript | 808 bis 998 ms und 165 KB, Median aus zwei Browserläufen der Kurzversion des nächtlichen Tests                           |
| B6 Datenbankgröße pro Million Transaktionen                                                                       | Höchstens 2,5 GB                                                                     | 1,24 GB; 1,22 GB, beides vor Migration 0030; in den neuesten kurzen Läufen wurden 1,68 bis 1,71 GB gemessen              |
| B7 `/api/health`, p97.5                                                                                           | Höchstens 50 ms, keine Antwort außer 200                                             | 5 ms und 22 ms; keine andere Antwort                                                                                     |

In den Zeilen B3 bis B7 gilt: Der erste Wert bezieht sich auf 3.000.000 Transaktionen, der zweite auf 10.000.000. Der [Metrikbericht](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/docs/METRICS.md#the-api-at-scale-l2) enthält den Lasttest; der Abschnitt zu [B1 und B2](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/docs/METRICS.md#b1-and-b2-on-the-reference-machine-and-on-the-runner) enthält die zugehörigen Messwerte und ihre Einschränkungen.

## Hardware

Für den Benchmark und die Demo wurde jeweils eine NVIDIA RTX PRO 6000 Blackwell Server Edition GPU verwendet. Für die Ostia-Demo wurden nur GPU und Treiber aufgezeichnet. Der DevNet-Prover ist eine NVIDIA RTX PRO 6000 Blackwell Server Edition (96 GB) in einer Maschine mit 48 vCPUs, demselben Maschinentyp wie beim Benchmark vom 03.10.2026.

| Komponente                    | Prover-Benchmark, 03.10.2026                                                         | Ostia-Läufe, 05.10.2026 |
| ----------------------------- | ------------------------------------------------------------------------------------ | ----------------------- |
| CPU                           | AMD EPYC 9B45, 48 vCPUs; ein Sockel, zwei Threads pro Kern                           | Nicht aufgezeichnet     |
| Host-RAM                      | 176 GiB laut Host                                                                    | Nicht aufgezeichnet     |
| GPU-Speicher                  | 97.887 MiB, als 96 GB angegeben; PCIe Gen 5 x16                                      | Kapazität nicht erfasst |
| Treiber                       | 580.178.04                                                                           | 580.178.04              |
| CUDA                          | 13.0 auf Treiberebene; vorgefertigte GPU-Binärdateien, kein CUDA-Toolkit installiert | Nicht aufgezeichnet     |
| Betriebssystem und Festplatte | Ubuntu 22.04.5, 500-GB-Systemfestplatte                                              | Nicht aufgezeichnet     |
| Node und snarkjs              | 20.18.0 und 0.7.6                                                                    | Nicht aufgezeichnet     |

## Festgelegte Versionen

Diese Versionen sind in [PINS](https://github.com/rome-protocol/canton-zk-evm/blob/main/PINS) und im [Metrikbericht](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/docs/METRICS.md#software-versions)aufgeführt. Die oben angegebene Node-Version des Benchmark-Hosts unterscheidet sich von der festgelegten Version des Provers.

### Derzeit festgelegt und in DevNet im Einsatz

| Komponente                       | Version                                                                                                                                                                                                                                                                                                                                      |
| -------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| ZisK                             | 1.4.0-alpha (DevNet wechselte mit Block 71864 am 2026-11-16 darauf; von Block 15573 am 2026-10-27 an lief dort 1.3.2-alpha; bei den Läufen auf dieser Seite kam 1.3.1-alpha zum Einsatz)                                                                                                                                                     |
| Upstream-Quellcode des Guest     | 0.14.0 (DevNets Guest ab Block 71864; davor und bei den Läufen auf dieser Seite 0.13.1)                                                                                                                                                                                                                                                      |
| reth                             | 2.11.0 (in DevNet seit 2026-11-19; davor und bei den Läufen auf dieser Seite 2.5.2)                                                                                                                                                                                                                                                          |
| Canton                           | 3.7.2 (Validator von Romes DevNet seit 2026-11-07; DevNets Synchronizer verwendet seit 2026-11-18 Protokollversion 37). Die DevNet-Läufe auf dieser Seite (2026-10-24 und 2026-10-25) liefen mit Canton 3.6.3 und Protokollversion 36; der Benchmark vom 2026-10-03 und die Demo vom 2026-10-05 liefen mit den unten aufgeführten Snapshots. |
| Daml-SDK für den externen Aufruf | 3.6.0                                                                                                                                                                                                                                                                                                                                        |
| Daml-Compiler                    | damlc 3.6.2, Zielversion Daml-LF 2.4                                                                                                                                                                                                                                                                                                         |
| Daml-SDK für Script-Tests        | 3.5.12, Zielversion Daml-LF 2.1                                                                                                                                                                                                                                                                                                              |
| Java                             | 21                                                                                                                                                                                                                                                                                                                                           |
| Rust                             | 1.94.1                                                                                                                                                                                                                                                                                                                                       |
| Python für Builder und Demo      | 3.12 oder neuer                                                                                                                                                                                                                                                                                                                              |
| Prover-Node und snarkjs          | 20.20.2 und 0.7.6                                                                                                                                                                                                                                                                                                                            |
| Explorer-Node                    | Lokal 22.18 oder neuer; im Container und in CI 24                                                                                                                                                                                                                                                                                            |
| Solidity-Compiler für Test-Token | 0.8.28                                                                                                                                                                                                                                                                                                                                       |

### Bei den dokumentierten Läufen verwendet

Der Benchmark vom 2026-10-03 und die Demo vom 2026-10-05 liefen mit Snapshots von Canton und dem Daml-Compiler. In den Aufzeichnungen sind die Snapshots angegeben. Die übrigen oben genannten Versionen stimmen überein, mit Ausnahme von ZisK, dem Upstream-Quellcode des Guest und reth: Bei diesen Läufen kamen 1.3.1-alpha, 0.13.1 und 2.5.2 zum Einsatz.

| Komponente                       | Version bei den dokumentierten Läufen                              |
| -------------------------------- | ------------------------------------------------------------------ |
| Canton                           | 3.6.0-snapshot.20260930.20337.0.ve610bc8f                          |
| Daml-SDK für den externen Aufruf | 3.5.13-snapshot.20261001.145.0.v852bdd82                           |
| Daml-Compiler                    | 3.6.0-snapshot.20260915.14804.0.v53478765, Zielversion Daml-LF 2.4 |

## Ostia-Demo: 2026-10-05

Die Demo bestand ihre Prüfungen am 2026-10-05 in einem lokalen Canton-Netzwerk mit einer NVIDIA RTX PRO 6000 Blackwell Server Edition-GPU. Jeder Testfall wurde einmal ausgeführt, während der Prover bereits lief, ausgehend von Commit `6b445073163832e9023850f53678617d90dfc808`. Dies sind einzelne Testergebnisse, kein Benchmark.

TKA war der EVM-Testtoken. TKB war der Canton-Testtoken und wTKB seine Wrapped-Form auf der EVM. U und V waren die Testparteien. Zuerst wurde ein leerer Smoke-Block committed. Anschließend deployte ein Setup-Block TKA und erstellte wTKB. Es folgten fünf Durchläufe:

| Durchlauf                   | Ablauf                                                                                                                                    | Ergebnis                                                                                                                                                              | Proof-Zeit                                                                         |
| --------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------- |
| 1: Einzahlung               | U zahlte 10 TKB ein und beanspruchte 10 wTKB.                                                                                             | Der Eintrag in Block 3 und der neue Bestand von 10 TKB beim Gateway gingen auf dasselbe Canton-Update zurück.                                                         | 6,72 s                                                                             |
| 2: Zahlung                  | V zahlte U über das Gateway 10 TKA im Gegenzug für Us Zuweisung von 10 TKB an V. Außerdem überwies V U 1 TKA als gewöhnliche Überweisung. | Der Eintrag in Block 4 und Vs neuer Bestand von 10 TKB gingen auf dasselbe Update zurück. Die gewöhnliche Überweisung erzeugte keinen Leg.                            | 6,72 s                                                                             |
| 3: Auszahlung               | U verbrannte 4 wTKB und erhielt 4 TKB.                                                                                                    | Der Eintrag in Block 5 und Us neuer Bestand gingen auf dasselbe Update zurück. Der Wrapped-Bestand und der Verwahrbestand des Gateways sanken auf 6.                  | 6,72 s                                                                             |
| 4: Zuweisung zurückgenommen | U nahm die Zuweisung der Zahlung zurück, nachdem der Proof erstellt worden war.                                                           | Canton lehnte Block 6 ab. Auch die erneute Übermittlung ohne den Leg schlug fehl. Beim nächsten Build wurde die Zahlung ausgelassen und nur Vs Genehmigung committed. | 6,75 s für den ursprünglichen Build; der zweite Proof wurde nicht separat gemessen |
| 5: Manipulierter Proof      | Eine Hexadezimalziffer des Proofs wurde geändert.                                                                                         | Canton lehnte Block 7 ab, nachdem der Sidecar den Proof zurückgewiesen hatte. Der Head blieb bei 6.                                                                   | 6,74 s vor der Manipulation                                                        |

Der Wrapped-Proof war 1.344 Byte groß. Die sechs erfassten Proof-Zeiten für das Setup und die fünf Durchläufe lagen zwischen 6,71 und 6,75 s; für den Proof des leeren Blocks wurden 6,31 s benötigt. Der  [Ergebnisordner](https://github.com/rome-protocol/canton-zk-evm/tree/v0.1.0/demo/results) enthält die Aufzeichnungen. Diese Tabelle zeigt die Zeiten für die einzelnen Fälle:

| Fall                     | Block und verbrauchtes Gas                                                                          | Proof                                                                                      | Vom fertigen Proof-File bis zum Ende des Builders | Gesamter Builder-Durchlauf          |
| ------------------------ | --------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------ | ------------------------------------------------- | ----------------------------------- |
| Smoke-Test               | Block 1, leer; 0 Gas                                                                                | 6,31 s                                                                                     | 0,49 s                                            | 155,20 s                            |
| Setup                    | Block 2, zwei Transaktionen; Gasverbrauch nicht erfasst                                             | 6,71 s                                                                                     | Nicht aufgezeichnet                               | 8,00 s                              |
| Einzahlung               | Block 3, eine Transaktion; 122.308 Gas                                                              | 6,72 s                                                                                     | 0,66 s                                            | 8,14 s                              |
| Zahlung                  | Block 4, drei Transaktionen; 185.307 Gas                                                            | 6,72 s                                                                                     | 0,42 s                                            | 7,87 s                              |
| Auszahlung               | Block 5, eine Transaktion; 90.345 Gas                                                               | 6,72 s                                                                                     | 0,58 s                                            | 8,02 s                              |
| Zuteilung zurückgenommen | Block 6 abgelehnt, anschließend mit einer Transaktion und ohne Legs neu erstellt; Gas nicht erfasst | 6,75 s für den abgelehnten Build; die zweite Proof-Erstellung wurde nicht separat gemessen | Die abgelehnte Übermittlung wurde nicht gemessen  | 8,09 s abgelehnt; 8,04 s übernommen |
| Manipulierter Proof      | Block 7 abgelehnt; Gas nicht erfasst                                                                | 6,74 s vor der Manipulation                                                                | Die abgelehnte Übermittlung wurde nicht gemessen  | 7,57 s                              |

Jeder Proof war 1.344 Byte groß. Das Intervall vom fertigen Proof-Datei bis zum Ende des Builders umfasst das Abrufen der Konto- und Storage-Proofs des Gateways, `Advance`, den Commit durch beide bestätigenden Teilnehmer und das Markieren des Blocks als final durch reth. Es ist länger als Cantons Commit allein. Das Zuordnen der Legs zu Canton-Verträgen geschieht vor dem Proving und liegt außerhalb dieses Intervalls.

Der gesamte Lauf des Smoke-Tests umfasst die Vorbereitung von Witness und Eingaben sowie die anfängliche Einrichtung des Guest-Programms durch den Prover. Möglicherweise umfasst er auch das Erstellen des Eingabetools. Separate Zeiten für diese Schritte wurden nicht erfasst.

## Prover-Benchmark: 2026-10-03

Die Tabelle zeigt Medianzeiten in Sekunden aus drei Warmstarts für jede Blockgröße. Jeder Block enthielt einfache Transfers. Jeder Proof bestand `cargo-zisk verify`. Die Rohdaten der Benchmark-Protokolle sind nicht im Repository enthalten.

| Block                     | Proof ohne Wrap, neuer Prozess | Nur Wrap, neuer Prozess | Proof mit Wrap, neuer Prozess | Gesamter neuer Prozess | Prover im laufenden Betrieb: Eingabe bis zum gewrappten Proof | Prover im laufenden Betrieb: Eingabe bis zum verifizierten Proof |
| ------------------------- | ------------------------------ | ----------------------- | ----------------------------- | ---------------------- | ------------------------------------------------------------- | ---------------------------------------------------------------- |
| 1 Transfer, 21 kgas       | 4.6                            | 2.4                     | 7.4                           | 21.1                   | 6.7                                                           | 7.0                                                              |
| 1.000 Transfers, 21 Mgas  | 6.9                            | 2.4                     | 9.6                           | 24.5                   | 9.0                                                           | 9.3                                                              |
| 5.000 Transfers, 105 Mgas | 17.9                           | 2.4                     | 20.8                          | 34.9                   | 21.2                                                          | 21.5                                                             |

Beim Prover im laufenden Betrieb blieben Koordinator, Worker und Schlüssel geladen. Die Gesamtzeiten für neue Prozesse umfassen das Starten und Beenden des Provers. Die Zeiten von der Eingabe bis zum Proof beginnen mit einer vorhandenen Witness-Datei; das Erstellen der Witness wird nicht gemessen. Der Fall mit 105 Mgas war ein Benchmark des Upstream-Guest, kein Ostia-Block. Das festgelegte Gaslimit für Ostia-Blöcke beträgt 30.000.000.

| Proof-Messung            | Gewrapptes PLONK     | Ungewrapptes STARK       |
| ------------------------ | -------------------- | ------------------------ |
| Größe der Proof-Datei    | 2.942 bis 2.944 Byte | 415.232 bis 415.234 Byte |
| `cargo-zisk verify` Zeit | 0,29 bis 0,30 s      | 0,03 s                   |
| Wire-Größe               | 1.344 Byte           | Nicht gemessen           |

Die Verifizierung des gewrappten Proofs umfasst das Starten von Node zur Ausführung von snarkjs. Sie misst nicht den nativen Verifier des Sidecars. Die 1.344 Byte große Wire-Form enthält 768 Byte Proof, 32 Byte Program Key, 32 Byte Recursion Root und 512 Byte öffentliche Werte.

## Start und Speicher

Diese Messwerte stammen aus demselben Benchmark vom 2026-10-03 mit ZisK 1.3.1-alpha.

| Messung                                                                                                                                      | Ergebnis                                                                           |
| -------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------- |
| Erster Lauf mit einem Transfer nach dem Löschen des ZisK-Caches und Leeren des Page-Caches; der Proving Key lag weiterhin auf der Festplatte | 123 s Laufzeit; die Proof-Erstellung dauerte 14,5 s                                |
| Start des Provers im laufenden Betrieb, wenn der kompilierte Cache des Guests bereits vorhanden ist                                          | Schlüssel in 7,0 s geladen, anschließend 9,5 s für die Registrierung des Programms |
| Erste Proof-Anfrage nach diesem Start                                                                                                        | 6,56 s                                                                             |
| Von `nvidia-smi`                                                                                                                             | 93,2 GiB                                                                           |
| Anstieg des Host-RAM bei einem Proof in einem frischen Prozess                                                                               | 27 bis 29 GiB plus 22,9 GiB gemeinsam genutzter Speicher                           |
| Anstieg des Host-RAM, während der laufende Prover Anfragen verarbeitete                                                                      | 3 GiB plus 22,9 GiB gemeinsam genutzter Speicher                                   |
| Von der PLONK-Umhüllung allein gemeldeter GPU-Speicher                                                                                       | 30.054.767.337 Byte, etwa 28,0 GiB                                                 |

Der Prover passt einen großen GPU-Puffer an die Grafikkarte an. Der Spitzenverbrauch war bei den kleinsten und größten Benchmark-Blöcken ungefähr gleich. Daraus lässt sich nicht ableiten, wie viel GPU-Speicher der gesamte Prover mindestens benötigt.

## Weitere aufgezeichnete Prüfungen

Am 04.10.2026 betraf der erste Transfer-Proof Block 1 auf einer temporären Kopie des Genesis-Blocks, nicht auf einer laufenden Chain: einen Transfer mit 21.000 Gas und 385.277 Guest-Schritten. Drei Proofs dauerten 6,33, 6,75 und 6,69 s. Der Verifier von ZisK und das Verifier-Crate des Repositorys überprüften den Proof. Eine Änderung der Chain-ID der Eingabe auf 1 veranlasste den Guest, sie ohne Proof abzulehnen.

Das Erstellen des Guest aus einem leeren Build-Ordner dauerte 125 s, einschließlich des Herunterladens von Abhängigkeiten. Zwei frische Checkouts dauerten 133 s und 126 s und erzeugten dasselbe ELF und dieselbe programVK. Das erste Program-Setup des Provers dauerte 43 s. Diese Zahlen stammen aus den Aufzeichnungen vom 04.10.2026, die im Metrikbericht und in der [Guest-README](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/guest/README.md).

Nach der Demo vom 05.10.2026 bestand die Browserprüfung des Blocks 3 im Explorer in 13 ms. Vom Klick bis zur Antwort vergingen etwa 0,35 s. Dies war eine einzelne Browserprüfung, kein Benchmark, und sie ist nicht aufgezeichnet unter `demo/results/`.

Die WebAssembly-Prüfung dauerte auf den CI-Runnern in Node 8 bis 32 ms. Bei diesem Test wurde ein Proof überprüft und anschließend ein nicht übereinstimmender Header abgelehnt. Es handelte sich weder um eine erfolgreiche Prüfung eines vollständigen Blocks noch um eine Browsermessung; siehe die [Verifier-README](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/explorer/verify/README.md).

## Was sich aus diesen Messungen nicht ableiten lässt

Es gibt keinen systematischen Benchmark für Contract-Aufrufe oder Precompiles. Beim Benchmark vom 03.10.2026 wurde der Upstream-Guest bis zu 105 Mgas verwendet; beim Benchmark vom 25.10.2026 kam der Guest von Ostia bis zu 1,31 Ggas zum Einsatz, und zwar auf einer Benchmark-Maschine. Kein derart großer Block wurde in Canton eingereicht. Es liegen keine aufgezeichneten Messungen mit mehr als einem gleichzeitig bearbeiteten Block vor. Auf einer Benchmark-Maschine wurde ein Prover mit zwei GPUs getestet; dabei waren die Proof-Zeiten um 25 bis 39 % kürzer (ein Proof verwendete beide GPUs), und alle Proofs wurden verifiziert. Diese Läufe sind hier nicht aufgezeichnet, und DevNet verwendet diesen Prover nicht.

Die Witness-Erstellung auf einem aufgewärmten Host und die native Sidecar-Verifizierung wurden nicht separat gemessen. Bei der Demo wurden Blöcke mit höchstens drei Transaktionen und einem Leg eingereicht. Auf DevNet waren die größten gemessenen Commits Blöcke mit 1.428 einfachen Transfers. Jeder Fall wurde nur einmal ausgeführt; die Ergebnisse zeigen daher nicht, wie stark die Laufzeiten zwischen den Durchläufen variieren.

Die einstündige DevNet-Last vom 24.10.2026 erreichte das Limit der Chain nicht: Das RPC-Budget des Clients beendete den Anstieg zuerst, und kein Block enthielt mehr als 84 Transaktionen. Bei diesem Lasttest gab es keinen Block mit mehr als 100 Transaktionen, keinen funktionierenden Oracle-Preis und keinen abgeschlossenen privaten Transfer; außerdem wurden die Korrekturen am Treiber nicht eine volle Stunde lang ausgeführt. Die Läufe vom 25.10.2026 erreichten das Limit bei einfachen Transfers, wo die Gas-Obergrenze greift.


---

# 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/canton-zk-evm/measurements.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.
