> 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/build-with-canton.md).

# Construir con Canton

A qué puedes apuntar en Ostia más allá de los simples contratos EVM, las piezas de Canton con las que puedes construir y cuáles puedes hacer por tu cuenta en DevNet hoy y cuáles ejecuta Rome.

Ostia ejecuta contratos EVM ordinarios y también se conecta con Canton. Las solicitudes a Canton de un bloque son legs y se confirman en la misma transacción de Canton que el bloque. Esta página enumera los destinos posibles, los componentes que hay detrás de cada uno y quién puede usarlos hoy en DevNet.

El código de cada componente está en el repositorio público, [rome-protocol/canton-zk-evm](https://github.com/rome-protocol/canton-zk-evm), bajo la licencia Apache 2.0.

| Destino                                                        | Qué es                                                                          | Disponibilidad actual en DevNet                                                                                                                                                                                            |
| -------------------------------------------------------------- | ------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Contratos EVM](#evm-contracts)                                | Aplicaciones de Solidity desplegadas con las herramientas que usas en Ethereum. | Lo haces por tu cuenta.                                                                                                                                                                                                    |
| [Canton Coin en tus contratos](#canton-coin-in-your-contracts) | Canton Coin como CC ERC-20.                                                     | Lo haces por tu cuenta, con [Bridge](https://docs.rome.builders/es/canton-zk-evm/bridge.md).                                                                                                                               |
| [Un token EVM en Canton con un twin](#erc-20-twins-on-canton)  | Un ERC-20 con un twin, un token CIP-0056.                                       | Rome lo ejecuta con WtROME (de tROME) y TKA. Bridge los mueve para una billetera de Canton cuando se habiliten las billeteras. Por ahora, ninguna billetera externa de Canton tiene twins. Rome registra los nuevos twins. |
| [Pagos con parties de Canton](#payments-with-canton-parties)   | Un pago ERC-20 que ejecuta una asignación de Canton en la misma transacción.    | Rome lo ejecuta con parties de prueba; no puedes ejecutarlo por tu cuenta en DevNet.                                                                                                                                       |
| [Un mercado de Canton](#a-canton-venue)                        | Una aplicación Daml que intercambia un token de Canton por un ERC-20.           | Rome ejecuta el mercado; se ha ejecutado una vez. No puedes ejecutar un mercado en DevNet.                                                                                                                                 |
| [Tu propia red](#your-own-network)                             | Toda la pila en una red local de Canton.                                        | Lo haces todo tú.                                                                                                                                                                                                          |

## Contratos EVM

Despliega con Foundry o Hardhat, verifica el código fuente en el explorador y conéctate con viem o ethers. [Crear en Ostia](https://docs.rome.builders/es/canton-zk-evm/build-on-ostia.md) contiene los pasos y [Ostia DevNet](https://docs.rome.builders/es/canton-zk-evm/devnet.md#limits) contiene los límites. En Ostia se han ejecutado ERC-20, ERC-721, ERC-1155, un token con permisos ERC-3643, Uniswap V2 y los contratos que verifican las pruebas Merces de TACEO. Se desplegó y verificó un consumidor de precios de RedStone.

## Canton Coin en tus contratos

Canton Coin en Ostia es un ERC-20 ordinario con 10 decimales, en la dirección `0x4db3dea7c13116961fd3e438542ccfcca61a7547`. Cualquier contrato puede tenerlo y transferirlo. La custodia del gateway en Canton lo respalda en una proporción de uno a uno, y el explorador muestra ambos uno al lado del otro en [`/twins`](https://ostia.devnet.romeprotocol.xyz/twins) y en `GET /api/twins`.

Obtienes CC depositando Canton Coin en la página [Bridge](https://docs.rome.builders/es/canton-zk-evm/bridge.md) y recuperas Canton Coin al retirarlo. La página entrega 20 Canton Coin de prueba al día.

## Twins ERC-20 en Canton

Pagas un ERC-20 al vault y una party de Canton tiene la misma cantidad de su twin. El twin es un token CIP-0056 con el ID de instrumento `erc20:<token address>`. Al canjearlo, se quema el twin y se devuelve el ERC-20 a una dirección de Ostia.

**Quién tiene twins actualmente.** Los twins implementan CIP-0056, pero eso no hace que aparezcan en todas las billeteras de Canton. Una party puede tener un twin cuando todos los validadores que lo alojan hayan aprobado `ostia-twin` 0.1.0 y 0.2.0; además, una party que recibe un bloqueo también debe firmar un `TwinAcceptance`de un solo uso. Hoy en día, solo las parties que gestiona Rome cumplen esos requisitos. Por ahora, ninguna billetera externa de Canton tiene ni envía twins.

**Conecta tu propia wallet de Canton: está construida, pero no activada.** La página Bridge conecta la wallet de Canton que ya tienes, y la cuenta de Bridge creada mediante una firma de wallet se retiró el 2026-11-17. La conexión se activa wallet por wallet, sin una fecha establecida. Depende de tres cosas que deciden los creadores de wallets y los validadores: revisan un paquete Daml de terceros antes de que su wallet lo permita; algunas de sus reglas bloquean los nombres de paquetes que empiezan por `canton-` (el paquete de nuestra cadena se llama `canton-zk-evm`), y los validadores que alojan las partes de una wallet deben tener los paquetes de Ostia. Hasta entonces, ninguna wallet externa de Canton puede realizar operaciones en Bridge. En DevNet, los activos gemelos son TKA y WtROME, y la bóveda está en `0x69f13a94f986021f1a7650eb611bf9b717aa495a`.

El servicio de registro de activos gemelos responde en `https://ostia.devnet.romeprotocol.xyz/twin-registry` (por ejemplo, `GET /twin-registry/healthz`). No guarda ninguna clave.

| Llamada                                                                         | Qué proporciona                                                                                                                                                                                                                             |
| ------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `GET /healthz`                                                                  | Los activos gemelos y las bóvedas.                                                                                                                                                                                                          |
| `GET /twin/v1/twins`                                                            | El token, el identificador del instrumento y las bóvedas de cada activo gemelo.                                                                                                                                                             |
| `GET /registry/...`                                                             | La API de registro del estándar del token: los metadatos del activo gemelo y las fábricas de transferencias y asignaciones, para que una wallet cuyos validadores hayan aprobado el paquete del activo gemelo pueda enviar activos gemelos. |
| `POST /twin/v1/lock-parts` con `{"receiver": <Canton party id>, "ref": <text>}` | El identificador del bloqueo y las bóvedas registradas, para que el pagador los use en un bloqueo.                                                                                                                                          |

El receptor de un bloqueo firma una `TwinAcceptance` una sola vez. Sin ella, el registro responde con 409 y el constructor excluye el bloqueo del bloque antes de demostrarlo, por lo que el ERC-20 permanece en manos del pagador. Una wallet de Canton que conectes a la página Bridge firma su aceptación al optar por participar. El pagador comprueba por su cuenta el identificador del bloqueo, el SHA-256 de `lock,<receiver>,<ref>`y obtiene la bóveda de una fuente de confianza.

Puedes comprobar que la bóveda corresponde a la compilación revisada. `cast keccak $(cast code 0x69f13a94f986021f1a7650eb611bf9b717aa495a --rpc-url $RPC)` devuelve `0x2fbcf33083dd26a360690a0d8d24cd333997b3c7000d950aa5e564e01460d4da`, que también es el hash del código que `GET /api/twins` informa.

Actualmente, solo Rome registra activos gemelos y bóvedas en DevNet. Para solicitar un activo gemelo de tu propio ERC-20, abre un issue en el [repositorio](https://github.com/rome-protocol/canton-zk-evm/issues) o pregúntalo en el [Discord](https://discord.gg/vZ9rnCdNSB)de Rome; Rome decide caso por caso.

## Pagos con parties de Canton

Un pagador de EVM llama a `pay`. El pagador y el beneficiario de Canton han firmado `DvpTerms` que especifican la asignación, el identificador del pago, el token de EVM, el beneficiario de EVM y el importe. En una única transacción de Canton se confirma el bloque y se ejecuta la asignación, por lo que ninguno de los dos queda finalizado sin el otro. Se ejecutó en DevNet en los bloques 783 y 1471. [Depósitos, retiros y pagos](https://docs.rome.builders/es/canton-zk-evm/deposits-withdrawals-payments.md#tie-a-payment-to-one-allocation) contiene las reglas.

En DevNet, las partes de prueba de Rome realizan estos pagos. La página Bridge no los ejecuta: realiza las cuatro operaciones del puente. Para ejecutar pagos vinculados a una asignación entre tus propias partes de Canton, ejecuta tu propia red (más abajo).

## Un mercado de Canton

Un espacio de negociación es una aplicación Daml que ejecuta una operación entre un vendedor de Canton y un comprador de EVM. Sus componentes:

* `otc-venue` 0.1.0, en [`apps/otc`](https://github.com/rome-protocol/canton-zk-evm/tree/main/apps/otc), contiene el `TradeOffer` y el `Trade`. Solo depende del estándar de tokens, CIP-0056, y no especifica la cadena, así que cualquier plataforma puede usarlo. La `Trade` muestra al vendedor una solicitud de asignación en una cartera estándar.
* El paquete Daml de la cadena (0.4.0 y posteriores, con 0.5.0 fijado) contiene el `VenueTrade` y el `FundedClaim`. La plataforma y el vendedor firman el `VenueTrade` para cada operación.
* El comprador paga a través de la pasarela. La asignación del vendedor se ejecuta en la misma transacción de Canton que el pago, y después el comprador reclama el token envuelto con un `FundedClaim`.

Se ejecutó en DevNet el 2026-10-27 a las 15:55 UTC: el token Canton TKB se intercambió por el token ERC-20 TKA. El pago del comprador está en el bloque 16816, en una actualización de Canton, y la reclamación del comprador está en el bloque 16823. Un pago inferior al importe de la operación se excluyó del bloque 16834 y no movió nada. El explorador muestra los intercambios en [`/swaps`](https://ostia.devnet.romeprotocol.xyz/swaps)y `GET /api/swaps` los devuelve.

En DevNet, el builder se inicia con la parte de la plataforma, así que Rome añade una plataforma. Los comandos para realizar un intercambio están en la demostración del repositorio, para una red local o una instancia propia. Antes de la red principal está prevista una etapa en la que el vendedor propone la operación.

## Tu propia red

[Ejecuta tu propio Ostia](https://docs.rome.builders/es/canton-zk-evm/run-it-locally.md) inicia una red local de Canton y toda la pila: la cadena, el prover o su sustituto, la pasarela y el explorador. En ella ejecutas tú mismo todos los componentes anteriores, excepto Canton Coin, que requiere un validador de Canton Network; para ello, ejecuta Ostia en el participante de tu propio validador (consulta [Ejecuta tu propio Ostia](https://docs.rome.builders/es/canton-zk-evm/run-it-locally.md#run-on-an-existing-participant)). Usas tus propias partes y tu propia plataforma.

Una aplicación Daml ve las partes de las operaciones que firma. Cualquiera puede leer todas las partes mediante `GET /api/legs` en el explorador.

## Qué hacer a continuación

* [Casos de uso](https://docs.rome.builders/es/canton-zk-evm/use-cases.md): lo que estos componentes hacen posible hoy.
* [Bridge](https://docs.rome.builders/es/canton-zk-evm/bridge.md): la página del navegador para los cuatro movimientos y para enviar fondos en Canton.
* [Cómo funciona](https://docs.rome.builders/es/canton-zk-evm/how-it-works.md): un bloque, desde la transacción hasta la confirmación en Canton.


---

# 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/build-with-canton.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.
