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

# Explorador

Um guia para o explorer ativo da Ostia DevNet, seu faucet, suas APIs e a verificação da prova no navegador.

O explorador Ostia está disponível em [ostia.devnet.romeprotocol.xyz](https://ostia.devnet.romeprotocol.xyz). Ele combina os dados da EVM do reth com os registros de Canton de cada bloco, que consulta como parte leitora. Use-o para encontrar um bloco ou uma transação, conferir uma prova no navegador, verificar um contrato, obter tROME e ler os mesmos dados por uma API.

Esta página descreve a versão `v0.1.0` e, quando indicado, o que está em execução agora na DevNet. [Status](https://docs.rome.builders/pt-br/canton-zk-evm/status.md) indica o commit em execução na DevNet. Leia o [README completo do explorador](https://github.com/rome-protocol/canton-zk-evm/blob/main/explorer/README.md).

O explorador marca um bloco como final somente quando seu registro está em Canton. Até lá, mostra o bloco do reth como em processo de prova, e uma transação que você acabou de enviar aparece como pendente. Quando não há transações aguardando, o produtor cria um bloco vazio uma vez por minuto; por isso, o bloco mais recente em uma cadeia sem atividade não costuma ter mais do que alguns minutos. Os horários em todas as páginas estão em UTC.

## Visão geral das páginas

| Página            | O que você pode fazer nela                                                                                                                                                                                                                                                                                                                                                                                      |
| ----------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Início            | Pesquise por bloco, transação, endereço ou ID de atualização de Canton. Veja o bloco final mais recente, o bloco em processo de prova, o tempo até a finalização, o tempo de prova e os blocos mais recentes. Uma faixa de status indica se o nó EVM, Canton, o produtor, o provador, o faucet e o verificador estão funcionando corretamente. O cartão com o tempo de commit em Canton abre Chamadas externas. |
| Blocos            | Liste blocos finais, filtre os que têm transações, baixe um CSV e abra um bloco.                                                                                                                                                                                                                                                                                                                                |
| Transações        | Liste transações e filtre pelas ainda não finalizadas, com falha ou chamadas de contrato. Uma transação mostra seu resultado, bloco, atualização de Canton, taxa, entrada decodificada e uma linha do tempo com seus quatro estágios de finalização.                                                                                                                                                            |
| Contratos         | Veja quais contratos foram verificados e com que frequência são usados. A página de um contrato mostra seu código-fonte verificado, ABI, eventos e chamadas de leitura e escrita. As chamadas de escrita passam pela sua carteira.                                                                                                                                                                              |
| Tokens            | Explore tokens ERC-20, ERC-721 e ERC-1155, com seus detentores e transferências. Uma aba lista tokens provenientes de Canton, como wTKB e CC.                                                                                                                                                                                                                                                                   |
| Chamadas externas | Veja como cada bloco foi confirmado em Canton, uma linha por bloco, com seu status, horário de liquidação e tentativas. O link "Chamadas externas" no cabeçalho abre essa página. Veja [Chamadas externas](#external-calls).                                                                                                                                                                                    |
| Estatísticas      | Veja o tempo até a finalização, o tempo de prova, o tempo de commit em Canton, as transações por segundo e a taxa de sucesso em períodos de 1 hora, 6 horas, 24 horas, 7 dias ou 30 dias. Um cartão de ativos de Canton mostra cada oferta em comparação com o que está sob custódia do cofre e da gateway. Um cartão de chamadas externas mostra o desempenho dos commits em Canton.                           |
| Gêmeos            | Veja os ativos bidirecionais de Canton em [`/twins`](https://ostia.devnet.romeprotocol.xyz/twins): a oferta de cada gêmeo em comparação com o saldo do cofre, além dos bloqueios e resgates mais recentes.                                                                                                                                                                                                      |
| Swaps             | Veja os swaps que uma plataforma de Canton realizou com a EVM em [`/swaps`](https://ostia.devnet.romeprotocol.xyz/swaps)e abra um swap para ver seu pagamento e sua reivindicação.                                                                                                                                                                                                                              |
| Ponte             | Conecte sua carteira, obtenha tROME de teste e transfira tokens entre Ostia e Canton usando a carteira de Canton que você já tem (ativada carteira por carteira; até lá, o botão exibirá "Em breve"). Veja [Ponte](https://docs.rome.builders/pt-br/canton-zk-evm/bridge.md).                                                                                                                                   |
| Faucet            | Solicite tROME ou entre com o GitHub para receber a concessão de 100 tROME para desenvolvedores e acompanhe sua solicitação até a finalização.                                                                                                                                                                                                                                                                  |
| API               | Consulte a referência da API gerada a partir do documento OpenAPI. Um botão adiciona a Ostia DevNet à sua carteira.                                                                                                                                                                                                                                                                                             |

O cabeçalho tem uma caixa de pesquisa em todas as páginas, exceto na página Início, que tem a sua própria; a tecla `/` a coloca em foco. Blocos, transações, transações e transferências de um endereço e transferências de um token podem ser baixados como CSV. As páginas acompanham um fluxo ao vivo, então novos blocos aparecem sem recarregar. As páginas de endereço e de trecho da gateway são abertas por links; os endereços também podem ser acessados pela pesquisa. O cabeçalho não tem uma entrada para essas páginas.

## Ler um bloco

A página do bloco exibe os dados da EVM ao lado das informações correspondentes de Canton: o ID da atualização, o horário do registro e o operador e confirmador que assinaram o registro. Ela compara o hash do bloco do reth, o hash do registro e o hash do cabeçalho registrado, e indica se os três coincidem. Também exibe a chave do programa, a versão do ZisK e o hash do bloco lidos da prova, ao lado dos valores esperados pelo explorador. Um valor divergente aparece em vermelho.

Quatro cartões apresentam os números do bloco: transações, tempo de prova, commit em Canton (o tempo entre o envio do bloco e o horário do registro correspondente em Canton) e o tempo entre a criação do bloco e sua finalização. Os cartões de Canton na página Início e em Estatísticas medem o tempo desde o envio até o produtor receber a resposta de Canton; por isso, mostram um valor maior do que este cartão. Um painel, "Como este bloco se tornou final", lista as etapas e seus horários.

Um bloco em processo de prova ainda não está em Canton. A página informa isso e é atualizada até o bloco ser final. Uma transação pode estar aguardando, em processo de prova ou finalizada. A página do bloco lista os trechos da gateway conforme registrados pela EVM. `BlockRecord` não informa como cada perna foi liquidada no Canton, então o explorador não pode exibir isso. Consulte [Pernas e custódia](#legs-and-custody) para ver as pernas ativas na DevNet.

## Pernas e custódia

As pernas do gateway estão ativas na DevNet, executada pela Rome com partes de teste (consulte [Depósitos, saques e pagamentos](https://docs.rome.builders/pt-br/canton-zk-evm/deposits-withdrawals-payments.md)), então estas páginas agora têm conteúdo. Ainda não há um link para elas no cabeçalho; acesse [`/legs`](https://ostia.devnet.romeprotocol.xyz/legs) diretamente ou siga uma perna a partir do bloco correspondente.

* **A lista** em `/legs` mostra todas as pernas, com o tipo (depósito, pagamento ou saque), o bloco, o token, a conta e o valor. Abra uma delas para ver sua própria página em `/leg/<id>`. Um saque identifica a parte do Canton para a qual foi pago. Às 11:54 UTC de 2026-10-25, a lista continha seis pernas, provenientes das duas execuções daquele dia (blocos 780, 783, 784, 1465, 1471 e 1473).
* **A API** disponibiliza os mesmos dados em `/api/legs`, `/api/legs/<id>` e `/api/blocks/<number>/legs`.
* **O token encapsulado** wTKB, em `0x294d3049874526910a69f6b61da14d10a8b1b3af`, tem uma página de token como qualquer ERC-20 (10 casas decimais). Seu suprimento era de 12 wTKB no bloco 1473, e a execução da Rome verificou que o gateway mantinha 12 TKB no Canton.
* **Custódia em relação ao suprimento.** A página de um token lastreado no Canton exibe um cartão “Lastreado no Canton”: o que o gateway mantém no Canton, ao lado do suprimento encapsulado, consultados no mesmo bloco, e `GET /api/tokens/<address>` contém os mesmos valores em um objeto `canton` . Apenas o total é exibido, nunca uma posição individual. A consulta de custódia está disponível na DevNet desde as 12:27 UTC de 2026-10-25. Às 12:52 UTC daquele dia, a custódia de wTKB era de 12 TKB, distribuídos em duas posições, diante de um suprimento encapsulado de 12 wTKB.

## Twins e ativos do Canton

O explorador exibe os ativos bidirecionais do Canton (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)). Acesse [`/twins`](https://ostia.devnet.romeprotocol.xyz/twins). A página contém:

* **O registro.** Os cofres registrados no registro da blockchain, com o hash do código de cada cofre, e os twins vinculados a eles, com suas casas decimais.
* **Um cartão para cada twin.** O suprimento no Canton, ao lado do que o cofre mantém, consultados no mesmo bloco, com a indicação do bloco até o qual os valores foram contabilizados e o número de bloqueios e resgates. Os valores coincidem após cada bloqueio e resgate.
* **Custódia em relação ao suprimento** para os tokens do Canton, como wTKB e CC: o que o gateway mantém no Canton, ao lado do suprimento encapsulado.
* **Os bloqueios e resgates mais recentes.** Cada item contém links para sua perna, transação, bloco e atualização do Canton.
* **O serviço de registro.** Uma linha com um link para a verificação de integridade do serviço de registro dos twins.

O cartão de ativos do Canton em Estatísticas mostra os mesmos suprimentos em relação ao que o cofre e o gateway mantêm, e `GET /api/twins` disponibiliza a página inteira em JSON. Apenas os totais são exibidos, nunca uma posição individual.

## Chamadas externas

Abrir **Chamadas externas** no cabeçalho, em [`/canton`](https://ostia.devnet.romeprotocol.xyz/canton). A Ostia confirma cada bloco como uma transação do Canton. A chamada externa do participante que confirma verifica a prova do bloco; na DevNet, esse participante é o da Rome. Esta página mostra como cada uma dessas confirmações ocorreu.

**O cabeçalho** apresenta os números de todos os blocos:

* blocos confirmados;
* a taxa de sucesso, que corresponde às confirmações concluídas em relação às tentativas realizadas: 99,99% em todos os blocos até 2026-11-09;
* o tempo de liquidação, como média e p95, nas últimas 24 horas ou nos últimos 7 dias (em 2026-11-09, nas últimas 24 horas, cerca de 9,1 s e 10,7 s);
* as confirmações recusadas pelo Canton e os blocos confirmados após uma nova tentativa;
* as legs liquidadas, por tipo.

**A lista** tem uma linha por bloco. Cada linha mostra:

* a atualização do Canton e o bloco EVM que ela contém, além da quantidade de transações EVM liquidadas;
* o status: confirmado na primeira tentativa ou após mais tentativas, com a quantidade de recusas do Canton;
* a escolha, `Advance` no contrato `ZkChain` da cadeia;
* as legs liquidadas pelo bloco, por tipo;
* o tempo de liquidação, desde o início da prova do bloco até o horário do registro no Canton, e o horário do registro.

Exiba todos os blocos ou apenas os confirmados na primeira tentativa, os que passaram por novas tentativas, os que o Canton recusou pelo menos uma vez ou os que liquidaram legs. Ordene a lista dos mais recentes para os mais antigos ou na ordem inversa. **CSV** baixa as primeiras 1.000 linhas da visualização aberta, na ordem exibida, e `GET /api/canton/updates?format=csv&filter=<all|first|retried|refused|legs>&order=<desc|asc>` fornece o mesmo arquivo.

**Uma atualização** abre uma página com uma linha do tempo (bloco criado, prova iniciada, prova concluída, enviada ao Canton, confirmada no Canton), todas as tentativas de confirmação até a que foi bem-sucedida, a verificação da prova e as legs liquidadas pelo bloco. A comparação feita pelo próprio explorador entre a prova e os valores fixados aparece ao lado da verificação. Os dados vêm do registro do Canton e do log do próprio criador (a página identifica esses dados como "log do produtor"); se o log não contiver um bloco, a página mostra o que consta no Canton e omite o restante.

Os principais números estão na página **Estatísticas** , em um cartão de Chamadas externas, e `GET /api/canton/stats` os fornece como JSON.

## Verifique a prova no navegador

Ler os valores da prova não é o mesmo que verificá-la. Ao clicar em Verificar, o navegador baixa uma versão WebAssembly da função `verify` do sidecar e a executa com a prova, o cabeçalho e as transações registradas.

A verificação valida a prova PLONK usando a chave do programa fixada e a versão do ZisK. Ela confere se o hash do cabeçalho corresponde ao hash comprovado do bloco e se as transações correspondem à raiz de transações do cabeçalho. O painel também exige que o hash do bloco corresponda ao hash do bloco no reth.

Os valores fixados esperados vêm da resposta de status do explorador. A verificação executa a checagem de bloco do sidecar; ela não executa a verificação separada de `legs` . O botão fica desativado enquanto a prova do bloco está sendo gerada. Após a verificação, o painel mostra o resultado, a duração e o tamanho do módulo baixado. A duração não inclui o download. Consulte o [README do verificador para navegador](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/explorer/verify/README.md).

## Use o faucet de tROME

O faucet fornece 1 tROME por solicitação, para qualquer pessoa. tROME é a moeda de teste da Ostia DevNet e não tem valor. Abra a página do Faucet ou envie `POST /api/faucet`. Os limites são:

* uma solicitação por endereço a cada 24 horas;
* uma solicitação por endereço IP a cada 10 minutos;
* 5.000 pagamentos por hora, somando todos os clientes.

A solicitação entra na fila imediatamente e recebe um ticket. O faucet processa a fila em lotes de até 100, e seu pagamento chega assim que o bloco correspondente for finalizado. `GET /api/faucet/ticket/<id>` informa em que ponto está sua solicitação. Os limites são armazenados no banco de dados, então uma reinicialização não os redefine. Leia a seção [do faucet](https://github.com/rome-protocol/canton-zk-evm/blob/main/explorer/README.md#the-faucet) para ver os detalhes.

**A concessão para desenvolvedores.** Quem desenvolve e entra com o GitHub recebe 100 tROME em vez de 1. Digite seu endereço na página Faucet e escolha "Entrar com GitHub" na linha "Desenvolvendo na Ostia? Entre com o GitHub para receber 100 tROME." O GitHub redireciona você de volta à página, que acompanha sua concessão até a finalização. A conta do GitHub precisa ter pelo menos 30 dias. Cada conta do GitHub e cada endereço recebem uma concessão a cada 7 dias, e o faucet concede no máximo 200 concessões por dia no total. A página não solicita nenhuma permissão ao GitHub. [Ostia DevNet](https://docs.rome.builders/pt-br/canton-zk-evm/devnet.md#the-builder-grant) contém as etapas e os limites.

## Use as APIs

As três APIs são abertas, sem chaves. Os limites são por cliente.

| API                                               | Endereço   | Limite                                           |
| ------------------------------------------------- | ---------- | ------------------------------------------------ |
| JSON-RPC, somente blocos finalizados, apenas HTTP | `/rpc`     | 300 chamadas por minuto, em lotes de até 20      |
| REST, descrita em `/api/openapi.json`             | `/api/...` | 20 solicitações por segundo, com picos de até 60 |
| Compatível com Etherscan                          | `/api`     | 10 solicitações por segundo e 600 por minuto     |

O RPC não oferece WebSocket nem filtros, então consulte periodicamente `eth_getLogs`. `GET /api/stream` é o fluxo ao vivo usado pelas páginas. `GET /api/status` informa a cadeia, a chave fixa do programa e o estado de cada componente.

Para verificar o código-fonte de um contrato, use `forge verify-contract` com o verificador Etherscan:

```sh
forge verify-contract <address> src/Counter.sol:Counter \
  --chain-id 770101 \
  --evm-version london \
  --verifier etherscan \
  --verifier-url https://ostia.devnet.romeprotocol.xyz/api \
  --etherscan-api-key any
```

Use a mesma versão do compilador, as mesmas configurações do otimizador e a mesma versão da EVM usadas na implantação. Você pode enviar 30 verificações por hora. Um contrato com muitos arquivos-fonte pode receber um erro HTTP 413 do forge, porque o forge envia a entrada codificada como URL e o proxy frontal do explorador aceita cerca de 300 KB por solicitação. Consulte [Verificar um contrato grande](https://docs.rome.builders/pt-br/canton-zk-evm/build-on-ostia.md#verify-a-large-contract). [Desenvolver na Ostia](https://docs.rome.builders/pt-br/canton-zk-evm/build-on-ostia.md) explica como fazer implantações; os [limites de taxa](https://github.com/rome-protocol/canton-zk-evm/blob/main/explorer/README.md#rate-limits) estão no README do explorador.

## O que a parte observadora pode ver

O explorador lê o Canton como uma parte observadora, usando um token somente de leitura. Essa parte observa o registro do bloco e nada mais no pacote Daml da Ostia. Ela vê o número, o hash, o hash do bloco pai, o cabeçalho, as transações e a prova de cada registro, além do ID da atualização, do horário do registro e dos dois signatários. Ela não pode ver solicitações de depósito, aceitações de saque nem condições de pagamento; por isso, nada disso aparece no explorador.

Os ativos mantidos pelo gateway são obtidos de um segundo cliente somente de leitura, que lê como a parte do gateway. Ele mostra os totais: o cartão "Garantido no Canton", a página `/twins` , o cartão de ativos do Canton em Estatísticas e `GET /api/twins`. Ele também lê as negociações na plataforma e as reivindicações financiadas por trás de `/swaps` e `GET /api/swaps`, mantendo o pagamento, a reivindicação e as respectivas atualizações no Canton, e removendo as partes do Canton do local e do vendedor.

O limite de acesso do leitor é o do próprio explorador. O operador do participante que hospeda as partes da Ostia ainda consegue ver tudo nesse participante. Na DevNet, esse operador é a Rome, que executa o participante como seu próprio validador do Canton DevNet. [Modelo de confiança e limitações](https://docs.rome.builders/pt-br/canton-zk-evm/trust-model.md) explica o que isso significa. O Verify executa a verificação do sidecar no seu navegador, usando dados fornecidos por este explorador.

Para executar seu próprio explorador com seu banco de dados, consulte [Execute sua própria Ostia](https://docs.rome.builders/pt-br/canton-zk-evm/run-it-locally.md).


---

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