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

# Medições

Medições registradas de prova e liquidação com suas datas, hardware e limites.

Esta página reúne seis conjuntos de medições, do mais recente ao mais antigo: throughput da DevNet (2026-10-25), o maior bloco recebido pelo prover (2026-10-25, em uma máquina de benchmark), a carga mista de uma hora na Ostia DevNet (2026-10-24), os limites do explorer, a demonstração local (2026-10-05) e o benchmark do prover (2026-10-03). Eles mediram coisas diferentes. O benchmark de 2026-10-03 usou o guest upstream do reth sem modificações. As outras execuções do prover e da Ostia usaram o guest próprio da Ostia, com a verificação das regras da cadeia e o gateway.

Esta página descreve a versão `v0.1.0` e, quando indicado, o que a DevNet executa: em 2026-10-25 para os números abaixo e em 2026-11-19 para a tabela "Fixado agora". [Status](https://docs.rome.builders/pt-br/canton-zk-evm/status.md) indica o commit que a DevNet executa agora. Leia o [relatório completo de métricas](https://github.com/rome-protocol/canton-zk-evm/blob/main/docs/METRICS.md), os [resultados de uma hora](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/load/mixed/RESULTS-2026-10-24.md) e os [resultados da demonstração](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/demo/README.md#results).

Nas ferramentas da Ostia, dois intervalos são chamados de "commit". Ambos começam quando o builder envia `Advance`. O cartão Home e Stats do explorer termina com a resposta de Canton ao builder. O bloco do tile da página e a coluna "commit" dos resultados de uma hora terminam no horário em que Canton registra o bloco. Esta página especifica o intervalo sempre que cita um deles.

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

Essas execuções ocorreram na própria Ostia DevNet, com um participante, um builder e um prover. Os logs brutos não foram publicados; os números foram extraídos das anotações das execuções. Todas as transações enviadas se tornaram finais, e nenhuma transação que deveria ter sido bem-sucedida sofreu reversão. No pico da manhã, com 20.000 transferências, quatro foram perdidas no pool de transações do reth e enviadas novamente.

**Manhã, 08:11 a 08:45 UTC: o builder preenche blocos com base no gás usado.** A mudança foi contabilizar o gás usado pelas transações, em vez do gás declarado por elas. O limite de cada bloco foi de 65.536 bytes brutos de transações.

| Carga                                                        | Builder antigo    | Novo builder em saturação                                               | O que limitou                                             |
| ------------------------------------------------------------ | ----------------- | ----------------------------------------------------------------------- | --------------------------------------------------------- |
| Mista: 17 tipos de transação, cerca de 254 bytes brutos cada | cerca de 7,5 tx/s | cerca de 10,9 tx/s (10,1 durante todo o período de pico)                | o limite de 65.536 bytes, não o gás (17 M de 30 M usados) |
| Transferências simples: 21.000 unidades de gás cada          | não medido        | cerca de 26 tx/s (595 por bloco, um bloco a cada 23 s, aproximadamente) | o mesmo limite (12,5 M de 30 M de gás usados)             |

A carga mista acompanhou o ritmo com 10 tx/s enviadas e ficou para trás com 15; o acúmulo foi drenado em cerca de dois minutos. **A carga mista não foi medida novamente desde o pacote Daml 0.2.0.**

**Meio-dia, 11:36 a 11:46 UTC: após o pacote 0.2.0.** O pacote entrou em produção no bloco 1453 (11:29 UTC). Cada execução consistiu em um pico de 9.000 transferências simples enviadas de uma conta em cerca de 25 segundos, enquanto outro gerador enviava 3 transações por segundo em segundo plano. "Estável" contabiliza do corte do primeiro bloco completo até a finalização do último bloco completo.

| Limite de bytes brutos por bloco | Transferências por bloco | Prova  | Commit p50 / p95 | Do corte do bloco à finalização, p50 | Estável | Pico completo |
| -------------------------------- | ------------------------ | ------ | ---------------- | ------------------------------------ | ------- | ------------- |
| 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       |

As confirmações começam no envio `Advance`  à resposta do Canton. Com 196.608 bytes, o limite de bytes não é atingido: o limite de 30.000.000 de gas é o primeiro a valer, com 1.428 transferências simples (29.988.000 gas). Aumentar ainda mais o limite de bytes não muda nada para transferências simples. Passar de 131.072 para 196.608 aumentou o desempenho em apenas 8% (de 59 para 64 tx/s): o bloco cresceu 20%, mas a prova (de 12,1 para 13,3 s) e a confirmação também demoraram mais. Um bloco leva cerca de 20 a 23 segundos desde a criação até a finalização, com a prova e a confirmação ocorrendo em sequência e apenas um bloco em andamento. As anotações da execução registram um resultado definitivo para cada envio e nenhum timeout da API JSON em nenhum dos dois picos.

As anotações da execução informam que a versão 0.2.0 reduziu o trabalho Daml do participante por KB do argumento `Advance`  serializado. Por passagem — são duas —, o tempo caiu de cerca de 23 ms (envio) e 22 ms (verificação) para valores estimados de 4,7 a 4,8 ms e 3,4 a 4,1 ms, respectivamente, ou cerca de 3 ms em um bloco típico. Em blocos comuns de 35 a 54 transações, `Advance` a mediana foi de 3,9 s na versão 0.2.0 (blocos 1453 a 1457), contra 6,4 s na versão 0.1.0 (blocos 1440 a 1452).

As transferências simples são as transações mais baratas que existem, portanto 64 tx/s não é um número representativo de tráfego com muitos contratos. Foi executado um pico em cada limite, então não há variação a relatar.

## O maior bloco recebido pelo provador, 2026-10-25

Esta é uma máquina de benchmark, não a DevNet: uma máquina temporária com uma GPU NVIDIA RTX PRO 6000 Blackwell Server Edition (96 GB), 48 vCPUs e 176 GiB de RAM, utilizada das 03:35 às 04:35 UTC e depois excluída. O ZisK 1.3.1-alpha provou blocos de transferências simples com o guest da Ostia na versão v0.1.0. Todas as provas bem-sucedidas foram verificadas. Nenhum desses blocos foi confirmado no Canton; a última coluna mostra o tamanho dos dados que uma confirmação transportaria.

| Transferências no bloco | Gas    | Tempo de prova | Memória do provador (host) no pico | `Argumento` Advance |
| ----------------------- | ------ | -------------- | ---------------------------------- | ------------------- |
| 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             |

Um bloco de 62.500 transferências, com 1,31 bilhão de gas, foi provado em 284 s e passou na verificação. Blocos de 75.000 e 100.000 transferências falharam ao atingir o limite de 300 segundos do coordenador do ZisK, não por falta de memória. Cada transferência adicional custou cerca de 4,5 ms de prova, aproximadamente 220 transferências por segundo. Em 2026-10-25, o limite de gas da DevNet era 30.000.000, portanto seus blocos são muito menores. Considerando o limite padrão de 10 MiB por requisição do Canton, o tamanho da requisição, por si só, permitiria no máximo 45.557 transferências; esse cálculo é derivado dos tamanhos acima, e o limite específico da DevNet não foi consultado. O trabalho Daml do participante impediria primeiro um bloco desse tipo: a cerca de 3 a 5 ms por KB por passagem na versão 0.2.0, um argumento de 10,49 MB exigiria aproximadamente 60 a 105 segundos de trabalho nas duas passagens (uma extrapolação a partir de blocos de até cerca de 330 KB), muito além do timeout de 20 segundos da API JSON. Portanto, esse tamanho não foi confirmado no Canton e não poderia ser usado na DevNet com a configuração atual.

## Ostia DevNet: carga mista de uma hora, 2026-10-24

A carga foi executada uma vez contra o RPC público da [Ostia DevNet](https://docs.rome.builders/pt-br/canton-zk-evm/devnet.md) (chain 770101), das 12:59:28 às 13:59:58 UTC. A chain produziu os blocos 224 a 448, que contêm apenas as transações da carga. Foram enviadas 13.496 transações de 200 carteiras e 4 titulares verificados de ERC-3643, abrangendo 25 tipos de ação: transferências e cunhagens de ERC-20, ERC-721 e ERC-1155, transferências de ERC-3643 (T-REX), swaps e operações de liquidez Uniswap V2, transferências Merces com provas geradas no cliente e reversões intencionais. Todas as 13.496 foram finalizadas e nenhuma se perdeu. O RPC recusou mais 5 no envio devido a uma lacuna de nonce.

O driver enviou 2, 3, 4 e 4,5 transações por segundo durante dez minutos cada e, em seguida, 4,5 por vinte minutos. A cadeia processou 1,95, 2,98, 3,95, 4,58, 4,48 e 4,54 tx/s nas seis janelas de dez minutos. **O limite de taxa foi imposto pelo orçamento de RPC de um cliente, não pela cadeia.** O RPC público permite 300 chamadas por minuto para um cliente, e o driver se manteve em 285. O maior bloco tinha 84 transações, e o maior consumo de gas em um bloco foi de 7,89 Mgas, diante do limite de 30 Mgas. O provador ficou ocupado, no máximo, durante 0,56 de qualquer janela de dez minutos. Esta execução não encontrou o limite da cadeia.

| Blocos na hora         | Mediana   | p95       | Máximo    |
| ---------------------- | --------- | --------- | --------- |
| Transações em um bloco | 69        | 79        | 84        |
| Gas em um bloco        | 5,29 Mgas | 6,77 Mgas | 7,89 Mgas |
| Segundos entre blocos  | 17        | 18        | 19        |

### Prova e tempo até a finalização

O tempo de prova é o tempo que o provador leva para processar o bloco. O intervalo do bloco à finalização vai da criação do bloco até sua finalização em Canton. O intervalo de commit vai do envio pelo construtor `Advance` até o horário de registro do bloco em Canton.

| Transações no bloco | Blocos | Prova p50 / p95 (s)        | Bloco à finalização p50 / p95 (s) | Commit p50 / p95 (s) |
| ------------------- | ------ | -------------------------- | --------------------------------- | -------------------- |
| 1 a 10              | 2      | 7.41 / 7.47                | 8.52 / 8.61                       | 1.09 / 1.11          |
| 11 a 100            | 223    | 9.03 / 9.21                | 11.01 / 11.95                     | 2.03 / 2.86          |
| 101 ou mais         | 0      | nenhum bloco desse tamanho |                                   |                      |

O tempo de prova aumentou apenas um pouco com o tamanho do bloco: cerca de 7,9 s para os 36 blocos com 19 a 30 transações e cerca de 9,1 s para os 76 blocos com 76 a 84. Uma transação espera mais tempo do que o necessário para processar seu bloco. Da aceitação da transação pelo RPC até a finalização do bloco, considerando as três primeiras transações de cada bloco (673 transações), a mediana foi de 19,5 s, o p95 de 27,1 s e o máximo de 28,8 s.

### Quanto custa um bloco em Canton

Cada bloco corresponde a um comando `Advance` e o tráfego que ele custa é o `paidTrafficCost` informado no relatório de conclusão. Os 225 blocos têm esse dado: 15.654 bytes na mediana, 16.612 no p95 e 16.822 no máximo. O custo da hora foi de 3.285.181 bytes, cerca de 3,3 MB. A maior parte do tráfego de um bloco é fixa, cerca de 8,4 KB, e cada transação acrescenta cerca de 100 bytes (ajuste feito para a hora: aproximadamente 8.400 + 103 por transação). Um bloco com 1 a 10 transações custou 7.928 bytes na mediana, e um bloco com 61 a 100 transações custou 16.052.

### O que não funcionou

* **A RedStone não registrou nenhum preço.** O contrato `PriceVault` está implantado. O driver solicitou preços assinados 80 vezes nos gateways públicos da RedStone e não recebeu nenhum, porque eles recusam solicitações anônimas. Não enviou nenhuma chamada `record` O registro de preços exige um acordo de serviço de dados com a RedStone, que não estava disponível nesta execução.
* **57 reversões intencionais não reverteram.** No caso de swap com saída abaixo do mínimo, o driver definiu o mínimo com 6 casas decimais para um token que tem 18, então todos esses swaps foram executados. Isso era um bug no driver de carga, já corrigido. Os outros casos intencionais reverteram como previsto: 288 dos 345 no total.
* **4 transações falharam sem que devessem.** Três swaps e um unwrap falharam porque a carteira não tinha nenhum token. O driver contabilizou tokens de um swap que o RPC recusou no envio. A causa foi o controle de saldo do driver, não a cadeia.
* **5 envios foram recusados por uma lacuna de nonce.** Duas transações de uma carteira foram enviadas ao mesmo tempo, e a posterior chegou primeiro. Agora, o driver envia as transações de cada carteira em ordem de nonce. As correções ainda não foram testadas durante uma hora inteira.

### Os números em tempo real

A página [Stats do explorador](https://ostia.devnet.romeprotocol.xyz/stats) exibe esses números para qualquer período, e `/api/stats/summary` os fornece. Nas 24 horas até 2026-10-25 01:34 UTC, a cadeia produziu 417 blocos. Durante o período de atividade da cadeia, o intervalo mediano entre blocos foi de 16,6 s. O tempo de prova teve mediana de 8,0 s. Uma transação levou uma mediana de 19,2 s entre a aceitação e a finalização (p95 de 28,4 s). Os números da página Stats são atualizados continuamente e, portanto, descrevem o que aconteceu nas últimas 24 horas.

## Metas de desempenho do explorer

Os testes do explorer o avaliam com base em sete metas, de B1 a B7. Os números vêm de execuções de integração contínua em um runner compartilhado do GitHub com um banco de dados de teste, não do DevNet. A execução com 3.000.000 de transações é feita em cada pull request; a de 10.000.000 foi realizada uma vez, no tamanho especificado pelo projeto. B1 e B2 também têm uma medição na máquina de referência do explorer, que o repositório classifica como provisória porque o commit e o comando não foram registrados.

| Meta                                                                                                     | Alvo                                                                                                         | Medido                                                                                                                |
| -------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------- |
| B1 Indexar o bloco mais caro permitido pelo limite de 30 Mgas, primeira etapa (blocos, transações, logs) | No máximo 2.750 ms                                                                                           | 806 ms p50 na máquina de referência, em 2026-10-23; 2.116 ms no runner, na execução mais recente                      |
| B2 Ambas as etapas desse bloco (a segunda calcula saldos e transferências de tokens)                     | No máximo 12.750 ms                                                                                          | 3.998 ms p50 na máquina de referência; de 10,9 a 13,0 s no runner ao longo de seis execuções, com limite de 16.000 ms |
| B3 API a 200 solicitações por segundo: bloco, transação ou endereço, p95                                 | No máximo 100 ms                                                                                             | 22 ms com 3.000.000 de transações; 40 ms com 10.000.000                                                               |
| B3 Página de transações de um endereço; página de listagem; pesquisa; `getLogs`                          | No máximo 300, 200, 100 e 500 ms                                                                             | 18, 14, 7 e 12 ms com 3.000.000; 34, 30, 18 e 19 ms com 10.000.000                                                    |
| B4 Um novo bloco finalizado para 2.000 clientes de transmissão em tempo real, p95                        | No máximo 500 ms                                                                                             | 63 ms; 100 ms                                                                                                         |
| B5 Carregamento a frio da página a 10 Mbit/s e com ida e volta de 100 ms: Home, Block, Transaction       | Maior elemento com conteúdo renderizado em no máximo 2,0 s; no máximo 200 KB de scripts compactados com gzip | De 808 a 998 ms e 165 KB, mediana de duas execuções no navegador da versão reduzida do teste noturno                  |
| B6 Tamanho do banco de dados por milhão de transações                                                    | No máximo 2,5 GB                                                                                             | 1,24 GB; 1,22 GB, ambos antes da migração 0030; as execuções reduzidas mais recentes mediram de 1,68 a 1,71 GB        |
| B7 `/api/health`, p97.5                                                                                  | No máximo 50 ms; nenhuma resposta diferente de 200                                                           | 5 ms e 22 ms; nenhuma outra resposta                                                                                  |

Nas linhas B3 a B7, o primeiro número corresponde a 3.000.000 de transações e o segundo, a 10.000.000. O [relatório de métricas](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/docs/METRICS.md#the-api-at-scale-l2) contém o teste de carga, e a seção sobre [B1 e 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) contém as medições e suas limitações.

## Hardware

O benchmark e a demonstração usaram, cada um, uma GPU NVIDIA RTX PRO 6000 Blackwell Server Edition. Para a demonstração do Ostia, foram registrados apenas a GPU e o driver. O provador do DevNet é uma NVIDIA RTX PRO 6000 Blackwell Server Edition (96 GB) em uma máquina com 48 vCPUs, do mesmo tipo que a máquina usada no benchmark de 2026-10-03.

| Item                        | Benchmark do provador, 2026-10-03                                                        | Execuções do Ostia, 2026-10-05 |
| --------------------------- | ---------------------------------------------------------------------------------------- | ------------------------------ |
| CPU                         | AMD EPYC 9B45, 48 vCPUs; um soquete, dois threads por núcleo                             | Não registrado                 |
| RAM do host                 | 176 GiB, conforme informado pelo host                                                    | Não registrado                 |
| Memória da GPU              | 97.887 MiB, descritos como 96 GB; PCIe geração 5 x16                                     | Capacidade não registrada      |
| Driver                      | 580.178.04                                                                               | 580.178.04                     |
| CUDA                        | 13.0 no nível do driver; binários de GPU pré-compilados, sem o toolkit do CUDA instalado | Não registrado                 |
| Sistema operacional e disco | Ubuntu 22.04.5, disco de inicialização de 500 GB                                         | Não registrado                 |
| Node e snarkjs              | 20.18.0 e 0.7.6                                                                          | Não registrado                 |

## Versões fixadas

Essas versões estão em [PINS](https://github.com/rome-protocol/canton-zk-evm/blob/main/PINS) e no [relatório de métricas](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/docs/METRICS.md#software-versions). A versão do Node do host de benchmark acima é diferente da versão fixada para o provador.

### Versões fixadas atualmente e usadas pelo DevNet

| Componente                            | Versão                                                                                                                                                                                                                                                                                                                                                                    |
| ------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| ZisK                                  | 1.4.0-alpha (o DevNet migrou para ela no bloco 71864, em 2026-11-16; usou a 1.3.2-alpha a partir do bloco 15573, em 2026-10-27; as execuções desta página usaram a 1.3.1-alpha)                                                                                                                                                                                           |
| Código-fonte do guest upstream        | 0.14.0 (guest do DevNet a partir do bloco 71864; antes disso, e nas execuções desta página, usou a 0.13.1)                                                                                                                                                                                                                                                                |
| reth                                  | 2.11.0 (no DevNet desde 2026-11-19; antes disso, e nas execuções desta página, usou a 2.5.2)                                                                                                                                                                                                                                                                              |
| Canton                                | 3.7.2 (usado pelo validador do DevNet de Roma desde 2026-11-07; o sincronizador do DevNet está na versão 37 do protocolo desde 2026-11-18). As execuções do DevNet nesta página (2026-10-24 e 2026-10-25) foram realizadas no Canton 3.6.3, na versão 36 do protocolo; o benchmark de 2026-10-03 e a demonstração de 2026-10-05 foram realizados com os snapshots abaixo. |
| SDK do Daml para a chamada externa    | 3.6.0                                                                                                                                                                                                                                                                                                                                                                     |
| Compilador Daml                       | damlc 3.6.2, com destino ao Daml-LF 2.4                                                                                                                                                                                                                                                                                                                                   |
| SDK do Daml para testes com Script    | 3.5.12, com destino ao Daml-LF 2.1                                                                                                                                                                                                                                                                                                                                        |
| Java                                  | 21                                                                                                                                                                                                                                                                                                                                                                        |
| Rust                                  | 1.94.1                                                                                                                                                                                                                                                                                                                                                                    |
| Python do builder e da demonstração   | 3.12 ou mais recente                                                                                                                                                                                                                                                                                                                                                      |
| Node do provador e snarkjs            | 20.20.2 e 0.7.6                                                                                                                                                                                                                                                                                                                                                           |
| Node do Explorer                      | 22.18 ou mais recente localmente; 24 no contêiner e no CI                                                                                                                                                                                                                                                                                                                 |
| Compilador Solidity do token de teste | 0.8.28                                                                                                                                                                                                                                                                                                                                                                    |

### Usado nas execuções registradas

O benchmark de 2026-10-03 e a demonstração de 2026-10-05 foram realizados com snapshots do Canton e do compilador Daml. Os registros identificam os snapshots. As demais versões acima correspondem, exceto ZisK, o código-fonte do guest upstream e reth: essas execuções usaram 1.3.1-alpha, 0.13.1 e 2.5.2.

| Componente                         | Versão nas execuções registradas                                      |
| ---------------------------------- | --------------------------------------------------------------------- |
| Canton                             | 3.6.0-snapshot.20260930.20337.0.ve610bc8f                             |
| SDK do Daml para a chamada externa | 3.5.13-snapshot.20261001.145.0.v852bdd82                              |
| Compilador Daml                    | 3.6.0-snapshot.20260915.14804.0.v53478765, com destino ao Daml-LF 2.4 |

## Demonstração do Ostia: 2026-10-05

A demonstração passou nas verificações em 2026-10-05, em uma rede Canton local com uma GPU NVIDIA RTX PRO 6000 Blackwell Server Edition. Cada caso foi executado uma vez, com o provador já em execução, a partir do commit `6b445073163832e9023850f53678617d90dfc808`. Estes são resultados de testes individuais, não um benchmark.

TKA era o token de teste da EVM. TKB era o token de teste da Canton, e wTKB era sua versão encapsulada na EVM. U e V eram as partes de teste. Um bloco vazio de smoke test foi confirmado primeiro. Em seguida, um bloco de configuração implantou TKA e criou wTKB. As cinco execuções foram:

| Execução             | O que aconteceu                                                                                                         | Resultado                                                                                                                                                     | Tempo de prova                                                                       |
| -------------------- | ----------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------ |
| 1: depósito          | U depositou 10 TKB e resgatou 10 wTKB.                                                                                  | O registro do bloco 3 e os novos 10 TKB em posse do gateway vieram de uma única atualização da Canton.                                                        | 6,72 s                                                                               |
| 2: pagamento         | V pagou 10 TKA a U pelo gateway, em troca da alocação de 10 TKB de U para V. V também transferiu 1 TKA diretamente a U. | O registro do bloco 4 e os novos 10 TKB em posse de V vieram de uma única atualização. A transferência direta não gerou nenhuma perna.                        | 6,72 s                                                                               |
| 3: saque             | U queimou 4 wTKB e recebeu 4 TKB.                                                                                       | O registro do bloco 5 e os novos tokens em posse de U vieram de uma única atualização. A oferta de tokens encapsulados e a custódia do gateway caíram para 6. | 6,72 s                                                                               |
| 4: alocação retirada | U retirou a alocação do pagamento depois que a prova foi gerada.                                                        | A Canton rejeitou o bloco 6. O reenvio sem a perna também falhou. A compilação seguinte deixou o pagamento de fora e confirmou apenas a aprovação de V.       | 6,75 s para a compilação inicial; a segunda prova não foi cronometrada separadamente |
| 5: prova adulterada  | Um dígito hexadecimal da prova foi alterado.                                                                            | A Canton rejeitou o bloco 7 depois que o sidecar rejeitou a prova. O bloco mais recente permaneceu no 6.                                                      | 6,74 s antes da adulteração                                                          |

A prova encapsulada tinha 1.344 bytes. Os seis tempos de prova registrados para a configuração e as cinco execuções foram de 6,71 a 6,75 s, e a prova do bloco vazio levou 6,31 s. A pasta [results](https://github.com/rome-protocol/canton-zk-evm/tree/v0.1.0/demo/results) contém os registros. Esta tabela apresenta os tempos de cada caso:

| Caso                   | Bloco e gás usado                                                                                                       | Prova                                                                                        | Do arquivo de prova concluído até a saída do builder | Execução completa do builder        |
| ---------------------- | ----------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- | ---------------------------------------------------- | ----------------------------------- |
| Smoke test             | Bloco 1, vazio; 0 gás                                                                                                   | 6,31 s                                                                                       | 0,49 s                                               | 155,20 s                            |
| Configuração           | Bloco 2, duas transações; gás não registrado                                                                            | 6,71 s                                                                                       | Não registrado                                       | 8,00 s                              |
| Depósito               | Bloco 3, uma transação; 122.308 gás                                                                                     | 6,72 s                                                                                       | 0,66 s                                               | 8,14 s                              |
| Pagamento              | Bloco 4, três transações; 185.307 gás                                                                                   | 6,72 s                                                                                       | 0,42 s                                               | 7,87 s                              |
| Saque                  | Bloco 5, uma transação; 90.345 gás                                                                                      | 6,72 s                                                                                       | 0,58 s                                               | 8,02 s                              |
| Alocação retomada      | O bloco 6 foi rejeitado e, em seguida, reconstruído com uma transação e sem etapas; o consumo de gas não foi registrado | 6,75 s para a construção rejeitada; o segundo comprovante não foi cronometrado separadamente | O envio rejeitado não foi cronometrado               | 8,09 s rejeitado; 8,04 s confirmado |
| Comprovante adulterado | O bloco 7 foi rejeitado; o consumo de gas não foi registrado                                                            | 6,74 s antes da adulteração                                                                  | O envio rejeitado não foi cronometrado               | 7,57 s                              |

Cada comprovante tinha 1.344 bytes. O intervalo entre a conclusão do arquivo do comprovante e a saída do construtor inclui a busca dos comprovantes de conta e de armazenamento do gateway, `Advance`, a confirmação em ambos os participantes confirmadores e a marcação do bloco como final pelo reth. Esse intervalo é maior do que apenas a confirmação do Canton. A correspondência entre as etapas e os contratos do Canton ocorre antes da geração do comprovante e fica fora desse intervalo.

A execução completa do teste de fumaça inclui a preparação do witness e das entradas, além da configuração inicial do programa convidado pelo provador. Também pode incluir a compilação da ferramenta de entrada. Os tempos separados dessas etapas não foram registrados.

## Benchmark do provador: 2026-10-03

A tabela mostra os tempos medianos, em segundos, de três execuções com aquecimento para cada tamanho de bloco. Cada bloco continha transferências simples. Todos os comprovantes passaram na verificação `cargo-zisk verify`. Os logs brutos do benchmark não estão no repositório.

| Bloco                          | Comprovante sem wrap, processo novo | Somente wrap, processo novo | Comprovante com wrap, processo novo | Processo novo completo | Provador em execução: da entrada ao comprovante com wrap | Provador em execução: da entrada ao comprovante verificado |
| ------------------------------ | ----------------------------------- | --------------------------- | ----------------------------------- | ---------------------- | -------------------------------------------------------- | ---------------------------------------------------------- |
| 1 transferência, 21 kgas       | 4.6                                 | 2.4                         | 7.4                                 | 21.1                   | 6.7                                                      | 7.0                                                        |
| 1.000 transferências, 21 Mgas  | 6.9                                 | 2.4                         | 9.6                                 | 24.5                   | 9.0                                                      | 9.3                                                        |
| 5.000 transferências, 105 Mgas | 17.9                                | 2.4                         | 20.8                                | 34.9                   | 21.2                                                     | 21.5                                                       |

O provador em execução manteve o coordenador, o worker e as chaves carregados. Os tempos totais de processo novo incluem a inicialização e o encerramento do provador. Os tempos da entrada ao comprovante começam com um arquivo witness existente; eles não medem a criação do witness. O caso de 105 Mgas foi um benchmark do programa convidado upstream, não de um bloco Ostia. O limite de gas fixado para os blocos Ostia é 30.000.000.

| Medição do comprovante            | PLONK com wrap      | STARK sem wrap          |
| --------------------------------- | ------------------- | ----------------------- |
| Tamanho do arquivo do comprovante | 2.942 a 2.944 bytes | 415.232 a 415.234 bytes |
| `cargo-zisk verify` tempo         | 0,29 a 0,30 s       | 0,03 s                  |
| Tamanho na transmissão            | 1.344 bytes         | Não medido              |

A verificação do comprovante com wrap inclui a inicialização do Node para executar o snarkjs. Não é uma medição do verificador nativo do sidecar. A representação de 1.344 bytes transmitida contém 768 bytes do comprovante, 32 bytes da chave do programa, 32 bytes da raiz de recursão e 512 bytes de valores públicos.

## Inicialização e memória

Estas medições são do mesmo benchmark de 2026-10-03, com ZisK 1.3.1-alpha.

| Medição                                                                                                                                        | Resultado                                                                   |
| ---------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------- |
| Primeira execução com 1 transferência após excluir o cache do ZisK e limpar o cache de páginas, mantendo a chave de geração de provas no disco | 123 s de tempo decorrido; o trabalho de geração do comprovante levou 14,5 s |
| Inicialização do provador em execução com o cache compilado do programa convidado já presente                                                  | Chaves carregadas em 7,0 s; depois, mais 9,5 s para registrar o programa    |
| Primeira solicitação de geração de comprovante após essa inicialização                                                                         | 6,56 s                                                                      |
| Pico de memória da GPU informado por `nvidia-smi`                                                                                              | 93,2 GiB                                                                    |
| Aumento da RAM do host durante uma prova em um processo recém-iniciado                                                                         | de 27 a 29 GiB, mais 22,9 GiB de memória compartilhada                      |
| Aumento da RAM do host enquanto o provador em execução atendia às solicitações                                                                 | 3 GiB, mais 22,9 GiB de memória compartilhada                               |
| Memória da GPU informada apenas para o wrap PLONK                                                                                              | 30.054.767.337 bytes, cerca de 28,0 GiB                                     |

O provador dimensiona um buffer grande da GPU de acordo com a placa. O pico de uso foi aproximadamente o mesmo para os menores e os maiores blocos do benchmark. Isso não estabelece a quantidade mínima de memória da GPU necessária para o provador inteiro.

## Outras verificações registradas

Em 2026-10-04, a primeira prova de transferência cobriu o bloco 1 em uma cópia temporária do bloco gênese, não em uma cadeia em execução: uma transferência de 21.000 gas e 385.277 etapas do guest. Três provas levaram 6,33, 6,75 e 6,69 s. O verificador do ZisK e a crate de verificação do repositório validaram a prova. Alterar o chain id da entrada para 1 fez o guest recusá-la sem gerar uma prova.

A compilação do guest a partir de uma pasta de build vazia levou 125 s, incluindo o download das dependências. Dois clones novos levaram 133 s e 126 s e produziram o mesmo ELF e programVK entre si. A primeira configuração do programa pelo provador levou 43 s. Esses números vêm dos registros de 2026-10-04 descritos no relatório de métricas e no [README do guest](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/guest/README.md).

Após a demonstração de 2026-10-05, a verificação do bloco 3 pelo explorador no navegador foi concluída em 13 ms. Da ação de clicar até a resposta, transcorreram cerca de 0,35 s. Foi uma única verificação no navegador, não um benchmark, e ela não está registrada em `demo/results/`.

A verificação em WebAssembly levou de 8 a 32 ms no Node, em executores de CI. Esse teste validou uma prova e, em seguida, rejeitou um cabeçalho incompatível. Não foi uma verificação bem-sucedida de bloco completo nem uma medição em navegador; consulte o [README do verificador](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/explorer/verify/README.md).

## O que essas medições não demonstram

Não há um benchmark sistemático de chamadas de contratos ou precompilações. O benchmark de 2026-10-03 usou o guest upstream até 105 Mgas; o benchmark de 2026-10-25 usou o guest da Ostia até 1,31 Ggas, em uma máquina de benchmark, e nenhum bloco desse tamanho foi submetido à Canton. Não há medições registradas com mais de um bloco em processamento simultâneo. Um provador com duas GPUs foi testado em uma máquina de benchmark, onde os tempos de prova foram de 25 a 39% menores (uma prova usando as duas GPUs) e todas as provas foram validadas; essas execuções não estão registradas aqui, e o DevNet não usa essa configuração.

A construção do witness em um host aquecido e a verificação nativa do sidecar não foram cronometradas separadamente. A demonstração submeteu blocos com no máximo três transações e uma perna. No DevNet, os maiores blocos submetidos que foram medidos continham 1.428 transferências simples. Cada caso foi executado uma vez, portanto os resultados não mostram quanto os tempos variam entre execuções.

A carga de uma hora no DevNet em 2026-10-24 não atingiu o limite da cadeia: o orçamento de RPC do cliente interrompeu o aumento antes, e nenhum bloco continha mais de 84 transações. Nessa carga, não houve bloco com mais de 100 transações, preço de oráculo funcional nem transferência privada liquidada, e as correções do driver não foram executadas durante uma hora inteira. As execuções de 2026-10-25 atingiram, sim, o limite para transferências simples, determinado pelo teto de gas.


---

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