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

# Modelo de confiança e limites

As verificações, autoridades, pressupostos de custódia e limites da Ostia na DevNet da Canton Network.

Ostia é uma versão inicial no DevNet da Canton Network. Rome executa todos os serviços do Ostia: o único builder, o prover, o RPC público, o explorador, o faucet, o serviço de registro de twins e o participante que hospeda todas as parties do Ostia (o próprio validador de DevNet de Rome). O sincronizador do DevNet da Canton Network, que ordena os blocos, é executado pela rede, não por Rome. O único sidecar de Rome é o único confirmer. Esta página explica quem verifica o quê e quem detém o quê. Não use Ostia para nada de valor.

**Em quem você confia hoje.** Rome executa o prover e o único participante confirmador. O participante de Rome detém a custódia da Canton Coin e a administração dos twins. O código e o ZisK (alfa) não foram auditados. Isto é apenas DevNet.

Esta página descreve a versão `v0.1.0` e, quando indicado, o que está em execução no DevNet agora. [Status](https://docs.rome.builders/pt-br/canton-zk-evm/status.md) identifica o commit executado no DevNet. Leia o [design](https://github.com/rome-protocol/canton-zk-evm/blob/main/docs/DESIGN.md) e a [política de segurança](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/SECURITY.md).

## Demonstração local vs. Ostia DevNet

A demonstração de 2026-10-05 foi executada em uma rede Canton local. As verificações usam o mesmo código em ambas. A configuração de confiança não é a mesma.

|                                | Rede da demonstração local                                                    | Ostia DevNet                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| ------------------------------ | ----------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Participantes                  | Três: operador, confirmer e usuários.                                         | Um participante, o de Rome, hospeda todas as parties do Ostia. Um segundo participante de Rome ainda não hospeda nenhuma.                                                                                                                                                                                                                                                                                                                                                           |
| Confirmers                     | 2, cada um com seu próprio sidecar.                                           | 1, o sidecar junto desse participante.                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| Persistência                   | Perde seu estado ao reiniciar, a menos que seja iniciado em modo persistente. | A cadeia persiste no participante. Ainda assim, o DevNet pode ser redefinido.                                                                                                                                                                                                                                                                                                                                                                                                       |
| Acesso à Ledger API            | Sem autenticação, em uma única máquina.                                       | Cada usuário da Ledger API do Ostia precisa de um token de curta duração.                                                                                                                                                                                                                                                                                                                                                                                                           |
| Quem opera o quê               | Quem o inicia executa todas as parties em uma única máquina.                  | Rome executa todos os serviços do Ostia: o participante que hospeda as parties, o builder, o prover, o RPC, o explorador, o faucet e o registro de twins. A rede executa o sincronizador.                                                                                                                                                                                                                                                                                           |
| Canton                         | Canton 3.6.3 em `v0.1.0`; as execuções de 2026-10-05 usaram snapshots 3.6.    | O validador de Rome executa o Splice 0.10.1 com Canton 3.7.2 (desde 2026-11-07). O sincronizador do DevNet está na versão 37 do protocolo (desde 2026-11-18). Daml SDK 3.6.0, damlc 3.6.2.                                                                                                                                                                                                                                                                                          |
| Depósitos, saques e pagamentos | Exibidos na demonstração de 2026-10-05.                                       | Em operação desde 2026-10-25 com o token de teste TKB. Rome executa as parties de teste e todas as etapas.                                                                                                                                                                                                                                                                                                                                                                          |
| Twins e Canton Coin            | Não incluídos na versão `v0.1.0`.                                             | Em operação desde 2026-10-29: twins ERC-20 por meio do vault e transferências de entrada e saída da Canton Coin. De 2026-11-08 a 2026-11-17, a página Bridge podia abrir uma conta Canton usando uma assinatura da carteira; essa conta foi desativada (consulte [a conta Bridge criada com uma assinatura da carteira](#the-bridge-account-made-from-a-wallet-signature)). A página Bridge conecta a carteira Canton que você já tem; o recurso foi ativado carteira por carteira. |

O [README da rede](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 um único confirmer é menos seguro do que a rede local, mas aceitável para o DevNet.

## Quem verifica o quê

| Parte            | Verificação ou autoridade                                                                                                                                                                   |
| ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Convidado        | Valida o bloco EVM e rejeita qualquer configuração de cadeia diferente das regras compiladas da Ostia.                                                                                      |
| Sidecar `verify` | Verifica a prova, o programVK e o rootC fixados, o hash do bloco comprovado, o cabeçalho e a lista de transações.                                                                           |
| Sidecar `legs`   | Verifica as provas de conta e armazenamento do gateway e compara as legs anexadas, na ordem, com o hash comprovado do gateway.                                                              |
| Daml `Advance`   | Verifica as respostas do sidecar, o bloco pai, o número do próximo bloco, o limite de gas e os contratos usados pelas legs. Liquida as legs e cria o próximo registro de cabeçalho e bloco. |
| Canton           | Ordena os blocos por meio do consumo do único contrato de estado da cadeia e confirma em conjunto as alterações da transação. Rejeita respostas diferentes para chamadas externas.          |
| Construtor       | Seleciona transações, verifica os contratos Canton que consegue ver, obtém uma prova e envia o bloco. Não pode finalizar um bloco por conta própria.                                        |

Um sidecar é executado junto a cada participante confirmador. Na DevNet, há apenas um, junto ao participante que hospeda todas as partes da Ostia — o de Rome. Portanto, hoje, a prova é verificada pelo próprio nó de Rome. O sincronizador do Canton ordena os blocos e retransmite as mensagens; ele não vê a prova. Cada sidecar calcula suas respostas exclusivamente com base na entrada enviada na chamada externa. O Daml compara as respostas; ele não realiza a verificação criptográfica da prova. O [README do sidecar](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/sidecar/README.md) e o [README do Daml](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/daml/README.md) apresentam as verificações e os requisitos de autoridade.

## O que a prova fixa

A chave de programa fixada identifica o guest e as regras da cadeia. A prova se compromete com um hash de bloco. A verificação do cabeçalho vincula a raiz de estado e a raiz de transações. Em seguida, as provas de conta e armazenamento vinculam o hash de legs registrado pelo gateway a essa raiz de estado.

As legs anexadas devem ter os mesmos campos e a mesma ordem que as registradas pelo gateway. Remover uma leg, adicionar uma ou alterar o destinatário, o valor, o token ou o ID faz a comparação dos hashes falhar. Um bloco sem legs também deve comprovar essa ausência. A comparação das legs também depende da resistência a colisões do Keccak-256.

A raiz de estado da gênese registrada na cadeia fixa o código do gateway. O contrato do gateway não tem proprietário, chave de administrador, mecanismo de atualização nem pausa. A parte do Canton ainda tem autoridade de custódia sobre os tokens que detém.

## Autoridade do operador, do confirmador e do gateway

O operador e o gateway propõem a gênese da cadeia, os valores fixados, o limite de gas e o construtor. O confirmador aceita a proposta. Espera-se que ele compare os valores fixados e o código do gateway na gênese com sua própria compilação. Os scripts fornecidos propõem valores correspondentes e aceitam imediatamente a proposta em nome do confirmador.

O operador, o confirmador e o gateway assinam `ZkChain`. Eles são a raiz de confiança da cadeia. As opções de liquidação de depósitos e saques exigem os três, e a liquidação de pagamentos exige o operador e o confirmador. `Advance` fornece a autoridade conjunta deles. O construtor, sozinho, não pode exercer as opções de liquidação.

Na DevNet, Rome executa o único participante que hospeda todas essas partes. Rome, como operador, consegue ver todos os contratos da Ostia e tem o que é necessário para agir em nome de todas as partes da Ostia, incluindo o confirmador e o gateway. As contas Canton criadas pela conta Bridge desativada também são hospedadas lá (consulte [a conta Bridge criada a partir de uma assinatura de carteira](#the-bridge-account-made-from-a-wallet-signature)).

**Custódia.** A parte do gateway detém os tokens Canton que lastreiam os tokens wrapped na EVM. Ela é hospedada no participante do operador. Quem executa esse participante — Rome, na DevNet — pode movimentar os tokens bloqueados fora das regras de saque. A ausência de uma chave de administrador no contrato do gateway não limita a capacidade dessa parte Canton de agir por meio de seu participante. Na DevNet, o gateway detém apenas tokens de teste: a execução de Rome em 2026-10-25 verificou que ele detinha 12 TKB, o token de teste de referência distribuído pelo Splice, em relação a uma oferta de 12 wTKB, que qualquer pessoa pode consultar na Ostia. Os tokens ERC-20 que lastreiam os twins ficam no vault, um contrato EVM sem proprietário, conforme descrito [na seção sobre twins](#what-the-twins-trust) .

O registro de tokens é outra decisão de confiança. O operador e o gateway propõem o mapeamento de um instrumento Canton para um token wrapped EVM, e o confirmador o aceita. O gateway executa o código de transferência Daml do token registrado com sua própria autoridade; portanto, registrar um token também significa confiar no código Daml do seu registro.

Tokens enviados diretamente para o endereço EVM do gateway não podem ser recuperados. Se um token cobrar uma taxa de transferência ou transferir, de outra forma, um valor diferente, a leg de pagamento ainda registrará o valor solicitado. O [README da rede](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/network/README.md#the-canton-network) descreve a hospedagem dos participantes e as verificações de registro.

## Em que os twins confiam

Um twin é a forma Canton de um ERC-20 mantido pelo vault (consulte [Depósitos, saques e pagamentos](https://docs.rome.builders/pt-br/canton-zk-evm/deposits-withdrawals-payments.md#canton-twins-of-erc-20-tokens)). Estes são os pontos dos quais ele depende:

* **A cadeia emite e queima por meio de `Advance`.** De acordo com as regras da cadeia, um twin é emitido dentro de `Advance`, contra uma linha de bloqueio fixada pela prova: um pagamento comprovado para um vault registrado no registro da cadeia. `Advance` queima um twin somente contra uma solicitação de resgate assinada por seu titular. O registro da cadeia fixa o endereço do token, as casas decimais e o contrato de regras de cada twin, e uma solicitação de bloqueio para outro token é recusada.
* **O vault não tem proprietário.** Ele não tem chave, upgrade nem armazenamento, e não pode ser obrigado a pagar um ID que outro tipo de pagamento poderia ter. Qualquer pessoa pode comparar seu código on-chain com a versão revisada.
* **Um cofre é registrado por pessoas.** O operador e o gateway o propõem, e o confirmador o aceita depois de ler o código implantado. O que o contrato faz é protegido por essa leitura.
* **O administrador do twin é a parte do gateway.** Somente o administrador controla o `Mint` e o `Burn`, então a parte do gateway também pode criar ou queimar um twin fora de `Advance`, sem bloqueio nem solicitação de resgate. A parte do gateway é hospedada no participante da Rome, então, na DevNet, a Rome pode agir por ela, assim como pode agir por todas as partes da Ostia que executa. Ela assina a posse de cada twin, então pode queimar, criar e transferir os twins que qualquer parte do Canton possui, incluindo os de uma carteira Canton conectada à [Bridge](https://docs.rome.builders/pt-br/canton-zk-evm/bridge.md), sem a assinatura dessa parte. Antes da mainnet, o operador e o confirmador também deverão assinar as operações de criação e queima. O explorador mostra o suprimento de cada twin em relação ao que o cofre mantém, para que qualquer pessoa possa ver se os valores correspondem.
* **O serviço de registro é apenas uma indicação.** Ele informa ao pagador o ID do bloqueio e o cofre, e não guarda nenhuma chave. O construtor e o `Advance` verificam se as partes correspondem ao ID; o pagador verifica o próprio ID (o SHA-256 de `lock,<receiver>,<ref>`) e obtém o endereço do cofre de uma fonte em que confia. O registro na chain que identifica os cofres registrados só pode ser lido pelas partes da Rome; portanto, na DevNet, essa fonte é a Rome.

## A conta Bridge criada a partir de uma assinatura de carteira

Desativada em 2026-11-17. De 2026-11-08 a 2026-11-17, a página da [Bridge](https://docs.rome.builders/pt-br/canton-zk-evm/bridge.md) podia abrir uma conta Canton com uma assinatura de carteira: a página transformava a assinatura em uma chave Ed25519, que era a única chave de assinatura da conta. O serviço de contas que ajudava a abrir essas contas foi encerrado, e a página não oferece mais esse acesso, não cria a chave nem a mantém no navegador (ela exclui o que uma visita anterior armazenou). A conexão da sua própria carteira Canton substitui esse recurso, sendo habilitada carteira por carteira; consulte [Criar com Canton](https://docs.rome.builders/pt-br/canton-zk-evm/build-with-canton.md#erc-20-twins-on-canton) para saber do que isso depende, e [Bridge](https://docs.rome.builders/pt-br/canton-zk-evm/bridge.md).

As contas que foram abertas continuam na Canton DevNet, hospedadas no participante da Rome, com os ativos que possuem, até a DevNet ser reiniciada. Nenhum sistema aceita mais as chaves delas, então ninguém, nem mesmo a Rome, assina ou envia transações por elas. Elas continham apenas ativos de teste da DevNet.

Para registro, eis o que era a conta:

* **A chave era derivada somente da assinatura.** O EIP-712 vincula uma assinatura aos dados tipados, não ao site que a solicita; portanto, qualquer pessoa que obtivesse a assinatura poderia criar a chave. Uma carteira que deixasse de produzir a mesma assinatura não poderia reabrir a conta. Não havia revogação nem recuperação.
* **A Rome não podia assinar por ela, mas executava aquilo de que ela dependia.** A Rome executava o código usado pelos contratos da conta, era o único nó que hospedava a conta e administrava os twins; assim, podia queimar, criar e transferir os twins que a conta possuía sem a assinatura de seu titular. A aceitação permanente de saques da conta permitia que escolhas executadas pelas partes da Rome agissem em seu nome quando um saque era solicitado.

A administração dos twins e a aceitação de saques não são exclusivas da conta Bridge: a parte do gateway assina a posse de cada twin, e uma carteira Canton que opta por participar assina as mesmas duas aceitações. Consulte [O que os twins consideram confiável](#what-the-twins-trust).

## O que pode impedir um bloco

Para incluir uma etapa, o construtor precisa de acesso de leitura às solicitações, aos termos, às aceitações, às alocações, aos registros de tokens e às posses do gateway correspondentes. Ele omite qualquer transação cujos contratos Canton não consiga ver.

Uma alocação pode ser revogada depois que o construtor a verifica ou depois da geração da prova. Um registro de tokens também pode recusar a liquidação de acordo com suas próprias regras. Nesse caso, o Canton recusa o bloco e nada é confirmado.

O construtor é executado continuamente e cria um bloco sempre que há transações que podem ser incluídas à espera. O padrão do código é manter um bloco em andamento, e a DevNet executa até dois. Se ocorrer uma recusa que ele não pôde prever, como uma regra própria de um registro, ele marca uma transação após duas recusas consecutivas de bloco e a deixa de fora durante um período de espera, de 10 minutos por padrão. Ele tenta a transação novamente quando esse período termina. Uma reinicialização faz com que ele esqueça o que deixou de fora.

O construtor não limita as etapas de execução antes da geração da prova, e um provador que nunca retorna interrompe o processo. O [README do construtor](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/builder/README.md#not-here) lista os limites.

## O que esta versão não oferece

* **Descentralização.** Há um construtor, um provador e um confirmador, e a Rome executa o construtor, o provador, o RPC, o explorador, a faucet e o participante que hospeda todas as partes.
* **Resistência à censura ou inclusão forçada.** O RPC e o construtor podem recusar ou omitir uma transação, e não há outro caminho para uma transação chegar à chain. O RPC e o explorador são visões da chain operadas pela Rome. O indexador do explorador verifica cada registro em relação ao reth, mas esses serviços não são trustless.
* **Privacidade.** Todas as transações EVM são públicas, e a Rome, como operadora do participante, vê todos os contratos da Ostia. A carga de 2026-10-24 gerou provas de transferências privadas no cliente e as verificou on-chain, mas não há uma rede MPC em execução e nada é liquidado.
* **Valor ou auditorias.** tROME não tem valor. O código e o ZisK 1.4.0-alpha não foram auditados.
* **Permanência.** O DevNet pode ser redefinido, e o histórico da cadeia também.

Não há metas de vazão nem de tempo de bloco. As versões e os hashes exatos estão em [PINS](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/PINS).

O leitor pode verificar novamente as provas dos blocos, mas `BlockRecord` não contém as etapas liquidadas. O botão Verify do navegador verifica a prova, o cabeçalho e as transações; ele não repete as verificações de liquidação das etapas do Canton. [O que é provado e o que não é](https://docs.rome.builders/pt-br/canton-zk-evm/what-is-proven.md) explica o que uma prova informa, e [Status e roteiro](https://docs.rome.builders/pt-br/canton-zk-evm/status.md) explica os próximos passos.

## Relatar um problema de segurança

Use o recurso privado de comunicação de vulnerabilidades do GitHub para `canton-zk-evm`: acesse a aba Security do repositório e selecione **Report a vulnerability**. Não abra uma issue pública para relatar um problema de segurança.

Inclua o componente afetado, o commit, as etapas para reproduzir e o resultado observado. Anexe a prova ou o bloco, caso faça parte da descoberta. A [política de segurança](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/SECURITY.md) define o escopo. Não há programa de recompensas por bugs.


---

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