> For the complete documentation index, see [llms.txt](https://docs.rome.builders/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.rome.builders/pt-br/canton-zk-evm/build-with-canton.md).

# Construa com Canton

O que você pode direcionar na Ostia além de contratos EVM puros, os componentes de Canton com os quais você pode construir e quais você pode fazer por conta própria na DevNet hoje e quais rodam em Rome.

Ostia executa contratos EVM comuns e também se conecta ao Canton. As solicitações de um bloco ao Canton são chamadas de legs e são confirmadas na mesma transação do Canton que o bloco. Esta página lista os alvos disponíveis, os componentes por trás de cada alvo e quem pode usá-los hoje na DevNet.

O código de todos os componentes está no repositório aberto, [rome-protocol/canton-zk-evm](https://github.com/rome-protocol/canton-zk-evm), sob a licença Apache 2.0.

| Alvo                                                              | O que é                                                                       | Disponível hoje na DevNet                                                                                                                                                                                                            |
| ----------------------------------------------------------------- | ----------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| [Contratos EVM](#evm-contracts)                                   | Aplicações Solidity, implantadas com as ferramentas que você usa na Ethereum. | Você faz isso por conta própria.                                                                                                                                                                                                     |
| [Canton Coin nos seus contratos](#canton-coin-in-your-contracts)  | Canton Coin como o CC ERC-20.                                                 | Você faz isso por conta própria, usando a [Bridge](https://docs.rome.builders/pt-br/canton-zk-evm/bridge.md).                                                                                                                        |
| [Um token EVM no Canton como twin](#erc-20-twins-on-canton)       | Um ERC-20 com um twin, um token CIP-0056.                                     | A Rome oferece isso com WtROME (de tROME) e TKA. Quando as carteiras estiverem habilitadas, a Bridge os transferirá para uma carteira do Canton. Nenhuma carteira externa do Canton mantém twins ainda. A Rome registra novos twins. |
| [Pagamentos com parties do Canton](#payments-with-canton-parties) | Um pagamento em ERC-20 que executa uma alocação do Canton na mesma transação. | A Rome oferece isso com parties de teste; você não pode executar essa operação por conta própria na DevNet.                                                                                                                          |
| [Um ambiente de negociação no Canton](#a-canton-venue)            | Uma aplicação Daml que troca um token do Canton por um ERC-20.                | A Rome oferece o ambiente de negociação; ele foi executado uma vez. Você não pode executar um ambiente de negociação na DevNet.                                                                                                      |
| [Sua própria rede](#your-own-network)                             | Toda a infraestrutura em uma rede local do Canton.                            | Você faz tudo.                                                                                                                                                                                                                       |

## Contratos EVM

Implante com Foundry ou Hardhat, verifique o código-fonte no explorador e conecte-se com viem ou ethers. [Build on Ostia](https://docs.rome.builders/pt-br/canton-zk-evm/build-on-ostia.md) contém as etapas, e [Ostia DevNet](https://docs.rome.builders/pt-br/canton-zk-evm/devnet.md#limits) descreve as limitações. ERC-20, ERC-721, ERC-1155, um token permissionado ERC-3643, Uniswap V2 e os contratos que verificam provas TACEO Merces já foram executados na Ostia. Um consumidor de preços RedStone foi implantado e verificado.

## Canton Coin nos seus contratos

A Canton Coin na Ostia é um ERC-20 comum com 10 casas decimais, no endereço `0x4db3dea7c13116961fd3e438542ccfcca61a7547`. Qualquer contrato pode mantê-la e transferi-la. A custódia do gateway no Canton a lastreia na proporção de um para um, e o explorador mostra os dois lado a lado em [`/twins`](https://ostia.devnet.romeprotocol.xyz/twins) e em `GET /api/twins`.

Você recebe CC ao depositar Canton Coin na página [Bridge](https://docs.rome.builders/pt-br/canton-zk-evm/bridge.md) e recebe Canton Coin de volta ao sacá-la. A página oferece 20 Canton Coin de teste por dia.

## Twins ERC-20 no Canton

Você deposita um ERC-20 no cofre, e uma party do Canton mantém a mesma quantidade do seu twin. O twin é um token CIP-0056 com o ID de instrumento `erc20:<token address>`. O resgate queima o twin e devolve o ERC-20 a um endereço da Ostia.

**Quem mantém twins hoje.** Os twins implementam CIP-0056, mas isso não significa que apareçam em todas as carteiras do Canton. Uma party pode manter um twin quando todos os validadores que o hospedam tiverem aprovado `ostia-twin` 0.1.0 e 0.2.0; além disso, uma party que recebe um bloqueio também precisa assinar uma única vez `TwinAcceptance`. Hoje, somente as parties operadas pela Rome atendem a esses requisitos. Nenhuma carteira externa do Canton mantém ou envia twins ainda.

**Conecte sua própria carteira Canton: implementada, mas ainda não ativada.** A página Bridge conecta a carteira Canton que você já tem, e a conta Bridge criada com uma assinatura da carteira foi desativada em 2026-11-17. A conexão é ativada carteira por carteira, sem uma data definida. Ela depende de três fatores decididos pelos criadores das carteiras e pelos validadores: eles analisam um pacote Daml de terceiros antes de permitir seu uso pela carteira; algumas de suas regras bloqueiam nomes de pacotes que começam com `canton-` (o pacote da nossa cadeia se chama `canton-zk-evm`); e os validadores que hospedam as partes de uma carteira precisam manter os pacotes da Ostia. Até lá, nenhuma carteira Canton externa pode fazer uma operação na Bridge. Na DevNet, os twins são TKA e WtROME, e o cofre fica em `0x69f13a94f986021f1a7650eb611bf9b717aa495a`.

O serviço de registro de twins responde em `https://ostia.devnet.romeprotocol.xyz/twin-registry` (por exemplo, `GET /twin-registry/healthz`). Ele não armazena nenhuma chave.

| Chamada                                                                         | O que ela fornece                                                                                                                                                                                  |
| ------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `GET /healthz`                                                                  | Os twins e os cofres.                                                                                                                                                                              |
| `GET /twin/v1/twins`                                                            | O token, o ID do instrumento e os cofres de cada twin.                                                                                                                                             |
| `GET /registry/...`                                                             | A API de registro do padrão do token: os metadados do twin e as fábricas de transferência e alocação, para que uma carteira cujos validadores tenham aprovado o pacote do twin possa enviar twins. |
| `POST /twin/v1/lock-parts` com `{"receiver": <Canton party id>, "ref": <text>}` | O ID do bloqueio e os cofres registrados, para que o pagador os use no bloqueio.                                                                                                                   |

O destinatário de um bloqueio assina um `TwinAcceptance` uma vez. Sem essa assinatura, o registro responde com 409 e o construtor exclui o bloqueio do bloco antes de prová-lo, de modo que o ERC-20 permanece com o pagador. Uma carteira Canton que você conecta à página Bridge assina sua aceitação durante a adesão. O pagador verifica o próprio ID do bloqueio, o SHA-256 de `lock,<receiver>,<ref>`e obtém o cofre de uma fonte confiável.

Você pode verificar se o cofre corresponde à versão revisada. `cast keccak $(cast code 0x69f13a94f986021f1a7650eb611bf9b717aa495a --rpc-url $RPC)` retorna `0x2fbcf33083dd26a360690a0d8d24cd333997b3c7000d950aa5e564e01460d4da`, que também é o hash do código informado por `GET /api/twins` .

Atualmente, somente a Rome registra twins e cofres na DevNet. Para solicitar um twin do seu próprio ERC-20, abra uma issue no [repositório](https://github.com/rome-protocol/canton-zk-evm/issues) ou pergunte no Discord da [Rome](https://discord.gg/vZ9rnCdNSB); a Rome decide caso a caso.

## Pagamentos com parties do Canton

Um pagador EVM chama o método `pay`. O pagador e o recebedor Canton assinaram `DvpTerms` que especificam a alocação, o ID do pagamento, o token EVM, o recebedor EVM e o valor. Em uma única transação Canton, o bloco é confirmado e a alocação é executada, portanto nenhum dos dois é finalizado sem o outro. Isso foi executado na DevNet nos blocos 783 e 1471. [Depósitos, saques e pagamentos](https://docs.rome.builders/pt-br/canton-zk-evm/deposits-withdrawals-payments.md#tie-a-payment-to-one-allocation) contém as regras.

Na DevNet, as partes de teste da Rome executam esses pagamentos. A página Bridge não os executa: ela realiza as quatro operações de bridge. Para executar pagamentos vinculados a uma alocação entre suas próprias partes Canton, execute sua própria rede (abaixo).

## Um ambiente de negociação no Canton

Um venue é um app Daml que executa uma negociação entre um vendedor Canton e um comprador EVM. Os componentes:

* `otc-venue` 0.1.0, em [`apps/otc`](https://github.com/rome-protocol/canton-zk-evm/tree/main/apps/otc), contém o `TradeOffer` e o `Trade`. Ele depende apenas do padrão de token, CIP-0056, e não especifica a rede, então qualquer venue pode usá-lo. O `Trade` mostra ao vendedor uma solicitação de alocação em uma carteira padrão.
* O pacote Daml da rede (0.4.0 e posteriores, 0.5.0 fixado) contém o `VenueTrade` e o `FundedClaim`. O venue e o vendedor assinam o `VenueTrade` para cada negociação.
* O comprador paga pelo gateway. A alocação do vendedor é executada na mesma transação Canton que o pagamento, e então o comprador reivindica o token wrapped com um `FundedClaim`.

Ele foi executado na DevNet em 2026-10-27 às 15:55 UTC: o token Canton TKB foi trocado pelo TKA ERC-20. O pagamento do comprador está no bloco 16816, em uma única atualização Canton, e a reivindicação do comprador está no bloco 16823. Um pagamento inferior ao valor da negociação foi excluído do bloco 16834 e não movimentou nada. O explorador lista as trocas em [`/swaps`](https://ostia.devnet.romeprotocol.xyz/swaps)e `GET /api/swaps` as retorna.

Na DevNet, o builder é iniciado com a party do venue, então Rome adiciona um venue. Os comandos para executar uma troca estão na demonstração do repositório, para uma rede local ou sua própria execução. Uma etapa em que o vendedor propõe a negociação está planejada para antes da mainnet.

## Sua própria rede

[Execute sua própria Ostia](https://docs.rome.builders/pt-br/canton-zk-evm/run-it-locally.md) inicia uma rede Canton local e toda a pilha: a blockchain, o provador ou seu substituto, o gateway e o explorador. Nela, você mesmo executa todos os componentes acima, exceto o Canton Coin, que requer um validador Canton Network; para isso, execute a Ostia no participant do seu próprio validador (consulte [Execute sua própria Ostia](https://docs.rome.builders/pt-br/canton-zk-evm/run-it-locally.md#run-on-an-existing-participant)). Você usa suas próprias parties e seu próprio venue.

Um aplicativo Daml vê as etapas que assina. Qualquer pessoa pode ler todas as etapas por meio de `GET /api/legs` no explorador.

## Próximos passos

* [Casos de uso](https://docs.rome.builders/pt-br/canton-zk-evm/use-cases.md): o que esses componentes possibilitam hoje.
* [Bridge](https://docs.rome.builders/pt-br/canton-zk-evm/bridge.md): a página no navegador para as quatro operações e para enviar pela Canton.
* [Como funciona](https://docs.rome.builders/pt-br/canton-zk-evm/how-it-works.md): um bloco, da transação ao commit do 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/pt-br/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.
