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

# Measurements

Recorded proof and settlement measurements with their dates, hardware and limits.

This page holds six sets of measurements, newest first: DevNet throughput (2026-10-25), the largest block the prover was given (2026-10-25, on a benchmark machine), the one-hour mixed load on Ostia DevNet (2026-10-24), the explorer's budgets, the local demo (2026-10-05) and the prover benchmark (2026-10-03). They measured different things. The 2026-10-03 benchmark used the unmodified upstream reth guest. The other prover and Ostia runs used Ostia's own guest, with its chain-rules check and the gateway.

This page describes release `v0.1.0` and, where it says so, what DevNet runs, as of 2026-10-25 for the figures below and as of 2026-11-19 for the "Pinned now" table. [Status](https://docs.rome.builders/canton-zk-evm/status.md) names the commit DevNet runs now. Read the full [metrics report](https://github.com/rome-protocol/canton-zk-evm/blob/main/docs/METRICS.md), the [one-hour results](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/load/mixed/RESULTS-2026-10-24.md) and the [demo results](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/demo/README.md#results).

Two intervals are both called "commit" in Ostia's tools. Both start when the builder submits `Advance`. The explorer's Home and Stats card ends at Canton's answer to the builder. The block page's tile and the one-hour results' "commit" column end at Canton's record time for the block. This page names the interval wherever it quotes either.

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

These runs were on Ostia DevNet itself, with one participant, one builder and one prover. The raw logs are not published; the figures come from the notes of the runs. Every transaction sent became final, and none meant to succeed reverted. In the morning's burst of 20,000 transfers, four were lost from reth's transaction pool and were sent again.

**Morning, 08:11 to 08:45 UTC: the builder fills blocks by gas used.** The change was to count the gas transactions use instead of the gas they declare. A block was capped at 65,536 raw bytes of transactions.

| Load                                                     | Old builder    | New builder at saturation                               | What bound it                                    |
| -------------------------------------------------------- | -------------- | ------------------------------------------------------- | ------------------------------------------------ |
| Mixed: 17 kinds of transaction, about 254 raw bytes each | about 7.5 tx/s | about 10.9 tx/s (10.1 over the whole busy window)       | the 65,536-byte cap, not gas (17 M of 30 M used) |
| Plain transfers: 21,000 gas each                         | not measured   | about 26 tx/s (595 per block, a block about every 23 s) | the same cap (12.5 M of 30 M gas used)           |

The mixed load kept up at 10 tx/s sent and fell behind at 15; the backlog drained in about two minutes. **The mixed load has not been measured again since Daml package 0.2.0.**

**Midday, 11:36 to 11:46 UTC: after package 0.2.0.** The package went live at block 1453 (11:29 UTC). Each run was a burst of 9,000 plain transfers sent from one account in about 25 seconds, with another driver sending 3 transactions a second in the background. "Steady" counts from the first full block being cut to the last full block being final.

| Cap on raw bytes per block | Transfers per block | Proof  | Commit p50 / p95 | Block cut to final, p50 | Steady  | Whole burst |
| -------------------------- | ------------------- | ------ | ---------------- | ----------------------- | ------- | ----------- |
| 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 tx/s     |

Commit runs from submitting `Advance` to Canton's answer. At 196,608 bytes the byte cap is not reached: the 30,000,000 gas cap binds first, at 1,428 plain transfers (29,988,000 gas). Raising the byte cap further changes nothing for plain transfers. Going from 131,072 to 196,608 added only 8% (59 to 64 tx/s): the block grew 20%, but the proof (12.1 to 13.3 s) and the commit took longer too. A block takes about 20 to 23 seconds from cut to final, with the proof and the commit one after the other and one block in flight. The run notes report a definite outcome for every submission and no JSON API timeouts in either burst.

The run notes report that package 0.2.0 cut the participant's Daml work per KB of the serialized `Advance` argument. Per pass, and there are two, it fell from about 23 ms (submission) and 22 ms (check) to a fitted 4.7 to 4.8 ms and 3.4 to 4.1 ms, about 3 ms on a typical block. On ordinary blocks of 35 to 54 transactions, `Advance` took a median of 3.9 s under 0.2.0 (blocks 1453 to 1457) against 6.4 s under 0.1.0 (blocks 1440 to 1452).

Plain transfers are the cheapest transaction there is, so 64 tx/s is not a figure for contract-heavy traffic. One burst was run at each cap, so there is no spread to report.

## The largest block the prover was given, 2026-10-25

This is a benchmark machine, not DevNet: a temporary machine with one NVIDIA RTX PRO 6000 Blackwell Server Edition GPU (96 GB), 48 vCPUs and 176 GiB of RAM, run from 03:35 to 04:35 UTC and then deleted. ZisK 1.3.1-alpha proved blocks of plain transfers with Ostia's guest at v0.1.0. Every successful proof was checked. None of these blocks was committed to Canton; the last column is the size of the data a commit would carry.

| Transfers in the block | Gas    | Proof time | Prover memory (host) at peak | `Advance` argument |
| ---------------------- | ------ | ---------- | ---------------------------- | ------------------ |
| 1,000                  | 21 M   | 9.3 s      | 49 GB                        | 237 KB             |
| 5,000                  | 105 M  | 25.3 s     | 55 GB                        | 1.16 MB            |
| 10,000                 | 210 M  | 44.0 s     | 63 GB                        | 2.31 MB            |
| 20,000                 | 420 M  | 86.2 s     | 76 GB                        | 4.61 MB            |
| 45,557                 | 957 M  | 206.8 s    | 110 GB                       | 10.49 MB           |
| 50,000                 | 1.05 G | 228.4 s    | 108 GB                       | 11.5 MB            |
| 62,500                 | 1.31 G | 283.8 s    | 122 GB                       | 14.4 MB            |

A block of 62,500 transfers, 1.31 billion gas, proved in 284 s and passed verification. Blocks of 75,000 and 100,000 transfers failed on a 300-second limit in ZisK's coordinator, not on memory. Each added transfer cost about 4.5 ms of proving, about 220 transfers a second. DevNet's gas cap was 30,000,000 on 2026-10-25, so its blocks are far smaller. Under Canton's default 10 MiB request limit, the request size alone would allow at most 45,557 transfers; that is arithmetic from the sizes above, and DevNet's own limit was not read. The participant's Daml work would stop such a block first: at about 3 to 5 ms per KB per pass under 0.2.0, a 10.49 MB argument is roughly 60 to 105 seconds of work over the two passes (an extrapolation from blocks of up to about 330 KB), well past the 20-second JSON API timeout. So that size has not been committed to Canton, and could not be on DevNet as it is set up today.

## Ostia DevNet: one-hour mixed load, 2026-10-24

The load ran once against the public RPC of [Ostia DevNet](https://docs.rome.builders/canton-zk-evm/devnet.md) (chain 770101), from 12:59:28 to 13:59:58 UTC. The chain made blocks 224 to 448, which hold only the load's transactions. It sent 13,496 transactions from 200 wallets and 4 verified ERC-3643 holders, in 25 kinds of action: ERC-20, ERC-721 and ERC-1155 transfers and mints, ERC-3643 (T-REX) transfers, Uniswap V2 swaps and liquidity, Merces transfers with proofs made client-side, and deliberate reverts. All 13,496 became final and none was lost. The RPC refused 5 more at send, for a nonce gap.

The driver sent 2, 3, 4 and 4.5 transactions a second for ten minutes each, then 4.5 for twenty minutes. The chain took 1.95, 2.98, 3.95, 4.58, 4.48 and 4.54 tx/s in the six ten-minute windows. **One client's RPC budget capped the rate, not the chain.** The public RPC allows 300 calls a minute to one client, and the driver kept to 285. The largest block held 84 transactions, and the most gas in any block was 7.89 Mgas of the 30 Mgas cap. The prover was busy at most 0.56 of any ten-minute window. This run did not find the chain's limit.

| Blocks in the hour      | Median    | p95       | Max       |
| ----------------------- | --------- | --------- | --------- |
| Transactions in a block | 69        | 79        | 84        |
| Gas in a block          | 5.29 Mgas | 6.77 Mgas | 7.89 Mgas |
| Seconds between blocks  | 17        | 18        | 19        |

### Proof and time to final

Proof time is the prover's time for the block. Block to final runs from the block being made to its being final on Canton. Commit runs from the builder submitting `Advance` to Canton's record time for the block.

| Transactions in the block | Blocks | Proof p50 / p95 (s) | Block to final p50 / p95 (s) | Commit p50 / p95 (s) |
| ------------------------- | ------ | ------------------- | ---------------------------- | -------------------- |
| 1 to 10                   | 2      | 7.41 / 7.47         | 8.52 / 8.61                  | 1.09 / 1.11          |
| 11 to 100                 | 223    | 9.03 / 9.21         | 11.01 / 11.95                | 2.03 / 2.86          |
| 101 and more              | 0      | no block this size  |                              |                      |

Proof time rose only a little with block size: about 7.9 s for the 36 blocks of 19 to 30 transactions and about 9.1 s for the 76 blocks of 76 to 84. A transaction waits longer than its block takes. From the RPC accepting a transaction to its block being final, read for the first three transactions of each block (673 transactions), the median was 19.5 s, the p95 27.1 s and the maximum 28.8 s.

### What a block costs on Canton

Each block is one `Advance` command, and the traffic it costs is the `paidTrafficCost` its completion reports. All 225 blocks have it: 15,654 bytes at the median, 16,612 at the p95 and 16,822 at most. The hour cost 3,285,181 bytes, about 3.3 MB. Most of a block's traffic is fixed, about 8.4 KB, and each transaction adds about 100 bytes (a fit over the hour: about 8,400 + 103 per transaction). A block of 1 to 10 transactions cost 7,928 bytes at the median and one of 61 to 100 cost 16,052.

### What did not work

* **RedStone recorded no price.** The `PriceVault` contract is deployed. The driver asked RedStone's public gateways for signed prices 80 times and got none, because they refuse anonymous requests. It sent no `record` call. Recording prices needs a data-service arrangement with RedStone that this run did not have.
* **57 deliberate reverts did not revert.** The swap case with an output below the minimum set its minimum with 6 decimals for a token that has 18, so every one of those swaps went through. This was a bug in the load driver, now fixed. The other deliberate cases reverted as meant: 288 of the 345 in all.
* **4 transactions failed that should not have.** Three swaps and one unwrap failed because the wallet held none of the token. The driver had counted tokens from a swap that the RPC refused at send. The cause is the driver's bookkeeping, not the chain.
* **5 sends were refused for a nonce gap.** Two transactions of one wallet were sent at once and the later one arrived first. The driver now sends a wallet's transactions in nonce order. The fixes have not been run for a full hour.

### The live numbers

The explorer's [Stats page](https://ostia.devnet.romeprotocol.xyz/stats) shows these figures for any window, and `/api/stats/summary` serves them. In the 24 hours to 2026-10-25 01:34 UTC the chain made 417 blocks. Blocks came a median 16.6 s apart while the chain was busy. Proof time had a median of 8.0 s. A transaction took a median 19.2 s from acceptance to final (p95 28.4 s). The Stats page's figures roll forward, so they describe whatever the last 24 hours held.

## Explorer budgets

The explorer's tests hold it to seven budgets, B1 to B7. The figures come from continuous-integration runs on a shared GitHub runner with a test database, not from DevNet. The 3,000,000-transaction run is the one on every pull request; the 10,000,000 run was made once, at the size the design names. B1 and B2 also have a measurement on the explorer's reference machine, which the repository marks provisional because its commit and command were not recorded.

| Budget                                                                                        | Target                                                                   | Measured                                                                                                      |
| --------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------- |
| B1 Index the costliest block the 30 Mgas cap allows, first stage (blocks, transactions, logs) | At most 2,750 ms                                                         | 806 ms p50 on the reference machine, 2026-10-23; 2,116 ms on the runner, latest run                           |
| B2 Both stages of that block (the second derives balances and token transfers)                | At most 12,750 ms                                                        | 3,998 ms p50 on the reference machine; 10.9 to 13.0 s on the runner over six runs, which is held to 16,000 ms |
| B3 API at 200 requests a second: a block, transaction or address, p95                         | At most 100 ms                                                           | 22 ms at 3,000,000 transactions; 40 ms at 10,000,000                                                          |
| B3 An address's page of transactions; a list page; search; `getLogs`                          | At most 300, 200, 100 and 500 ms                                         | 18, 14, 7 and 12 ms at 3,000,000; 34, 30, 18 and 19 ms at 10,000,000                                          |
| B4 A new final block to 2,000 live-stream clients, p95                                        | At most 500 ms                                                           | 63 ms; 100 ms                                                                                                 |
| B5 Cold page load at 10 Mbit/s and 100 ms round trips: Home, Block, Transaction               | Largest contentful paint at most 2.0 s, at most 200 KB of gzipped script | 808 to 998 ms and 165 KB, median of two browser runs of the nightly test's short version                      |
| B6 Database size per million transactions                                                     | At most 2.5 GB                                                           | 1.24 GB; 1.22 GB, both before migration 0030; the latest short runs measured 1.68 to 1.71 GB                  |
| B7 `/api/health`, p97.5                                                                       | At most 50 ms, no answer other than 200                                  | 5 ms and 22 ms; no other answer                                                                               |

In the B3 to B7 rows, the first figure is for 3,000,000 transactions and the second for 10,000,000. The [metrics report](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/docs/METRICS.md#the-api-at-scale-l2) has the load test, and its section on [B1 and 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) has their measurement and its limits.

## Hardware

The benchmark and the demo each used one NVIDIA RTX PRO 6000 Blackwell Server Edition GPU. Only the GPU and driver were recorded for the Ostia demo. The DevNet prover is one NVIDIA RTX PRO 6000 Blackwell Server Edition (96 GB) on a 48-vCPU machine, the same kind of machine as the 2026-10-03 benchmark.

| Item                      | Prover benchmark, 2026-10-03                                               | Ostia runs, 2026-10-05 |
| ------------------------- | -------------------------------------------------------------------------- | ---------------------- |
| CPU                       | AMD EPYC 9B45, 48 vCPUs; one socket, two threads per core                  | Not recorded           |
| Host RAM                  | 176 GiB as reported by the host                                            | Not recorded           |
| GPU memory                | 97,887 MiB, described as 96 GB; PCIe gen 5 x16                             | Capacity not recorded  |
| Driver                    | 580.178.04                                                                 | 580.178.04             |
| CUDA                      | 13.0 at the driver level; prebuilt GPU binaries, no CUDA toolkit installed | Not recorded           |
| Operating system and disk | Ubuntu 22.04.5, 500 GB boot disk                                           | Not recorded           |
| Node and snarkjs          | 20.18.0 and 0.7.6                                                          | Not recorded           |

## Pinned versions

These versions are in [PINS](https://github.com/rome-protocol/canton-zk-evm/blob/main/PINS) and the [metrics report](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/docs/METRICS.md#software-versions). The benchmark host's Node version above differs from the prover's pin.

### Pinned now, and what DevNet runs

| Component                      | Version                                                                                                                                                                                                                                                                                               |
| ------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| ZisK                           | 1.4.0-alpha (DevNet moved to it at block 71864, 2026-11-16; it ran 1.3.2-alpha from block 15573, 2026-10-27; the runs on this page used 1.3.1-alpha)                                                                                                                                                  |
| Upstream guest source          | 0.14.0 (DevNet's guest from block 71864; 0.13.1 before it and in the runs on this page)                                                                                                                                                                                                               |
| reth                           | 2.11.0 (DevNet since 2026-11-19; 2.5.2 before it and in the runs on this page)                                                                                                                                                                                                                        |
| Canton                         | 3.7.2 (Rome's DevNet validator since 2026-11-07; DevNet's synchronizer is at protocol version 37 since 2026-11-18). The DevNet runs on this page (2026-10-24 and 2026-10-25) ran on Canton 3.6.3 at protocol version 36; the 2026-10-03 benchmark and the 2026-10-05 demo ran on the snapshots below. |
| Daml SDK for the external call | 3.6.0                                                                                                                                                                                                                                                                                                 |
| Daml compiler                  | damlc 3.6.2, targeting Daml-LF 2.4                                                                                                                                                                                                                                                                    |
| Daml SDK for Script tests      | 3.5.12, targeting Daml-LF 2.1                                                                                                                                                                                                                                                                         |
| Java                           | 21                                                                                                                                                                                                                                                                                                    |
| Rust                           | 1.94.1                                                                                                                                                                                                                                                                                                |
| Builder and demo Python        | 3.12 or newer                                                                                                                                                                                                                                                                                         |
| Prover Node and snarkjs        | 20.20.2 and 0.7.6                                                                                                                                                                                                                                                                                     |
| Explorer Node                  | 22.18 or newer locally; 24 in the container and CI                                                                                                                                                                                                                                                    |
| Test-token Solidity compiler   | 0.8.28                                                                                                                                                                                                                                                                                                |

### Used by the recorded runs

The 2026-10-03 benchmark and the 2026-10-05 demo ran on snapshots of Canton and the Daml compiler. Their records name the snapshots. The other versions above match, except ZisK, the upstream guest source and reth: these runs used 1.3.1-alpha, 0.13.1 and 2.5.2.

| Component                      | Version in the recorded runs                                     |
| ------------------------------ | ---------------------------------------------------------------- |
| Canton                         | 3.6.0-snapshot.20260930.20337.0.ve610bc8f                        |
| Daml SDK for the external call | 3.5.13-snapshot.20261001.145.0.v852bdd82                         |
| Daml compiler                  | 3.6.0-snapshot.20260915.14804.0.v53478765, targeting Daml-LF 2.4 |

## Ostia demo: 2026-10-05

The demo passed its checks on 2026-10-05, on a local Canton network with one NVIDIA RTX PRO 6000 Blackwell Server Edition GPU. Each case ran once, with the prover already running, from commit `6b445073163832e9023850f53678617d90dfc808`. These are individual test results, not a benchmark.

TKA was the EVM test token. TKB was the Canton test token, and wTKB was its wrapped form on the EVM. U and V were the test parties. An empty smoke block committed first. A setup block then deployed TKA and created wTKB. The five runs followed:

| Run                      | What happened                                                                                                    | Outcome                                                                                                                                    | Proof time                                                              |
| ------------------------ | ---------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------- |
| 1: deposit               | U deposited 10 TKB and claimed 10 wTKB.                                                                          | Block 3's record and the gateway's new 10 TKB holding came from one Canton update.                                                         | 6.72 s                                                                  |
| 2: payment               | V paid U 10 TKA through the gateway against U's allocation of 10 TKB to V. V also sent U a plain 1-TKA transfer. | Block 4's record and V's new 10 TKB holding came from one update. The plain transfer made no leg.                                          | 6.72 s                                                                  |
| 3: withdrawal            | U burnt 4 wTKB and received 4 TKB.                                                                               | Block 5's record and U's new holding came from one update. Wrapped supply and gateway custody fell to 6.                                   | 6.72 s                                                                  |
| 4: allocation taken back | U took back the payment's allocation after the proof was made.                                                   | Canton refused block 6. Resubmitting it without its leg also failed. The next build left out the payment and committed V's approval alone. | 6.75 s for the initial build; the second proof was not timed separately |
| 5: tampered proof        | One hex digit of the proof was changed.                                                                          | Canton refused block 7 after the sidecar rejected the proof. The head stayed at 6.                                                         | 6.74 s before tampering                                                 |

The wrapped proof was 1,344 bytes. The six recorded proof times for the setup and five runs were 6.71 to 6.75 s, and the empty block's proof took 6.31 s. The [results folder](https://github.com/rome-protocol/canton-zk-evm/tree/v0.1.0/demo/results) holds the records. This table gives the times for each case:

| Case                  | Block and gas used                                                               | Proof                                                           | Finished proof file to builder exit | Whole builder run                |
| --------------------- | -------------------------------------------------------------------------------- | --------------------------------------------------------------- | ----------------------------------- | -------------------------------- |
| Smoke                 | Block 1, empty; 0 gas                                                            | 6.31 s                                                          | 0.49 s                              | 155.20 s                         |
| Setup                 | Block 2, two transactions; gas not recorded                                      | 6.71 s                                                          | Not recorded                        | 8.00 s                           |
| Deposit               | Block 3, one transaction; 122,308 gas                                            | 6.72 s                                                          | 0.66 s                              | 8.14 s                           |
| Payment               | Block 4, three transactions; 185,307 gas                                         | 6.72 s                                                          | 0.42 s                              | 7.87 s                           |
| Withdrawal            | Block 5, one transaction; 90,345 gas                                             | 6.72 s                                                          | 0.58 s                              | 8.02 s                           |
| Allocation taken back | Block 6 refused, then rebuilt with one transaction and no legs; gas not recorded | 6.75 s for the refused build; second proof not timed separately | Refused submission not timed        | 8.09 s refused; 8.04 s committed |
| Tampered proof        | Block 7 refused; gas not recorded                                                | 6.74 s before tampering                                         | Refused submission not timed        | 7.57 s                           |

Each proof was 1,344 bytes. The interval from the finished proof file to builder exit includes fetching the gateway's account and storage proofs, `Advance`, commit on both confirming participants and reth marking the block final. It is longer than Canton's commit alone. Matching legs to Canton contracts happens before proving and is outside that interval.

The smoke test's whole run includes witness and input preparation and the prover's initial setup of the guest program. It may also include building the input tool. Separate times for those steps were not recorded.

## Prover benchmark: 2026-10-03

The table gives median times in seconds from three warm runs for each block size. Each block contained plain transfers. Every proof passed `cargo-zisk verify`. The raw benchmark logs are not in the repository.

| Block                     | Proof without wrap, fresh process | Wrap alone, fresh process | Proof with wrap, fresh process | Whole fresh process | Running prover: input to wrapped proof | Running prover: input to verified 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                                    |

The running prover kept the coordinator, worker and keys loaded. The fresh-process totals include starting and stopping the prover. Input-to-proof times start with an existing witness file; they do not measure building the witness. The 105 Mgas case was a benchmark of the upstream guest, not an Ostia block. Ostia's pinned block gas cap is 30,000,000.

| Proof measurement        | Wrapped PLONK        | Unwrapped STARK          |
| ------------------------ | -------------------- | ------------------------ |
| Proof file size          | 2,942 to 2,944 bytes | 415,232 to 415,234 bytes |
| `cargo-zisk verify` time | 0.29 to 0.30 s       | 0.03 s                   |
| Wire size                | 1,344 bytes          | Not measured             |

Verifying the wrapped proof includes starting Node to run snarkjs. It is not a measurement of the sidecar's native verifier. The 1,344-byte wire form contains 768 bytes of proof, 32 bytes of program key, 32 bytes of recursion root and 512 bytes of public values.

## Startup and memory

These measurements are from the same 2026-10-03 benchmark with ZisK 1.3.1-alpha.

| Measurement                                                                                                      | Result                                                   |
| ---------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------- |
| First 1-transfer run after deleting ZisK's cache and dropping the page cache, with the proving key still on disk | 123 s wall time; proof work took 14.5 s                  |
| Running prover startup with the guest's compiled cache already present                                           | Keys loaded in 7.0 s, then 9.5 s to register the program |
| First proof request after that startup                                                                           | 6.56 s                                                   |
| Peak GPU memory reported by `nvidia-smi`                                                                         | 93.2 GiB                                                 |
| Host RAM rise during a fresh-process proof                                                                       | 27 to 29 GiB, plus 22.9 GiB of shared memory             |
| Host RAM rise while the running prover served requests                                                           | 3 GiB, plus 22.9 GiB of shared memory                    |
| GPU memory reported for the PLONK wrap alone                                                                     | 30,054,767,337 bytes, about 28.0 GiB                     |

The prover sizes a large GPU buffer to the card. Peak use was about the same for the smallest and largest benchmark blocks. It does not establish the minimum GPU memory needed for the whole prover.

## Other recorded checks

On 2026-10-04, the first transfer proof covered block 1 on a temporary copy of the genesis, not a running chain: one 21,000-gas transfer and 385,277 guest steps. Three proofs took 6.33, 6.75 and 6.69 s. ZisK's verifier and the repository's verifier crate checked the proof. Changing the input's chain id to 1 made the guest refuse it without a proof.

Building the guest from an empty build folder took 125 s, including dependency download. Two fresh checkouts took 133 s and 126 s and produced the same ELF and programVK as each other. The prover's first program setup took 43 s. These figures come from the 2026-10-04 records described in the metrics report and [guest README](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/guest/README.md).

After the 2026-10-05 demo, the explorer's browser check of block 3 passed in 13 ms. About 0.35 s elapsed from the click to the answer. This was one browser check, not a benchmark, and is not recorded in `demo/results/`.

The WebAssembly check took 8 to 32 ms in Node on CI runners. That test verified a proof and then rejected a mismatched header. It was neither a successful full-block check nor a browser measurement; see the [verifier README](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/explorer/verify/README.md).

## What these measurements do not establish

There is no systematic benchmark of contract calls or precompiles. The 2026-10-03 benchmark used the upstream guest up to 105 Mgas; the 2026-10-25 benchmark used Ostia's guest up to 1.31 Ggas, on a benchmark machine, and no block that large was committed to Canton. There are no recorded measurements with more than one block in flight. A two-GPU prover was tried on a benchmark machine, where proof times were 25 to 39% shorter (one proof using both GPUs) and all verified; those runs are not recorded here, and DevNet does not use it.

Witness construction on a warm host and native sidecar verification have not been timed separately. The demo committed blocks with at most three transactions and one leg. On DevNet, the largest commits measured are blocks of 1,428 plain transfers. Each case ran once, so the results do not show how much timings vary between runs.

The one-hour DevNet load of 2026-10-24 did not reach the chain's limit: the client's RPC budget ended the climb first, and no block held more than 84 transactions. That load saw no block above 100 transactions, no working oracle price and no settled private transfer, and the driver's fixes were not run for a full hour. The runs of 2026-10-25 did reach the limit for plain transfers, where the gas cap binds.


---

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