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

# Mediciones

Mediciones registradas de la prueba y la liquidación con sus fechas, hardware y límites.

Esta página contiene seis conjuntos de mediciones, del más reciente al más antiguo: rendimiento de DevNet (2026-10-25), el bloque más grande que se entregó al prover (2026-10-25, en una máquina de pruebas de rendimiento), la carga mixta de una hora en Ostia DevNet (2026-10-24), los límites del explorador, la demostración local (2026-10-05) y la prueba de rendimiento del prover (2026-10-03). Midieron cosas distintas. La prueba del 2026-10-03 usó el guest de reth original, sin modificar. Las demás ejecuciones del prover y de Ostia usaron el guest propio de Ostia, con su comprobación de reglas de la cadena y la pasarela.

Esta página describe la versión `v0.1.0` y, cuando se indica, lo que ejecuta DevNet: las cifras de abajo corresponden al 2026-10-25 y la tabla «Fijado ahora», al 2026-11-19. [Estado](https://docs.rome.builders/es/canton-zk-evm/status.md) indica el commit que DevNet ejecuta ahora. Consulta el [informe completo de métricas](https://github.com/rome-protocol/canton-zk-evm/blob/main/docs/METRICS.md), los [resultados de una hora](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/load/mixed/RESULTS-2026-10-24.md) y los [resultados de la demostración](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/demo/README.md#results).

En las herramientas de Ostia, se llama «commit» a dos intervalos distintos. Ambos comienzan cuando el builder envía `Advance`. La tarjeta Inicio y Estadísticas del explorador termina con la respuesta de Canton al builder. El mosaico de la página del bloque y la columna «commit» de los resultados de una hora terminan con la hora en que Canton registra el bloque. Esta página especifica el intervalo cada vez que cita uno de los dos.

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

Estas ejecuciones se realizaron en la propia Ostia DevNet, con un participante, un builder y un prover. Los registros sin procesar no se han publicado; las cifras proceden de las notas de las ejecuciones. Todas las transacciones enviadas se finalizaron y ninguna transacción que debía tener éxito revirtió. En la ráfaga matutina de 20 000 transferencias, se perdieron cuatro de la cola de transacciones de reth y se volvieron a enviar.

**Por la mañana, de 08:11 a 08:45 UTC: el builder llena los bloques según el gas utilizado.** El cambio consistió en contar el gas que usan las transacciones, en vez del gas que declaran. El límite de cada bloque se fijó en 65 536 bytes sin procesar de transacciones.

| Carga                                                                | Builder anterior | Builder nuevo, al alcanzar el límite                               | Límite que se alcanzó                                         |
| -------------------------------------------------------------------- | ---------------- | ------------------------------------------------------------------ | ------------------------------------------------------------- |
| Mixta: 17 tipos de transacción, unos 254 bytes sin procesar cada una | unos 7,5 tx/s    | unos 10,9 tx/s (10,1 durante todo el periodo de mayor actividad)   | el límite de 65 536 bytes, no el gas (se usaron 17 M de 30 M) |
| Transferencias simples: 21 000 unidades de gas cada una              | no medido        | unos 26 tx/s (595 por bloque, un bloque aproximadamente cada 23 s) | el mismo límite (se usaron 12,5 M de 30 M de gas)             |

La carga mixta se mantuvo al día con 10 tx/s enviadas y se retrasó con 15; la cola pendiente se vació en unos dos minutos. **La carga mixta no se ha vuelto a medir desde Daml package 0.2.0.**

**Al mediodía, de 11:36 a 11:46 UTC: después de Daml package 0.2.0.** El paquete se activó en el bloque 1453 (11:29 UTC). Cada ejecución consistió en una ráfaga de 9 000 transferencias simples enviadas desde una cuenta en unos 25 segundos, mientras otro generador enviaba 3 transacciones por segundo en segundo plano. «Ritmo sostenido» se cuenta desde que se genera el primer bloque completo hasta que se finaliza el último bloque completo.

| Límite de bytes sin procesar por bloque | Transferencias por bloque | Prueba | Commit p50 / p95 | Desde el corte del bloque hasta su finalización, p50 | Ritmo sostenido | Ráfaga completa |
| --------------------------------------- | ------------------------- | ------ | ---------------- | ---------------------------------------------------- | --------------- | --------------- |
| 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         |

Las confirmaciones se ejecutan desde el envío `Advance` a la respuesta de Canton. Con 196,608 bytes no se alcanza el límite de bytes: el límite de 30,000,000 de gas se aplica primero, con 1,428 transferencias simples (29,988,000 de gas). Aumentar aún más el límite de bytes no cambia nada para las transferencias simples. Pasar de 131,072 a 196,608 solo añadió un 8 % (de 59 a 64 tx/s): el bloque creció un 20 %, pero la prueba (de 12.1 a 13.3 s) y la confirmación también tardaron más. Un bloque tarda unos 20 a 23 segundos desde que se crea hasta que queda finalizado, con la prueba y la confirmación una después de la otra y un bloque en curso. Las notas de ejecución indican que cada envío tuvo un resultado definitivo y que no hubo tiempos de espera agotados en la API JSON en ninguno de los dos picos de carga.

Las notas de ejecución indican que el paquete 0.2.0 redujo el trabajo de Daml del participante por KB del argumento serializado `Advance` . En cada pasada, y son dos, bajó de unos 23 ms (envío) y 22 ms (comprobación) a unos 4.7 a 4.8 ms y 3.4 a 4.1 ms, respectivamente: unos 3 ms en un bloque típico. En bloques corrientes de 35 a 54 transacciones, `Advance` la mediana fue de 3.9 s con 0.2.0 (bloques 1453 a 1457), frente a 6.4 s con 0.1.0 (bloques 1440 a 1452).

Las transferencias simples son las transacciones más baratas que existen, así que 64 tx/s no es una cifra representativa del tráfico con muchos contratos. Se ejecutó un único pico de carga con cada límite, por lo que no hay variabilidad que informar.

## El bloque más grande que recibió el probador, 2026-10-25

Esta es una máquina de pruebas de rendimiento, no DevNet: una máquina temporal con una GPU NVIDIA RTX PRO 6000 Blackwell Server Edition (96 GB), 48 vCPU y 176 GiB de RAM, que se usó de 03:35 a 04:35 UTC y luego se eliminó. ZisK 1.3.1-alpha probó bloques de transferencias simples con el entorno de ejecución invitado de Ostia en v0.1.0. Se comprobó cada prueba satisfactoria. Ninguno de estos bloques se confirmó en Canton; la última columna indica el tamaño de los datos que llevaría una confirmación.

| Transferencias en el bloque | Gas    | Tiempo de prueba | Memoria del probador (host) en el pico | `Argumento de` 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                |

Se probó un bloque de 62,500 transferencias y 1.31 mil millones de gas en 284 s, y superó la verificación. Los bloques de 75,000 y 100,000 transferencias excedieron el límite de 300 segundos del coordinador de ZisK, no la memoria. Cada transferencia añadida aumentó el tiempo de prueba en unos 4.5 ms, es decir, unas 220 transferencias por segundo. El 2026-10-25, el límite de gas de DevNet era de 30,000,000, por lo que sus bloques son mucho más pequeños. Con el límite predeterminado de 10 MiB por solicitud de Canton, el tamaño de la solicitud por sí solo permitiría como máximo 45,557 transferencias; es un cálculo basado en los tamaños anteriores y no se consultó el límite propio de DevNet. El trabajo de Daml del participante impediría primero un bloque de ese tamaño: a unos 3 a 5 ms por KB y por pasada con 0.2.0, un argumento de 10.49 MB representa aproximadamente entre 60 y 105 segundos de trabajo en las dos pasadas (una extrapolación a partir de bloques de hasta unos 330 KB), muy por encima del tiempo de espera de 20 segundos de la API JSON. Por tanto, ese tamaño no se ha confirmado en Canton, y tampoco podría confirmarse en DevNet con la configuración actual.

## Ostia DevNet: una hora de carga mixta, 2026-10-24

La carga se ejecutó una vez contra el RPC público de [Ostia DevNet](https://docs.rome.builders/es/canton-zk-evm/devnet.md) (cadena 770101), de 12:59:28 a 13:59:58 UTC. La cadena generó los bloques 224 a 448, que contienen únicamente las transacciones de la carga. Se enviaron 13,496 transacciones desde 200 monederos y 4 titulares verificados de ERC-3643, con 25 tipos de acciones: transferencias y acuñaciones de ERC-20, ERC-721 y ERC-1155, transferencias de ERC-3643 (T-REX), intercambios y provisión de liquidez de Uniswap V2, transferencias de Merces con pruebas generadas en el cliente y reversiones deliberadas. Las 13,496 llegaron a su estado final y no se perdió ninguna. El RPC rechazó otras 5 al enviarlas, debido a una brecha en los nonce.

El controlador envió 2, 3, 4 y 4,5 transacciones por segundo durante diez minutos cada vez, y luego 4,5 durante veinte minutos. La cadena procesó 1,95, 2,98, 3,95, 4,58, 4,48 y 4,54 tx/s en los seis intervalos de diez minutos. **El límite de solicitudes RPC de un cliente fue lo que limitó la tasa, no la cadena.** El RPC público permite 300 llamadas por minuto a un solo cliente, y el controlador se mantuvo en 285. El bloque más grande contenía 84 transacciones, y el mayor consumo de gas en un bloque fue de 7,89 Mgas, frente al límite de 30 Mgas. El probador estuvo ocupado como máximo durante 0,56 de cualquier intervalo de diez minutos. Esta ejecución no encontró el límite de la cadena.

| Bloques en una hora        | Mediana   | p95       | Máximo    |
| -------------------------- | --------- | --------- | --------- |
| Transacciones en un bloque | 69        | 79        | 84        |
| Gas en un bloque           | 5,29 Mgas | 6,77 Mgas | 7,89 Mgas |
| Segundos entre bloques     | 17        | 18        | 19        |

### Prueba y tiempo hasta la finalización

El tiempo de prueba es el tiempo que tarda el probador en procesar el bloque. El intervalo desde el bloque hasta la finalización abarca desde que se crea el bloque hasta que es final en Canton. El tiempo de confirmación abarca desde que el generador envía `Advance` hasta la hora de registro del bloque en Canton.

| Transacciones en el bloque | Bloques | p50 / p95 de la prueba (s)   | p50 / p95 del bloque hasta la finalización (s) | p50 / p95 de la confirmación (s) |
| -------------------------- | ------- | ---------------------------- | ---------------------------------------------- | -------------------------------- |
| De 1 a 10                  | 2       | 7.41 / 7.47                  | 8.52 / 8.61                                    | 1.09 / 1.11                      |
| De 11 a 100                | 223     | 9.03 / 9.21                  | 11.01 / 11.95                                  | 2.03 / 2.86                      |
| 101 o más                  | 0       | ningún bloque de este tamaño |                                                |                                  |

El tiempo de prueba apenas aumentó con el tamaño del bloque: unos 7,9 s para los 36 bloques de 19 a 30 transacciones y unos 9,1 s para los 76 bloques de 76 a 84. Una transacción espera más de lo que tarda su bloque. Desde que el RPC acepta una transacción hasta que su bloque es final, medido para las tres primeras transacciones de cada bloque (673 transacciones), la mediana fue de 19,5 s, el p95 de 27,1 s y el máximo de 28,8 s.

### Cuánto cuesta un bloque en Canton

Cada bloque es un comando `Advance` y el tráfico que cuesta es el `paidTrafficCost` que informan sus resultados. Los 225 bloques lo incluyen: 15.654 bytes en la mediana, 16.612 en el p95 y 16.822 como máximo. La hora costó 3.285.181 bytes, unos 3,3 MB. La mayor parte del tráfico de un bloque es fija, unos 8,4 KB, y cada transacción añade unos 100 bytes (un ajuste a lo largo de la hora: unos 8.400 + 103 por transacción). Un bloque de 1 a 10 transacciones costó 7.928 bytes en la mediana, y uno de 61 a 100 costó 16.052.

### Qué no funcionó

* **RedStone no registró ningún precio.** El contrato `PriceVault` está desplegado. El controlador solicitó precios firmados 80 veces a las puertas de enlace públicas de RedStone y no obtuvo ninguno, porque rechazan las solicitudes anónimas. No envió ninguna llamada `record` Registrar precios requiere un acuerdo de servicio de datos con RedStone, que no se tenía para esta ejecución.
* **57 reversiones intencionadas no revirtieron.** En el caso de intercambio con un resultado inferior al mínimo, el mínimo se estableció con 6 decimales para un token que tiene 18, así que todos esos intercambios se ejecutaron. Era un error en el controlador de carga, que ya se corrigió. Los demás casos intencionados revirtieron como se esperaba: 288 de los 345 en total.
* **4 transacciones fallaron cuando no deberían haberlo hecho.** Fallaron tres intercambios y una conversión de envoltorio porque la cartera no tenía ningún token. El controlador había contabilizado tokens de un intercambio cuyo envío rechazó el RPC. La causa está en la contabilidad del controlador, no en la cadena.
* **Se rechazaron 5 envíos por un salto en el nonce.** Se enviaron a la vez dos transacciones de una misma cartera y la posterior llegó primero. Ahora el controlador envía las transacciones de cada cartera en orden de nonce. Las correcciones no se han probado durante una hora completa.

### Las cifras en tiempo real

La [página de estadísticas](https://ostia.devnet.romeprotocol.xyz/stats) del explorador muestra estas cifras para cualquier intervalo, y `/api/stats/summary` los sirve. En las 24 horas hasta el 2026-10-25 01:34 UTC, la cadena produjo 417 bloques. Mientras la cadena estuvo ocupada, el intervalo mediano entre bloques fue de 16,6 s. El tiempo de prueba tuvo una mediana de 8,0 s. Una transacción tardó una mediana de 19,2 s desde su aceptación hasta su finalización (p95: 28,4 s). Las cifras de la página Stats se actualizan continuamente, por lo que describen lo ocurrido en las últimas 24 horas.

## Presupuestos del explorador

Las pruebas del explorador lo someten a siete presupuestos, del B1 al B7. Las cifras proceden de ejecuciones de integración continua en un runner compartido de GitHub con una base de datos de prueba, no de DevNet. La ejecución con 3.000.000 de transacciones se realiza en cada solicitud de incorporación de cambios; la de 10.000.000 se hizo una vez, con el tamaño especificado en el diseño. B1 y B2 también tienen una medición en el equipo de referencia del explorador, que el repositorio marca como provisional porque no se registraron el commit ni el comando.

| Presupuesto                                                                                                          | Objetivo                                                                                                          | Medición                                                                                                                  |
| -------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------- |
| B1 Indexar el bloque más costoso que permite el límite de 30 Mgas, primera etapa (bloques, transacciones, registros) | Como máximo 2.750 ms                                                                                              | 806 ms p50 en el equipo de referencia, 2026-10-23; 2.116 ms en el runner, última ejecución                                |
| B2 Las dos etapas de ese bloque (la segunda calcula los saldos y las transferencias de tokens)                       | Como máximo 12.750 ms                                                                                             | 3.998 ms p50 en el equipo de referencia; entre 10,9 y 13,0 s en el runner en seis ejecuciones, con un límite de 16.000 ms |
| B3 API con 200 solicitudes por segundo: un bloque, una transacción o una dirección, p95                              | Como máximo 100 ms                                                                                                | 22 ms con 3.000.000 de transacciones; 40 ms con 10.000.000                                                                |
| B3 Página de transacciones de una dirección; página de lista; búsqueda; `getLogs`                                    | Como máximo 300, 200, 100 y 500 ms                                                                                | 18, 14, 7 y 12 ms con 3.000.000; 34, 30, 18 y 19 ms con 10.000.000                                                        |
| B4 Un nuevo bloque final para 2.000 clientes de flujo en vivo, p95                                                   | Como máximo 500 ms                                                                                                | 63 ms; 100 ms                                                                                                             |
| B5 Carga en frío de páginas a 10 Mbit/s y con tiempos de ida y vuelta de 100 ms: inicio, bloque, transacción         | Pintado del mayor elemento de contenido en un máximo de 2,0 s; como máximo 200 KB de scripts comprimidos con gzip | De 808 a 998 ms y 165 KB, mediana de dos ejecuciones del navegador de la versión breve de la prueba nocturna              |
| B6 Tamaño de la base de datos por millón de transacciones                                                            | Como máximo 2,5 GB                                                                                                | 1,24 GB; 1,22 GB, ambos antes de la migración 0030; las últimas ejecuciones breves midieron entre 1,68 y 1,71 GB          |
| B7 `/api/health`, p97.5                                                                                              | Como máximo 50 ms, ninguna respuesta distinta de 200                                                              | 5 ms y 22 ms; ninguna otra respuesta                                                                                      |

En las filas B3 a B7, la primera cifra corresponde a 3.000.000 de transacciones y la segunda a 10.000.000. El [informe de métricas](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/docs/METRICS.md#the-api-at-scale-l2) incluye la prueba de carga, y su sección sobre [B1 y 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) incluye sus mediciones y sus limitaciones.

## Hardware

Tanto la prueba de rendimiento como la demostración utilizaron una GPU NVIDIA RTX PRO 6000 Blackwell Server Edition. Para la demostración de Ostia solo se registraron la GPU y el controlador. El probador de DevNet es una NVIDIA RTX PRO 6000 Blackwell Server Edition (96 GB) en una máquina de 48 vCPU, del mismo tipo que la máquina utilizada en la prueba de rendimiento del 2026-10-03.

| Elemento                  | Prueba de rendimiento del probador, 2026-10-03                                                         | Ejecuciones de Ostia, 2026-10-05 |
| ------------------------- | ------------------------------------------------------------------------------------------------------ | -------------------------------- |
| CPU                       | AMD EPYC 9B45, 48 vCPU; un socket, dos subprocesos por núcleo                                          | No registrado                    |
| RAM del host              | 176 GiB, según lo informado por el host                                                                | No registrado                    |
| Memoria de la GPU         | 97,887 MiB, descrita como 96 GB; PCIe gen 5 x16                                                        | Capacidad no registrada          |
| Controlador               | 580.178.04                                                                                             | 580.178.04                       |
| CUDA                      | 13.0 a nivel del controlador; binarios de GPU precompilados, sin el kit de herramientas CUDA instalado | No registrado                    |
| Sistema operativo y disco | Ubuntu 22.04.5, disco de arranque de 500 GB                                                            | No registrado                    |
| Node y snarkjs            | 20.18.0 y 0.7.6                                                                                        | No registrado                    |

## Versiones fijadas

Estas versiones están en [PINS](https://github.com/rome-protocol/canton-zk-evm/blob/main/PINS) y en el [informe de métricas](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/docs/METRICS.md#software-versions). La versión de Node del host de referencia indicada arriba difiere de la versión fijada para el prover.

### Versiones fijadas actualmente y las que ejecuta DevNet

| Componente                                     | Versión                                                                                                                                                                                                                                                                                                                                                                                                              |
| ---------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| ZisK                                           | 1.4.0-alpha (DevNet pasó a esta versión en el bloque 71864, el 2026-11-16; ejecutó 1.3.2-alpha desde el bloque 15573, el 2026-10-27; las ejecuciones de esta página usaron 1.3.1-alpha)                                                                                                                                                                                                                              |
| Código fuente upstream del guest               | 0.14.0 (guest de DevNet desde el bloque 71864; antes de esa fecha y en las ejecuciones de esta página, 0.13.1)                                                                                                                                                                                                                                                                                                       |
| reth                                           | 2.11.0 (DevNet la usa desde el 2026-11-19; antes de esa fecha y en las ejecuciones de esta página, 2.5.2)                                                                                                                                                                                                                                                                                                            |
| Canton                                         | 3.7.2 (el validador de DevNet de Roma la usa desde el 2026-11-07; el sincronizador de DevNet está en la versión 37 del protocolo desde el 2026-11-18). Las ejecuciones de DevNet de esta página (2026-10-24 y 2026-10-25) se realizaron con Canton 3.6.3 y la versión 36 del protocolo; la prueba de rendimiento del 2026-10-03 y la demostración del 2026-10-05 se realizaron con las instantáneas indicadas abajo. |
| SDK de Daml para la llamada externa            | 3.6.0                                                                                                                                                                                                                                                                                                                                                                                                                |
| Compilador de Daml                             | damlc 3.6.2, con destino Daml-LF 2.4                                                                                                                                                                                                                                                                                                                                                                                 |
| SDK de Daml para pruebas de Script             | 3.5.12, con destino Daml-LF 2.1                                                                                                                                                                                                                                                                                                                                                                                      |
| Java                                           | 21                                                                                                                                                                                                                                                                                                                                                                                                                   |
| Rust                                           | 1.94.1                                                                                                                                                                                                                                                                                                                                                                                                               |
| Python del generador y la demostración         | 3.12 o posterior                                                                                                                                                                                                                                                                                                                                                                                                     |
| Node del prover y snarkjs                      | 20.20.2 y 0.7.6                                                                                                                                                                                                                                                                                                                                                                                                      |
| Node del explorador                            | 22.18 o posterior en local; 24 en el contenedor y CI                                                                                                                                                                                                                                                                                                                                                                 |
| Compilador de Solidity para el token de prueba | 0.8.28                                                                                                                                                                                                                                                                                                                                                                                                               |

### Usado en las ejecuciones registradas

La prueba de rendimiento del 2026-10-03 y la demostración del 2026-10-05 se realizaron con instantáneas de Canton y del compilador de Daml. Los registros indican las instantáneas. Las demás versiones indicadas arriba coinciden, excepto ZisK, el código fuente upstream del guest y reth: estas ejecuciones usaron 1.3.1-alpha, 0.13.1 y 2.5.2.

| Componente                          | Versión en las ejecuciones registradas                             |
| ----------------------------------- | ------------------------------------------------------------------ |
| Canton                              | 3.6.0-snapshot.20260930.20337.0.ve610bc8f                          |
| SDK de Daml para la llamada externa | 3.5.13-snapshot.20261001.145.0.v852bdd82                           |
| Compilador de Daml                  | 3.6.0-snapshot.20260915.14804.0.v53478765, con destino Daml-LF 2.4 |

## Demostración de Ostia: 2026-10-05

La demostración superó las comprobaciones el 2026-10-05, en una red Canton local con una GPU NVIDIA RTX PRO 6000 Blackwell Server Edition. Cada caso se ejecutó una vez, con el prover ya en ejecución, a partir del commit `6b445073163832e9023850f53678617d90dfc808`. Estos son resultados de pruebas individuales, no una prueba de rendimiento.

TKA era el token de prueba de EVM. TKB era el token de prueba de Canton, y wTKB era su versión envuelta en EVM. U y V eran las partes de prueba. Primero se confirmó un bloque vacío de prueba de humo. Después, un bloque de configuración implementó TKA y creó wTKB. A continuación se realizaron las cinco ejecuciones:

| Ejecución              | Qué ocurrió                                                                                                                                        | Resultado                                                                                                                                                              | Tiempo de prueba                                                                    |
| ---------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------- |
| 1: depósito            | U depositó 10 TKB y reclamó 10 wTKB.                                                                                                               | El registro del bloque 3 y los nuevos 10 TKB que recibió el gateway procedieron de una sola actualización de Canton.                                                   | 6.72 s                                                                              |
| 2: pago                | V pagó 10 TKA a U a través del gateway, con cargo a la asignación de 10 TKB que U hizo a V. V también envió a U una transferencia simple de 1 TKA. | El registro del bloque 4 y los nuevos 10 TKB que recibió V procedieron de una sola actualización. La transferencia simple no generó ninguna acción.                    | 6.72 s                                                                              |
| 3: retirada            | U quemó 4 wTKB y recibió 4 TKB.                                                                                                                    | El registro del bloque 5 y la nueva tenencia de U procedieron de una sola actualización. El suministro de tokens envueltos y la custodia del gateway se redujeron a 6. | 6.72 s                                                                              |
| 4: asignación retirada | U retiró la asignación del pago después de generar la prueba.                                                                                      | Canton rechazó el bloque 6. Volver a enviarlo sin su acción también falló. La siguiente compilación omitió el pago y confirmó únicamente la aprobación de V.           | 6.75 s para la compilación inicial; la segunda prueba no se cronometró por separado |
| 5: prueba manipulada   | Se cambió un dígito hexadecimal de la prueba.                                                                                                      | Canton rechazó el bloque 7 después de que el sidecar rechazara la prueba. La cabecera permaneció en 6.                                                                 | 6.74 s antes de la manipulación                                                     |

La prueba envuelta ocupaba 1,344 bytes. Los seis tiempos registrados de generación de pruebas para la configuración y las cinco ejecuciones fueron de 6.71 a 6.75 s, y la prueba del bloque vacío tardó 6.31 s. La  [carpeta de resultados](https://github.com/rome-protocol/canton-zk-evm/tree/v0.1.0/demo/results) contiene los registros. Esta tabla muestra los tiempos de cada caso:

| Caso                  | Bloque y gas utilizado                                                                                         | Prueba                                                                                | Desde que finaliza el archivo de prueba hasta que termina el generador | Ejecución completa del generador    |
| --------------------- | -------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------- | ---------------------------------------------------------------------- | ----------------------------------- |
| Prueba de humo        | Bloque 1, vacío; 0 gas                                                                                         | 6.31 s                                                                                | 0.49 s                                                                 | 155.20 s                            |
| Configuración         | Bloque 2, dos transacciones; gas no registrado                                                                 | 6.71 s                                                                                | No registrado                                                          | 8.00 s                              |
| Depósito              | Bloque 3, una transacción; 122,308 gas                                                                         | 6.72 s                                                                                | 0.66 s                                                                 | 8.14 s                              |
| Pago                  | Bloque 4, tres transacciones; 185,307 gas                                                                      | 6.72 s                                                                                | 0.42 s                                                                 | 7.87 s                              |
| Retirada              | Bloque 5, una transacción; 90,345 gas                                                                          | 6.72 s                                                                                | 0.58 s                                                                 | 8.02 s                              |
| Asignación recuperada | El bloque 6 se rechazó y luego se reconstruyó con una transacción y sin legs; no se registró el consumo de gas | 6,75 s para la construcción rechazada; el segundo proof no se cronometró por separado | No se cronometró el envío rechazado                                    | 8,09 s rechazado; 8,04 s confirmado |
| Proof manipulado      | El bloque 7 se rechazó; no se registró el consumo de gas                                                       | 6.74 s antes de la manipulación                                                       | No se cronometró el envío rechazado                                    | 7,57 s                              |

Cada proof tenía 1.344 bytes. El intervalo desde que termina el archivo de proof hasta que finaliza el builder incluye la obtención de los proofs de cuenta y almacenamiento del gateway, `Advance`, la confirmación en ambos participantes confirmadores y el marcado del bloque como final por parte de reth. Es más largo que el commit de Canton por sí solo. La correspondencia entre legs y contratos de Canton se realiza antes de generar el proof y queda fuera de ese intervalo.

La ejecución completa de la prueba de humo incluye la preparación del witness y de la entrada, así como la configuración inicial del programa guest por parte del prover. También puede incluir la compilación de la herramienta de entrada. No se registraron tiempos separados para esos pasos.

## Benchmark del prover: 2026-10-03

La tabla muestra los tiempos medianos en segundos de tres ejecuciones en caliente para cada tamaño de bloque. Cada bloque contenía transferencias simples. Todos los proofs superaron `cargo-zisk verify`. Los registros brutos del benchmark no están en el repositorio.

| Bloque                         | Proof sin wrap, proceso nuevo | Solo wrap, proceso nuevo | Proof con wrap, proceso nuevo | Proceso nuevo completo | Prover en ejecución: de la entrada al proof con wrap | Prover en ejecución: de la entrada al proof verificado |
| ------------------------------ | ----------------------------- | ------------------------ | ----------------------------- | ---------------------- | ---------------------------------------------------- | ------------------------------------------------------ |
| 1 transferencia, 21 kgas       | 4.6                           | 2.4                      | 7.4                           | 21.1                   | 6.7                                                  | 7.0                                                    |
| 1.000 transferencias, 21 Mgas  | 6.9                           | 2.4                      | 9.6                           | 24.5                   | 9.0                                                  | 9.3                                                    |
| 5.000 transferencias, 105 Mgas | 17.9                          | 2.4                      | 20.8                          | 34.9                   | 21.2                                                 | 21.5                                                   |

El prover en ejecución mantuvo cargados el coordinador, el worker y las claves. Los totales de proceso nuevo incluyen el inicio y la detención del prover. Los tiempos de entrada a proof comienzan con un archivo witness ya existente; no miden la generación del witness. El caso de 105 Mgas fue un benchmark del guest upstream, no de un bloque de Ostia. El límite de gas fijado para los bloques de Ostia es 30.000.000.

| Medición del proof          | PLONK con wrap         | STARK sin wrap             |
| --------------------------- | ---------------------- | -------------------------- |
| Tamaño del archivo de proof | De 2.942 a 2.944 bytes | De 415.232 a 415.234 bytes |
| `cargo-zisk verify` tiempo  | De 0,29 a 0,30 s       | 0,03 s                     |
| Tamaño en la red            | 1.344 bytes            | No medido                  |

La verificación del proof con wrap incluye el inicio de Node para ejecutar snarkjs. No es una medición del verificador nativo del sidecar. El formato de 1.344 bytes transmitido por la red contiene 768 bytes de proof, 32 bytes de clave del programa, 32 bytes de raíz de recursión y 512 bytes de valores públicos.

## Inicio y memoria

Estas mediciones corresponden al mismo benchmark del 2026-10-03 con ZisK 1.3.1-alpha.

| Medición                                                                                                                                    | Resultado                                                         |
| ------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------- |
| Primera ejecución con 1 transferencia tras borrar la caché de ZisK y vaciar la caché de páginas, con la clave de prueba todavía en el disco | 123 s de tiempo de reloj; la generación del proof tardó 14,5 s    |
| Inicio del prover en ejecución con la caché compilada del guest ya presente                                                                 | Claves cargadas en 7,0 s; luego, 9,5 s para registrar el programa |
| Primera solicitud de proof después de ese inicio                                                                                            | 6,56 s                                                            |
| Memoria máxima de la GPU indicada por `nvidia-smi`                                                                                          | 93,2 GiB                                                          |
| Aumento de la RAM del host durante una prueba de generación de prueba en un proceso nuevo                                                   | De 27 a 29 GiB, más 22,9 GiB de memoria compartida                |
| Aumento de la RAM del host mientras el generador de pruebas en ejecución atendía solicitudes                                                | 3 GiB, más 22,9 GiB de memoria compartida                         |
| Memoria de la GPU indicada solo para el wrap de PLONK                                                                                       | 30 054 767 337 bytes, unos 28,0 GiB                               |

El generador de pruebas ajusta un búfer grande de la GPU a la capacidad de la tarjeta. El uso máximo fue prácticamente el mismo para los bloques de referencia más pequeño y más grande. Esto no permite determinar la memoria mínima de GPU que necesita el generador de pruebas completo.

## Otras comprobaciones registradas

El 2026-10-04, la primera prueba de transferencia abarcó el bloque 1 en una copia temporal del bloque génesis, no en una cadena en ejecución: una transferencia de 21 000 unidades de gas y 385 277 pasos del programa invitado. Tres pruebas tardaron 6,33, 6,75 y 6,69 s. El verificador de ZisK y la crate del verificador del repositorio comprobaron la prueba. Al cambiar a 1 el identificador de cadena de la entrada, el programa invitado la rechazó sin generar una prueba.

La compilación del programa invitado desde una carpeta de compilación vacía tardó 125 s, incluida la descarga de dependencias. Dos clones limpios tardaron 133 s y 126 s, y produjeron el mismo ELF y programVK. La primera configuración del programa del generador de pruebas tardó 43 s. Estas cifras proceden de los registros del 2026-10-04 descritos en el informe de métricas y el [README del programa invitado](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/guest/README.md).

Tras la demostración del 2026-10-05, la comprobación del bloque 3 en el navegador del explorador se completó en 13 ms. Desde el clic hasta la respuesta transcurrieron unos 0,35 s. Fue una sola comprobación en el navegador, no una prueba de rendimiento, y no está registrada en `demo/results/`.

La comprobación de WebAssembly tardó de 8 a 32 ms en Node, en los ejecutores de CI. Esa prueba verificó una prueba y luego rechazó un encabezado que no coincidía. No fue una comprobación satisfactoria de un bloque completo ni una medición en un navegador; consulta el [README del verificador](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/explorer/verify/README.md).

## Qué no permiten concluir estas mediciones

No hay pruebas de rendimiento sistemáticas de llamadas a contratos ni de precompilados. La prueba de rendimiento del 2026-10-03 usó el programa invitado original hasta 105 Mgas; la del 2026-10-25 usó el programa invitado de Ostia hasta 1,31 Ggas, en una máquina de pruebas de rendimiento, y no se confirmó ningún bloque de ese tamaño en Canton. No hay mediciones registradas con más de un bloque en proceso. Se probó un generador de pruebas con dos GPU en una máquina de pruebas de rendimiento: los tiempos de generación fueron entre un 25 % y un 39 % más cortos (una prueba usando ambas GPU) y todas las pruebas se verificaron; esas ejecuciones no están registradas aquí y DevNet no lo utiliza.

No se han medido por separado la construcción de testigos en un host con caché caliente ni la verificación nativa del proceso auxiliar. En la demostración se confirmaron bloques con un máximo de tres transacciones y una pata. En DevNet, las confirmaciones más grandes medidas fueron bloques de 1 428 transferencias simples. Cada caso se ejecutó una sola vez, por lo que los resultados no muestran cuánto varían los tiempos entre ejecuciones.

La carga de una hora en DevNet del 2026-10-24 no alcanzó el límite de la cadena: el presupuesto de RPC del cliente detuvo el aumento antes y ningún bloque contenía más de 84 transacciones. En esa carga no hubo ningún bloque con más de 100 transacciones, ningún precio de oráculo disponible ni ninguna transferencia privada liquidada; además, las correcciones del controlador no se ejecutaron durante una hora completa. Las ejecuciones del 2026-10-25 sí alcanzaron el límite para las transferencias simples, donde se impone el límite 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/es/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.
