> 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/run-it-locally.md).

# Ejecuta tu propio Ostia

Ejecuta las comprobaciones, el ensayo sin GPU, la demo local en una GPU, una cadena que sobrevive a reinicios y Ostia en un participante existente de Canton.

De forma predeterminada, los scripts proporcionados ejecutan una red de pruebas local. Canton mantiene su estado en memoria, así que cada reinicio lo descarta y crea una red nueva. Hay otros dos modos que conservan una cadena: el modo persistente (`CZE_PERSIST=1`) y Ostia en un participante de Canton que ya tengas, que es como se ejecuta Ostia DevNet. La demostración con GPU prueba bloques. El ensayo utiliza una prueba sustituta y no necesita GPU.

Esta página describe la versión `v0.1.0`. Lee la [guía completa de la red](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/network/README.md) y la [guía de la demostración](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/demo/README.md). Ejecuta los siguientes comandos desde la raíz del repositorio `canton-zk-evm` .

## Requisitos

| Tarea                            | Requisitos                                                                                                                        |
| -------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- |
| Comprobaciones del repositorio   | Docker, `bash`, `curl`, `jq`, `openssl` y Python 3. Las pruebas de Rust usan `rust-toolchain.toml`.                               |
| Pruebas de integración de Canton | Linux x86-64, Java 21 y acceso a la red.                                                                                          |
| Ensayo de la demostración        | Linux x86-64, Docker, Java 21, Rust y Python 3.12 o posterior.                                                                    |
| Pruebas del explorador           | Node 22.18 o posterior.                                                                                                           |
| Red y demostración con GPU       | Linux x86-64, una GPU NVIDIA con el controlador instalado, Docker, Rust, Python 3.12 o posterior, `jq`, `curl`, `openssl` y ZisK. |

El [README del repositorio](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/README.md#running-the-tests) enumera los requisitos previos para las pruebas. El instalador de GPU usa `sudo` y `apt` en Debian o Ubuntu y necesita unos 100 GB de espacio libre en disco. Instala paquetes del sistema y modifica los límites de bloqueo de memoria. El descargador de herramientas de la red instala Java 21 si no está disponible. Consulta [el host del probador de Ostia](https://docs.rome.builders/es/canton-zk-evm/prover-host.md) para conocer el hardware probado; no se ha establecido la memoria mínima de GPU.

## Ejecutar las pruebas

Empieza con las comprobaciones rápidas de [CONTRIBUTING.md](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/CONTRIBUTING.md#building-and-testing):

```sh
tests/static.sh                  # las líneas de versiones fijadas, génesis y licencia coinciden
tests/refuses_missing_flag.sh    # el inicio de reth rechaza una opción ausente o incorrecta
tests/fixtures.sh                # la prueba registrada es coherente
gateway/build.sh --check         # el código de gateway incluido en el repositorio es el que se compila en Gateway.sol (Docker)
```

El README del repositorio también incluye estas comprobaciones. No necesitan GPU:

```sh
tests/udp_control.sh             # la comprobación UDP falla en un contenedor con un listener UDP (sin reth)
tests/discovery.sh               # inicia el reth fijado, comprueba que no tiene pares y lo detiene
tests/network_static.sh          # solo reth mediante launch.sh, la configuración de Canton y el resultado de la prueba de humo registrado
tests/network_checks.sh          # la comprobación de la versión del compilador fijada, el ID del DAR y la detención con otro programVK (sin GPU)
tests/canton_network.sh          # el Canton fijado, el paquete Daml real y un Advance (Linux x86-64, Java 21, Python 3; sin GPU)
gateway/tests/run.sh             # la gateway con un reth real, iniciado con el descubrimiento de pares desactivado (Docker, curl, jq, Python 3 con los paquetes de demo/requirements.txt)
tests/guest-repro.sh             # la compilación del guest se ejecuta en una carpeta fija, por lo que la carpeta de origen no cambia el ELF (sustitutos de las herramientas ZisK; la misma comprobación con ZisK real se superó el 2026-10-04; consulta guest/README.md)
tests/demo_static.sh             # las versiones fijadas de la demo, el interruptor de manipulación y la sobrescritura de genesis, y sus resultados registrados (sin GPU)
tests/demo_explorer_static.sh    # las imágenes del explorador están fijadas, así como lo que recibe su contenedor (sin Docker)
(cd explorer && npm ci && npm test)  # las pruebas del explorador, con simulaciones (Node 22.18+; CI usa EXPLORER_NODE_IMAGE en PINS)
(cd guest/rules && cargo test)   # las reglas de la cadena y su hash (requiere Rust)
```

## Ensayar sin GPU

```sh
tests/demo_rehearsal.sh          # la demo y el explorador con una prueba de sustitución (Linux x86-64, Docker, Java 21, Rust, Python 3.12+; sin GPU)
```

Esto ejecuta el reth, Canton, el paquete Daml, el estándar de tokens y el builder reales. El sidecar comprueba las operaciones de la gateway con pruebas de almacenamiento, mientras un sustituto responde a la llamada `verify` de prueba. El ensayo no demuestra un bloque ni verifica una prueba real de conocimiento cero.

También comprueba el explorador y el faucet. La comprobación Verify del explorador debe rechazar la prueba de sustitución. El [README de la demo](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/demo/README.md#the-rehearsal) describe la cobertura del ensayo.

## Iniciar la red local con una GPU

Instala ZisK con `prover/install.sh` antes de iniciar la red. Inicia siempre reth mediante el lanzador proporcionado; `network/up.sh` lo usa.

```sh
network/up.sh       # herramientas, compilación del guest, reth, sidecars, prover, Canton, la cadena
CZE_SOURCE_COMMIT=$(git rev-parse HEAD) network/smoke.sh    # un bloque vacío, demostrado y confirmado
network/down.sh
```

`up.sh` compila el guest y rechaza cualquier clave de programa, raíz de ZisK o hash de reglas que difiera de los valores registrados. La red tiene un sincronizador y tres participantes. Los participantes operador y confirmador ejecutan cada uno un sidecar. El participante llamado users aloja las partes de prueba y el reader.

La prueba de humo confirma un bloque vacío, comprueba la cabecera de la cadena y el registro de bloques del reader, y verifica que reth lo haya marcado como final. El estado y los registros se guardan en `state/`, o en `CZE_STATE_DIR` si está definido.

## Ejecutar los cinco casos de la demo con una GPU

Usa una nueva red local para la demo:

```sh
demo/prepare.sh
CZE_GENESIS_FILE=$PWD/state/demo/genesis.json network/up.sh
CZE_SOURCE_COMMIT=$(git rev-parse HEAD) network/smoke.sh      # opcional: primero, un bloque vacío
CZE_SOURCE_COMMIT=$(git rev-parse HEAD) demo/run.sh
network/down.sh
```

El script de preparación crea claves de prueba y un genesis con fondos para la ejecución. La demo ejecuta el bloque de configuración, el depósito, el pago, el retiro, el rechazo de la asignación y el rechazo de la prueba manipulada. El script se detiene si falla una comprobación y escribe los resultados en `demo/results/`.

Para una exportación del código fuente sin `.git`, asigna `CZE_SOURCE_COMMIT` el hash completo del commit usado para la exportación. Para incluir el faucet, hay que preparar su genesis con fondos antes de iniciar la red; consulta [Ejecuta el explorador tú mismo](#run-the-explorer-yourself) más abajo y la guía completa de la demo.

## Conserva la cadena entre reinicios

Una cadena que la gente usa debe sobrevivir a un fallo o un reinicio. `up.sh` crea una cadena nueva en cada ejecución, a menos que solicites el modo persistente:

```sh
CZE_PERSIST=1 network/up.sh     # el primer inicio: una cadena nueva que se conserva
network/down.sh                 # detiene todo y conserva los datos
network/restart.sh              # después de un reinicio: vuelve la misma cadena
network/down.sh --wipe          # detiene todo y elimina la cadena definitivamente
```

Canton guarda sus nodos en PostgreSQL en 127.0.0.1, con una contraseña creada en la máquina y almacenada en un archivo con permisos 0600. reth guarda sus datos en `$CZE_STATE_DIR/reth-data` y escribe cada bloque en el disco a medida que lo importa. `restart.sh` no crea nada: inicia la base de datos, reth, los procesos auxiliares, el prover y Canton con los datos conservados, y sincroniza reth con la cabeza de Canton. Se detiene si las bases de datos se crearon con una versión de Canton distinta de la indicada en `PINS`. Haz una copia de seguridad de las bases de datos y de `reth-data` al mismo tiempo, con la red detenida. La [guía de la red](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/network/README.md#keeping-the-chain-across-restarts) describe todos los casos.

## Ejecutar en un participante existente

Ostia puede ejecutarse en un participante de Canton que ya exista, como el de un validador de Splice en Canton Network DevNet, en lugar de hacerlo en la red local. Así es como se ejecuta Ostia DevNet. `up.sh` inicia entonces reth, el prover y, si lo solicitas, un proceso auxiliar, y configura la cadena en ese participante. No inicia Canton ni realiza el arranque inicial.

Necesitas:

* La API JSON Ledger (v2) del participante, disponible mediante una URL `https` o una URL `http` en la misma máquina.
* Un archivo de token para cada uno de los cuatro usuarios de Ledger API: `ADMIN` (carga el paquete y crea las partes y los usuarios, por lo que solo `up.sh` y `setup.py` lo necesitan), y `OPERATOR`, `CONFIRMER` y `BUILDER` (los usuarios que `setup.py` crea: `ostia-operator`, `ostia-confirmer` y `ostia-builder`). Cada token usa HS256, con la audiencia `https://canton.network.global` y el ID del usuario como `sub`. Quien ejecuta el participante lo crea. Ostia nunca crea, imprime ni almacena un token.
* Un sidecar al que puede acceder el participante y nadie más.

Los tokens tienen una vida corta, así que escribe cada token nuevo en el mismo archivo, sobrescribiéndolo. El builder vuelve a leer su archivo en cada llamada. `setup.py` y `propose.py` leen cada token una sola vez, así que inícialos con tokens nuevos.

Primero, dale al participante la línea que necesita, como una variable más `ADDITIONAL_CONFIG` de su contenedor, y reinícialo:

```sh
network/external/participant-config.sh <sidecar address> 8085
# imprime: ADDITIONAL_CONFIG_ZK_EVM=canton.participants.participant.parameters.engine.extensions.canton-zk-evm { address = "<sidecar address>", port = 8085, validate-on-startup = false }
```

Con `validate-on-startup` en false, el participante sigue iniciándose aunque el sidecar esté inactivo; entonces falla la comprobación de un bloque y no se confirma ningún bloque. Después, inicia la cadena:

```sh
export CZE_CANTON=external CZE_LEDGER_URL=https://<participant's Ledger API>
export CZE_TOKEN_FILE_ADMIN=... CZE_TOKEN_FILE_OPERATOR=... \
       CZE_TOKEN_FILE_CONFIRMER=... CZE_TOKEN_FILE_BUILDER=...
CZE_PERSIST=1 CZE_SIDECAR_LISTEN=<sidecar address>:8085 network/up.sh
```

`CZE_PERSIST=1` es necesario aquí porque la cadena permanece en el participante y reth también debe conservar sus bloques. Si el sidecar se ejecuta en otra máquina, inícialo allí con `network/external/sidecar.sh start <sidecar address>:8085` (la dirección desde la que accede el participante, no una dirección pública) y ejecuta `up.sh` sin `CZE_SIDECAR_LISTEN`. `up.sh` crea el guest, inicia reth y el prover, y ejecuta `external/setup.py`, que carga el paquete, asigna las partes, crea los usuarios con solo los permisos de sus respectivos roles y propone la cadena. Puede ejecutarse dos veces sin causar problemas. `restart.sh` vuelve a poner en marcha la cadena y solo necesita el token del builder. `down.sh --wipe` no afecta al participante: los contratos de la cadena permanecen allí hasta que su operador los elimine.

Este modo está sujeto a tres reglas:

* **Nunca expongas la Ledger API.** Puede actuar como todas las partes alojadas en el participante. Mantenla en la dirección propia de la máquina o detrás de un proxy que compruebe quién la llama.
* **Mantén los archivos de tokens con permisos 0600**y fuera de máquinas compartidas.
* **El operador del participante puede verlo todo.** Un participante aloja todas las partes de Ostia, así que el operador puede leer todos los contratos y actuar en nombre de todas las partes, incluida la custodia del gateway. Su único sidecar es el único confirmer. En Ostia DevNet, ese operador es Rome: ejecuta el participante, su propio validador de Canton DevNet.

## Ejecuta el builder continuamente

`builder.py once` crea un bloque. `builder.py run` sigue creándolos:

```sh
python3 builder/builder.py run [--heartbeat-seconds N] [--status-file <path>]
```

Lee la misma [configuración](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/builder/README.md#settings) que `once`. Con la estrategia predeterminada, `on_demand`, se crea un bloque en cuanto hay transacciones que pueden incluirse en espera, con un bloque en curso a la vez de forma predeterminada (`--max-in-flight` aumenta ese límite). Una cadena inactiva no crea bloques a menos que `--heartbeat-seconds N` solicite un bloque vacío tras N segundos sin crear ninguno; de forma predeterminada no hay latido. Después de que se rechacen dos bloques seguidos, el creador sospecha que hay una transacción problemática y la excluye durante un período de enfriamiento.

Solo se ejecuta un creador a la vez; `run` y `once` adquieren un bloqueo y se niegan a iniciarse si otro proceso lo tiene. Una señal de detención termina el bloque en curso y finaliza el proceso. Ejecuta el creador con un gestor de servicios que lo reinicie, con un tiempo de espera para la detención superior al tiempo combinado de la prueba y la respuesta de Canton. Es seguro reiniciarlo en cualquier momento: el siguiente inicio vuelve a la cabeza de Canton y envía de nuevo a reth las transacciones del bloque interrumpido. El creador escribe `status.json` y un diario en su carpeta de trabajo; el explorador lee ambos.

## Ejecuta el explorador por tu cuenta

El explorador se ejecuta en un contenedor junto a la cadena que muestra, en una máquina Linux con Docker. Tiene su propio PostgreSQL, que inicia `network/explorer-db.sh`; el indexador lo rellena con los registros de Canton. La financiación del grifo debe estar en el génesis antes de iniciar la red, así que `setup` va primero:

```sh
explorer/run.sh setup           # crea la clave del grifo y un génesis financiado
CZE_GENESIS_FILE=state/faucet/genesis.json network/up.sh
explorer/run.sh start           # luego abre http://127.0.0.1:8088
explorer/run.sh stop
```

`start` inicia la base de datos, aplica las migraciones e inicia el indexador en su propio contenedor, y luego el explorador. Si no hay una clave del grifo, este queda desactivado. Un pago del grifo es una transacción para reth, así que solo alcanza la finalidad cuando se ejecuta el creador. Iniciar la red o el explorador no inicia el creador. Ejecuta el creador una vez antes de `explorer/run.sh start`, o vuelve a ejecutar `start` después de la primera ejecución del creador; hasta entonces, el explorador no tiene la carpeta de trabajo del creador y el ciclo de vida del bloque permanece vacío. En una red creada sin `CZE_PERSIST`, `stop` también elimina la base de datos del explorador, junto con las solicitudes al grifo y las fuentes de contratos verificadas. Una red persistente la conserva.

De forma predeterminada, `explorer/run.sh start` desactiva la verificación de contratos, a menos que configures `EXPLORER_VERIFIER=1` (con `SOLC_LIST_URL`), y no habilita `/rpc` ni las llamadas de lectura de contratos, a menos que configures `PUBLIC_RPC=1`. La lista de ajustes está en el encabezado de [explorer/run.sh](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/explorer/run.sh).

En la red local proporcionada, la API de Ledger no requiere inicio de sesión. El explorador solo lee como la parte lectora, pero cualquier persona que pueda acceder a ese participante también puede leer los datos de sus otras partes; por eso, nunca asignes una dirección pública al contenedor allí. En un participante existente, proporciona al explorador un archivo de token con permisos 0600 para el usuario lector (`LEDGER_TOKEN_FILE`), la `LEDGER_URL` del participante y la `READER_PARTY`. El contenedor sigue escuchando en 127.0.0.1; para usar una dirección pública, necesitas tu propio proxy. La [guía del explorador](https://github.com/rome-protocol/canton-zk-evm/blob/main/explorer/README.md#running-it) incluye todos los ajustes.

## Cárgalo con una combinación realista

`load/mixed` contiene el kit utilizado en la ejecución de una hora en [Mediciones](https://docs.rome.builders/es/canton-zk-evm/measurements.md). Despliega en una cadena tokens de varios tipos, un DEX, un token con permisos y un contrato de transferencias privadas; luego envía tráfico mixto desde 200 monederos. Su [README](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/load/mixed/README.md) contiene los pasos. Necesitas Docker y una cuenta con unos 12 000 tROME, usando la configuración del kit tal como viene. En tu propia cadena, asígnale fondos en el génesis. El faucet de DevNet no puede proporcionar esa cantidad.


---

# 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/run-it-locally.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.
