> 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/trust-model.md).

# Modelo de confianza y límites

Las comprobaciones, autoridades, suposiciones de custodia y límites de Ostia en Canton Network DevNet.

Ostia es una versión preliminar en Canton Network DevNet. Rome ejecuta todos los servicios de Ostia: el único builder, el prover, el RPC público, el explorador, el faucet, el servicio de registro de twins y el participante que aloja todas las partes de Ostia (el propio validador de DevNet de Rome). El sincronizador de Canton Network DevNet, que ordena los bloques, lo ejecuta la red, no Rome. El único sidecar de Rome es el único confirmer. Esta página explica quién verifica qué y quién tiene qué. No uses Ostia para nada de valor.

**En quién confías hoy.** Rome ejecuta el prover y el único participante que confirma. El participante de Rome custodia Canton Coin y administra el twin. El código y ZisK (alfa) no se han auditado. Esto es solo para DevNet.

Esta página describe la versión `v0.1.0` y, cuando así se indica, lo que se ejecuta actualmente en DevNet. [Estado](https://docs.rome.builders/es/canton-zk-evm/status.md) indica el commit que ejecuta DevNet. Lee el [diseño](https://github.com/rome-protocol/canton-zk-evm/blob/main/docs/DESIGN.md) y la [política de seguridad](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/SECURITY.md).

## Demo local frente a Ostia DevNet

La demo del 2026-10-05 se ejecutó en una red local de Canton. Las verificaciones usan el mismo código en ambas. La configuración de confianza no es la misma.

|                            | Red de la demo local                                                                         | Ostia DevNet                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| -------------------------- | -------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Participantes              | Tres: operador, confirmer y usuarios.                                                        | Un participante, el de Rome, aloja todas las partes de Ostia. Un segundo participante de Rome aún no aloja ninguna.                                                                                                                                                                                                                                                                                                                                                                                      |
| Confirmers                 | 2, cada uno con su propio sidecar.                                                           | 1, el sidecar junto a ese participante.                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| Persistencia               | Pierde su estado al reiniciarse, a menos que se inicie en modo persistente.                  | La cadena persiste en el participante. DevNet aún puede restablecerse.                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| Acceso a la API del ledger | Sin autenticación, en una sola máquina.                                                      | Cada usuario de la API del ledger de Ostia necesita un token de corta duración.                                                                                                                                                                                                                                                                                                                                                                                                                          |
| Quién opera qué            | Quien lo inicia ejecuta todas las partes en una sola máquina.                                | Rome ejecuta todos los servicios de Ostia: el participante que aloja las partes, el builder, el prover, el RPC, el explorador, el faucet y el registro de twins. La red ejecuta el sincronizador.                                                                                                                                                                                                                                                                                                        |
| Canton                     | Canton 3.6.3 en `v0.1.0`; las ejecuciones del 2026-10-05 usaron snapshots de la versión 3.6. | El validador de Rome ejecuta Splice 0.10.1 con Canton 3.7.2 (desde el 2026-11-07). El sincronizador de DevNet usa la versión 37 del protocolo (desde el 2026-11-18). Daml SDK 3.6.0, damlc 3.6.2.                                                                                                                                                                                                                                                                                                        |
| Depósitos, retiros y pagos | Se mostraron en la demo del 2026-10-05.                                                      | En funcionamiento desde el 2026-10-25 con el token de prueba TKB. Rome ejecuta las partes de prueba y todos los pasos.                                                                                                                                                                                                                                                                                                                                                                                   |
| Twins y Canton Coin        | No incluido en la versión `v0.1.0`.                                                          | En funcionamiento desde el 2026-10-29: twins ERC-20 a través de la bóveda y entradas y salidas de Canton Coin. Entre el 2026-11-08 y el 2026-11-17, la página Bridge podía abrir una cuenta de Canton mediante la firma de una billetera; esa cuenta se ha retirado (consulta [la cuenta de Bridge creada mediante la firma de una billetera](#the-bridge-account-made-from-a-wallet-signature)). La página Bridge conecta la billetera de Canton que ya tienes, con activación billetera por billetera. |

El [README de la red](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/network/README.md#running-on-an-existing-participant-the-canton-network) considera que un solo confirmer ofrece menos seguridad que la red local, pero es suficiente para DevNet.

## Quién verifica qué

| Componente       | Verificación o autoridad                                                                                                                                                                                               |
| ---------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Invitado         | Valida el bloque EVM y rechaza cualquier configuración de cadena distinta de las reglas compiladas de Ostia.                                                                                                           |
| Sidecar `verify` | Comprueba la prueba, el programVK y el rootC fijados, el hash del bloque probado, la cabecera y la lista de transacciones.                                                                                             |
| Sidecar `legs`   | Comprueba las pruebas de cuenta y almacenamiento del gateway y compara las legs adjuntas, en el orden indicado, con el hash del gateway probado.                                                                       |
| Daml `Advance`   | Comprueba las respuestas del sidecar, el bloque padre, el número del siguiente bloque, el límite de gas y los contratos usados por las legs. Liquida las legs y crea el siguiente encabezado y el registro del bloque. |
| Canton           | Ordena los bloques mediante el consumo del único contrato de estado de la cadena y confirma conjuntamente los cambios de la transacción. Rechaza las respuestas distintas a las llamadas externas.                     |
| Generador        | Selecciona transacciones, comprueba los contratos de Canton que puede ver, obtiene una prueba y envía el bloque. No puede finalizar un bloque por sí solo.                                                             |

Junto a cada participante confirmador se ejecuta un sidecar. En DevNet hay uno, junto al participante que aloja todas las partes de Ostia, que es el de Rome. Así que hoy la prueba la comprueba el propio nodo de Rome. El sincronizador de Canton ordena los bloques y retransmite los mensajes; no ve la prueba. Cada sidecar calcula sus respuestas únicamente a partir de la entrada enviada en la llamada externa. Daml compara sus respuestas; no realiza por sí mismo la comprobación criptográfica de la prueba. El  [README del sidecar](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/sidecar/README.md) y el [README de Daml](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/daml/README.md) detallan las comprobaciones y los requisitos de autoridad.

## Qué garantiza la prueba

La clave de programa fijada identifica el guest y sus reglas de cadena. La prueba queda vinculada a un hash de bloque. La comprobación de su cabecera vincula la raíz de estado y la raíz de transacciones. A continuación, las pruebas de cuenta y almacenamiento vinculan el hash de las legs registradas por el gateway con esa raíz de estado.

Las legs adjuntas deben tener los mismos campos y el mismo orden que las registradas por el gateway. Eliminar una leg, añadir una o cambiar un destinatario, importe, token o id hace que falle la comparación de hashes. Un bloque sin legs también debe probar esa ausencia. La comparación de legs también depende de la resistencia a colisiones de Keccak-256.

La raíz de estado génesis del registro de la cadena fija el código del gateway. El contrato del gateway no tiene propietario, clave de administrador, mecanismo de actualización ni pausa. La parte de Canton sigue teniendo autoridad de custodia sobre los tokens que posee.

## Autoridad del operador, del confirmador y del gateway

El operador y el gateway proponen el génesis de la cadena, los valores fijados, el límite de gas y el generador. El confirmador acepta la propuesta. Se espera que compare los valores fijados y el código génesis del gateway con su propia compilación. Los scripts proporcionados proponen valores coincidentes y aceptan inmediatamente la propuesta en nombre del confirmador.

El operador, el confirmador y el gateway firman `ZkChain`. Son la raíz de confianza de la cadena. Las decisiones de liquidación de depósitos y retiros requieren a los tres, y la liquidación de pagos requiere al operador y al confirmador. `Advance` proporciona su autoridad conjunta. El generador no puede ejecutar por sí solo las decisiones de liquidación.

En DevNet, Rome ejecuta el único participante que aloja todas estas partes. Rome, en calidad de operador, puede ver todos los contratos de Ostia y tiene lo necesario para actuar en nombre de todas las partes de Ostia, incluido el confirmador y el gateway. Allí también se alojan las cuentas de Canton creadas por la cuenta Bridge retirada (consulta [la cuenta Bridge creada mediante una firma de cartera](#the-bridge-account-made-from-a-wallet-signature)).

**Custodia.** La parte del gateway posee los tokens de Canton que respaldan los tokens envueltos en EVM. Está alojada en el participante del operador. Quienquiera que ejecute ese participante —Rome en DevNet— puede mover los tokens bloqueados al margen de las reglas de retiro. Que el contrato del gateway no tenga una clave de administrador no limita la capacidad de esa parte de Canton para actuar a través de su participante. En DevNet, el gateway solo posee tokens de prueba: la ejecución de Rome del 2026-10-25 comprobó que tenía 12 TKB, el token de prueba de referencia que distribuye Splice, frente a un suministro de 12 wTKB, que cualquiera puede consultar en Ostia. Los tokens ERC-20 que respaldan los gemelos están en la bóveda, un contrato EVM sin propietario, que [la sección sobre los gemelos](#what-the-twins-trust) describe.

El registro de tokens es otra decisión de confianza. El operador y el gateway proponen la correspondencia entre un instrumento de Canton y un token envuelto en EVM, y el confirmador la acepta. El gateway ejecuta el código de transferencia Daml del token registrado con su propia autoridad, así que registrar un token también implica confiar en el código Daml de su registro.

Los tokens enviados directamente a la dirección EVM del gateway no se pueden recuperar. Si un token cobra una comisión de transferencia o transfiere por algún otro motivo un importe distinto, la leg de pago sigue registrando el importe solicitado. El [README de la red](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/network/README.md#the-canton-network) detalla el alojamiento de los participantes y las comprobaciones de registro.

## En qué confían los gemelos

Un gemelo es la representación en Canton de un ERC-20 que posee la bóveda (consulta [Depósitos, retiros y pagos](https://docs.rome.builders/es/canton-zk-evm/deposits-withdrawals-payments.md#canton-twins-of-erc-20-tokens)). Estos son los fundamentos en los que se apoya:

* **La cadena emite y quema mediante `Advance`.** Según las reglas de la cadena, un gemelo se emite dentro de `Advance`, contra una línea de bloqueo fijada por la prueba: un pago probado a una bóveda que registra el registro de la cadena. `Advance` quema un gemelo únicamente contra una solicitud de canje firmada por su titular. El registro de la cadena fija la dirección del token, los decimales y el contrato de reglas de cada gemelo, y rechaza un bloqueo para otro token.
* **La bóveda no tiene propietario.** No tiene clave, ni actualización ni almacenamiento, y no se puede hacer que pague un identificador que otro tipo de pago sí podría pagar. Cualquiera puede comparar su código en cadena con la compilación revisada.
* **Las personas registran una bóveda.** El operador y la pasarela la proponen, y el confirmador la acepta después de leer el código desplegado. Esa lectura protege lo que hace el contrato.
* **El administrador del gemelo es la parte de la pasarela.** El administrador es quien controla por sí solo las funciones `Mint` y `Burn`, por lo que la parte de la pasarela también puede acuñar o quemar un gemelo fuera de `Advance`, sin bloqueo ni solicitud de canje. La parte de la pasarela está alojada en el participante de Rome, así que en DevNet Rome puede actuar en su nombre, como puede hacerlo por todas las partes de Ostia que gestiona. Firma cada tenencia de gemelos, por lo que puede quemar, acuñar y transferir los gemelos que tenga cualquier parte de Canton, incluidos los de una billetera de Canton conectada a [Bridge](https://docs.rome.builders/es/canton-zk-evm/bridge.md), sin la firma de esa parte. Antes de la red principal, el operador y el confirmador también deberán firmar las operaciones de acuñación y quema. El explorador muestra la oferta de cada gemelo en comparación con lo que tiene la bóveda, para que cualquiera pueda ver si coinciden.
* **El servicio de registro es una referencia.** Indica al pagador el identificador de bloqueo y la bóveda, y no tiene ninguna clave. El generador y `Advance` comprueban que las partes produzcan el identificador; el pagador comprueba el identificador en sí (el SHA-256 de `lock,<receiver>,<ref>`) y obtiene la dirección de la bóveda de una fuente en la que confía. El registro de cadena que identifica las bóvedas registradas solo pueden leerlo las partes de Rome, así que en DevNet esa fuente es Rome.

## La cuenta de Bridge creada con la firma de una billetera

Retirada el 2026-11-17. Del 2026-11-08 al 2026-11-17, la página de [Bridge](https://docs.rome.builders/es/canton-zk-evm/bridge.md) permitía abrir una cuenta de Canton con la firma de una sola billetera: la página convertía la firma en una clave Ed25519, que era la única clave de firma de la cuenta. Se detuvo el servicio de cuentas que ayudaba a abrirlas, y la página ya no ofrece el inicio de sesión, genera la clave ni la conserva en el navegador (elimina la que se guardó en una visita anterior). Ahora se conecta la billetera de Canton propia, función que se habilita billetera por billetera; consulta [Desarrollar con Canton](https://docs.rome.builders/es/canton-zk-evm/build-with-canton.md#erc-20-twins-on-canton) para saber qué está pendiente, y [Bridge](https://docs.rome.builders/es/canton-zk-evm/bridge.md).

Las cuentas que se abrieron permanecen en Canton DevNet, alojadas en el participante de Rome, junto con lo que contienen, hasta que se restablezca DevNet. Ya no hay nada que acepte sus claves, así que nadie, ni siquiera Rome, firma ni envía transacciones en su nombre. Solo contenían valor de prueba de DevNet.

Para que conste, esto es lo que era la cuenta:

* **La clave se obtenía únicamente de la firma.** EIP-712 vincula una firma a los datos tipados, no al sitio que la solicita, así que cualquiera que obtuviera la firma podía crear la clave. Una billetera que dejara de generar la misma firma no podría volver a abrir la cuenta. No había revocación ni recuperación.
* **Rome no podía firmar en su nombre, pero gestionaba aquello sobre lo que se sustentaba.** Rome gestionaba el código que usaban los contratos de la cuenta, el único nodo que alojaba la cuenta y el administrador de gemelos; por eso podía quemar, acuñar y transferir los gemelos que tuviera una cuenta sin la firma de su titular. La aceptación permanente de retiros de la cuenta permitía que las opciones gestionadas por las partes de Rome actuaran en su nombre cuando llegaba un retiro.

El administrador de gemelos y la aceptación de retiros no son exclusivos de la cuenta de Bridge: la parte de la pasarela firma cada tenencia de gemelos, y una billetera de Canton que opte por participar firma las mismas dos aceptaciones. Consulta [En qué confían los gemelos](#what-the-twins-trust).

## Qué puede detener un bloque

Para incluir una etapa, el generador necesita acceso de lectura a sus solicitudes, términos, aceptaciones, asignaciones, registros de tokens y tenencias de la pasarela. Omite toda transacción cuyos contratos de Canton no pueda ver.

Se puede retirar una asignación después de que el generador la compruebe o después de demostrarla. Un registro de tokens también puede rechazar la liquidación según sus propias reglas. En ese caso, Canton rechaza el bloque y no se confirma nada.

El generador se ejecuta continuamente y crea un bloque cuando hay transacciones que pueden incluirse. El valor predeterminado del código es un bloque en curso, y DevNet ejecuta hasta dos. Si se produce un rechazo que no podía prever, como el causado por una regla propia del registro, el generador marca una transacción como sospechosa tras dos bloques rechazados consecutivos y la omite durante un periodo de espera, de 10 minutos de forma predeterminada. Vuelve a intentar la transacción cuando termina ese periodo. Si se reinicia, olvida lo que ha omitido.

El generador no limita los pasos de ejecución antes de la demostración, y si un probador nunca responde, el generador se detiene. El [README del generador](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/builder/README.md#not-here) enumera sus límites.

## Qué no ofrece esta versión

* **Descentralización.** Hay un generador, un probador y un confirmador, y Rome gestiona el generador, el probador, RPC, el explorador, el grifo y el participante que aloja todas las partes.
* **Resistencia a la censura ni inclusión forzada.** RPC y el generador pueden rechazar u omitir una transacción, y no existe otra vía para incluirla en la cadena. RPC y el explorador son vistas de la cadena gestionadas por Rome. El indexador del explorador comprueba cada registro frente a reth, pero no son sistemas sin confianza.
* **Privacidad.** Todas las transacciones EVM son públicas y Rome, como operador del participante, ve todos los contratos de Ostia. La carga del 2026-10-24 generó pruebas de transferencias privadas en el cliente y las verificó en la cadena, pero no se ejecuta ninguna red MPC ni se liquida nada.
* **Valor ni auditorías.** tROME no tiene valor. El código y ZisK 1.4.0-alpha no se han auditado.
* **Permanencia.** DevNet puede restablecerse, y con ella el historial de la cadena.

No hay objetivos de rendimiento ni de tiempo de bloque. Las versiones y los hashes exactos están en [PINS](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/PINS).

El lector puede volver a comprobar las pruebas de los bloques, pero `BlockRecord` no contiene las etapas liquidadas. El botón Verify del navegador comprueba la prueba, la cabecera y las transacciones; no repite las comprobaciones de liquidación de etapas de Canton. [Qué se demuestra y qué no](https://docs.rome.builders/es/canton-zk-evm/what-is-proven.md) explica qué te indica una prueba, y [Estado y hoja de ruta](https://docs.rome.builders/es/canton-zk-evm/status.md) explica qué viene después.

## Informar de un problema de seguridad

Usa el sistema privado de GitHub para informar de vulnerabilidades en `canton-zk-evm`: abre la pestaña Security del repositorio y selecciona **Report a vulnerability**. No abras una incidencia pública para informar de un problema de seguridad.

Incluye el componente afectado, el commit, los pasos para reproducir el problema y el resultado observado. Adjunta la prueba o el bloque si forma parte del hallazgo. La [política de seguridad](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/SECURITY.md) define el alcance. No hay programa de recompensas por errores.


---

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