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

# Explorer

A guide to the live Ostia DevNet explorer, its faucet, its APIs and the proof check in the browser.

The Ostia explorer is live at [ostia.devnet.romeprotocol.xyz](https://ostia.devnet.romeprotocol.xyz). It combines reth's EVM data with the Canton records of each block, which it reads as the reader party. Use it to find a block or transaction, check a proof in your browser, verify a contract, get tROME and read the same data through an API.

This page describes release `v0.1.0` and, where it says so, what DevNet runs now. [Status](https://docs.rome.builders/canton-zk-evm/status.md) names the commit DevNet runs. Read the full [explorer README](https://github.com/rome-protocol/canton-zk-evm/blob/main/explorer/README.md).

The explorer marks a block final only when its record is on Canton. Until then it shows the block from reth as being proven, and a transaction you just sent shows as pending. When no transactions wait, the builder makes an empty block once a minute, so the newest block on a quiet chain is not much older than a couple of minutes. Times on every page are UTC.

## Tour of the pages

| Page           | What you can do there                                                                                                                                                                                                                                                                                                                   |
| -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Home           | Search by block, transaction, address or Canton update id. See the newest final block, the block being proven, time to final, proof time and the latest blocks. A status strip shows whether the EVM node, Canton, the producer, the prover, the faucet and the verifier are healthy. The Canton commit time tile opens External calls. |
| Blocks         | List final blocks, filter to blocks with transactions, download a CSV, open one block.                                                                                                                                                                                                                                                  |
| Transactions   | List transactions and filter to not final yet, failed or contract calls. A transaction shows its result, block, Canton update, fee, decoded input and a timeline of its four finality stages.                                                                                                                                           |
| Contracts      | See which contracts are verified and how often they are used. A contract page shows its verified source, ABI, events, and Read and Write calls. Write calls go through your wallet.                                                                                                                                                     |
| Tokens         | Browse ERC-20, ERC-721 and ERC-1155 tokens, with holders and transfers. A tab lists tokens that come from Canton, such as wTKB and CC.                                                                                                                                                                                                  |
| External calls | See how every block committed on Canton, one row per block, with its status, settlement time and attempts. The header link "External calls" opens it. See [External calls](#external-calls).                                                                                                                                            |
| Stats          | See time to final, proof time, Canton commit time, transactions per second and success rate over 1 hour, 6 hours, 24 hours, 7 days or 30 days. A Canton assets card shows each supply against what the vault and the gateway hold. An External calls card shows how the commits to Canton are doing.                                    |
| Twins          | See the two-way Canton assets at [`/twins`](https://ostia.devnet.romeprotocol.xyz/twins): each twin's supply against the vault's balance, and the latest locks and redeems.                                                                                                                                                             |
| Swaps          | See the swaps that a Canton venue made with the EVM, at [`/swaps`](https://ostia.devnet.romeprotocol.xyz/swaps), and open one swap with its payment and its claim.                                                                                                                                                                      |
| Bridge         | Connect your wallet, get test tROME, and move tokens between Ostia and Canton with the Canton wallet you already have (switched on wallet by wallet; until then its button reads "Coming soon"). See [Bridge](https://docs.rome.builders/canton-zk-evm/bridge.md).                                                                      |
| Faucet         | Request tROME, or sign in with GitHub for the 100 tROME builder grant, and follow your request to final.                                                                                                                                                                                                                                |
| API            | Read the API reference drawn from the OpenAPI document. A button adds Ostia DevNet to your wallet.                                                                                                                                                                                                                                      |

The header has a search box on every page but Home, which has its own; the `/` key focuses it. Blocks, Transactions, an address's transactions and transfers, and a token's transfers download as CSV. The pages follow a live stream, so new blocks appear without a reload. Address and gateway-leg pages open from links, and addresses also open from search; the header has no entry for them.

## Read a block

The block page shows its EVM data beside its Canton side: the update id, the record time, and the operator and confirmer that signed the record. It compares reth's block hash, the record's hash and the hash of the recorded header, and shows whether the three agree. It also displays the program key, ZisK release and block hash read from the proof beside the explorer's expected values. A value that does not match shows in red.

Four tiles give the block in numbers: transactions, proof time, Canton commit (the time from submitting the block to Canton's record time for it) and the time from the block's cut to final. The Home and Stats cards for Canton commit run from the same submit to the builder receiving Canton's answer, so they read higher than this tile. A panel, "How this block became final", lists the steps with their times.

A block being proven is not yet on Canton. The page says so and refreshes until the block is final. A transaction may be waiting, being proven or final. The block page lists the gateway's legs as the EVM recorded them. `BlockRecord` does not carry how each leg settled on Canton, so the explorer cannot show that. See [Legs and custody](#legs-and-custody) for the legs that are live on DevNet.

## Legs and custody

The gateway's legs are live on DevNet, run by Rome with test parties (see [Deposits, withdrawals and payments](https://docs.rome.builders/canton-zk-evm/deposits-withdrawals-payments.md)), so these pages now have content. The header has no entry for them yet; open [`/legs`](https://ostia.devnet.romeprotocol.xyz/legs) directly, or follow a leg from its block.

* **The list** at `/legs` shows every leg with its kind (deposit, payment or withdrawal), block, token, account and amount. Open one for its own page at `/leg/<id>`. A withdrawal names the Canton party it paid. At 11:54 UTC on 2026-10-25 the list held six legs, from the two runs of that day (blocks 780, 783, 784, 1465, 1471 and 1473).
* **The API** serves the same data at `/api/legs`, `/api/legs/<id>` and `/api/blocks/<number>/legs`.
* **The wrapped token** wTKB, at `0x294d3049874526910a69f6b61da14d10a8b1b3af`, has a token page like any ERC-20 (10 decimals). Its supply was 12 wTKB at block 1473, and Rome's run checked that the gateway held 12 TKB on Canton.
* **Custody against supply.** A Canton-backed token's page shows a "Backed on Canton" card: what the gateway holds on Canton next to the wrapped supply, read at the same block, and `GET /api/tokens/<address>` carries the same figures in a `canton` object. Only the total is shown, never an individual holding. The custody read has been on DevNet since 12:27 UTC on 2026-10-25. At 12:52 UTC that day wTKB read a custody of 12 TKB, held in two holdings, against a wrapped supply of 12 wTKB.

## Twins and Canton assets

The explorer shows the two-way Canton assets (see [Deposits, withdrawals and payments](https://docs.rome.builders/canton-zk-evm/deposits-withdrawals-payments.md#canton-twins-of-erc-20-tokens)). Open [`/twins`](https://ostia.devnet.romeprotocol.xyz/twins). It has:

* **The registry.** The vaults that the chain record registers, with each vault's code hash, and the twins it pins, with their decimals.
* **A card for each twin.** Its supply on Canton next to what the vault holds, read at the same block, with the block they are counted to and the number of locks and redeems. The two match after each lock and redeem.
* **Custody against supply** for the Canton tokens, such as wTKB and CC: what the gateway holds on Canton next to the wrapped supply.
* **The latest locks and redeems.** Each links to its leg, transaction, block and Canton update.
* **The registry service.** A line with a link to the twin registry service's health check.

The Canton assets card on Stats shows the same supplies against what the vault and the gateway hold, and `GET /api/twins` serves the whole page as JSON. Only totals are shown, never an individual holding.

## External calls

Open **External calls** in the header, at [`/canton`](https://ostia.devnet.romeprotocol.xyz/canton). Ostia commits each block as one Canton transaction. The confirming participant's external call checks the block's proof inside it; on DevNet that participant is Rome's. This page shows how each of those commits went.

**The header** gives the figures over every block:

* blocks committed;
* the success rate, which is the commits that got through over the attempts made, 99.99% over all blocks as of 2026-11-09;
* the settlement time, as an average and a p95, over the last 24 hours or the last 7 days (on 2026-11-09, over 24 hours, about 9.1 s and 10.7 s);
* the commits Canton refused, and the blocks that committed after a retry;
* the legs settled, by kind.

**The list** has one row per block. Each row shows:

* the Canton update and the EVM block it carries, and how many EVM transactions it settled;
* the status: committed on the first attempt, or after more attempts, with how many Canton refused;
* the choice, `Advance` on the chain's `ZkChain` contract;
* the legs the block settled, by kind;
* the settlement time, from the start of the block's proof to Canton's record time, and the record time.

Show all blocks, or only those committed on the first attempt, those retried, those that Canton refused at least once, or those that settled legs. Order the list newest or oldest first. **CSV** downloads the first 1,000 rows of the view you have open, in its order, and `GET /api/canton/updates?format=csv&filter=<all|first|retried|refused|legs>&order=<desc|asc>` gives the same file.

**One update** opens a page with a timeline (block built, proof started, proof done, submitted to Canton, committed on Canton), every commit attempt up to the one that committed, the proof check and the legs the block settled. The explorer's own comparison of the proof with the pinned values is beside the check. The facts come from the Canton record and from the builder's own log (the page tags these facts "producer log"); a block the log does not hold shows what Canton holds and leaves the rest out.

The main figures are on the **Stats** page, in an External calls card, and `GET /api/canton/stats` serves them as JSON.

## Check the proof in your browser

Reading values from the proof does not verify it. Pressing Verify downloads a WebAssembly build of the sidecar's `verify` function and runs it on the recorded proof, header and transactions.

The check verifies the PLONK proof under the pinned program key and ZisK release. It checks that the header hashes to the proven block hash and that the transactions match the header's transaction root. The panel also requires that block hash to match reth's hash for the block.

The expected pins come from the explorer's status response. Verify runs the sidecar's block check; it does not run the separate `legs` check. The button is disabled while the block is being proven. After a check, the panel shows its result, duration and the module's download size. The duration excludes the download. See the [browser verifier README](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/explorer/verify/README.md).

## Use the tROME faucet

The faucet gives 1 tROME per request, to anyone. tROME is the test coin of Ostia DevNet and has no value. Open the Faucet page, or send `POST /api/faucet`. The limits are:

* one request per address every 24 hours;
* one request per IP address every 10 minutes;
* 5,000 payouts an hour across all clients.

A request is queued at once and answered with a ticket. The faucet pays the queue in batches of up to 100, and your payout arrives once its block is final. `GET /api/faucet/ticket/<id>` says where your request is. The limits are kept in the database, so a restart does not reset them. Read the [faucet section](https://github.com/rome-protocol/canton-zk-evm/blob/main/explorer/README.md#the-faucet) for the details.

**The builder grant.** A builder who signs in with GitHub gets 100 tROME instead of 1. Type your address on the Faucet page and choose "Sign in with GitHub" in the line "Building on Ostia? Sign in with GitHub for 100 tROME." GitHub sends you back to the page, which follows your grant to final. The GitHub account must be at least 30 days old. Each GitHub account and each address gets one grant every 7 days, and the faucet gives at most 200 grants a day to everyone together. The page asks GitHub for no permissions. [Ostia DevNet](https://docs.rome.builders/canton-zk-evm/devnet.md#the-builder-grant) has the steps and the limits.

## Use the APIs

All three APIs are open, with no keys. The limits are per client.

| API                                    | Address    | Limit                                   |
| -------------------------------------- | ---------- | --------------------------------------- |
| JSON-RPC, final blocks only, HTTP only | `/rpc`     | 300 calls a minute, batches of up to 20 |
| REST, described at `/api/openapi.json` | `/api/...` | 20 requests a second, bursts of 60      |
| Etherscan-compatible                   | `/api`     | 10 requests a second and 600 a minute   |

The RPC has no WebSocket and no filters, so poll `eth_getLogs`. `GET /api/stream` is the live stream the pages use. `GET /api/status` reports the chain, the pinned program key and the health of each part.

To verify a contract's source, use `forge verify-contract` with the Etherscan verifier:

```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 the same compiler version, optimizer settings and EVM version as the deploy. You may send 30 verifications an hour. A contract with many source files can get HTTP 413 from forge, because forge sends its input url-encoded and the explorer's front proxy takes about 300 KB a request. See [Verify a large contract](https://docs.rome.builders/canton-zk-evm/build-on-ostia.md#verify-a-large-contract). [Build on Ostia](https://docs.rome.builders/canton-zk-evm/build-on-ostia.md) covers deploying; the [rate limits](https://github.com/rome-protocol/canton-zk-evm/blob/main/explorer/README.md#rate-limits) are in the explorer README.

## What the reader party can see

The explorer reads Canton as a reader party with a read-only token. That party observes the block record and nothing else in Ostia's Daml package. It sees each record's number, hash, parent hash, header, transactions and proof, the update id and record time, and the two signers. It cannot see deposit requests, withdrawal acceptances or payment terms, so none of those appear in the explorer.

The gateway's holdings come from a second, read-only client that reads as the gateway party. It shows totals: the "Backed on Canton" card, the `/twins` page, the Canton assets card on Stats and `GET /api/twins`. It also reads the venue trades and funded claims behind `/swaps` and `GET /api/swaps`, keeping the payment, the claim and their Canton updates, and dropping the venue's and the seller's Canton parties.

The reader's limit is the explorer's own. The operator of the participant that hosts the Ostia parties can still see everything there, and on DevNet that operator is Rome, which runs the participant as its own Canton DevNet validator. [Trust model and limits](https://docs.rome.builders/canton-zk-evm/trust-model.md) says what that means. Verify runs the sidecar's check in your browser on data this explorer serves.

To run your own explorer, with its database, see [Run your own Ostia](https://docs.rome.builders/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/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.
