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

# Start here

A starting point for each reader of Ostia, with the tools you use and where to look, whether you build apps, validate on Canton, run a prover, audit or run your own Ostia.

| I want to                                                     | Start here                                                                                            |
| ------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------- |
| Deploy an app                                                 | [App builders](#app-builders)                                                                         |
| See what I can build with Canton, and what has run on DevNet  | [Build with Canton](/canton-zk-evm/build-with-canton.md) and [Use cases](/canton-zk-evm/use-cases.md) |
| Get a wallet and test coin                                    | [Users](#users)                                                                                       |
| Get 100 tROME as a builder                                    | [The builder grant](/canton-zk-evm/devnet.md#the-builder-grant)                                       |
| Move tokens between Ostia and Canton with a browser wallet    | [Bridge](/canton-zk-evm/bridge.md)                                                                    |
| See how each block commits on Canton                          | [External calls](/canton-zk-evm/explorer.md#external-calls)                                           |
| Read how ERC-20 twins and Canton Coin work                    | [Two-way Canton assets](#two-way-canton-assets)                                                       |
| Run Ostia on a Canton participant, or see who confirms blocks | [Canton validators and participant operators](#canton-validators-and-participant-operators)           |
| Run a prover                                                  | [Prover operators](#prover-operators)                                                                 |
| See what the proof fixes, and what it does not                | [Trust model and limits](/canton-zk-evm/trust-model.md)                                               |
| Audit the code                                                | [Auditors and researchers](#auditors-and-researchers)                                                 |
| Run my own Ostia                                              | [Run your own Ostia](/canton-zk-evm/run-it-locally.md)                                                |

All the code is in one public repository, [rome-protocol/canton-zk-evm](https://github.com/rome-protocol/canton-zk-evm), under the Apache License 2.0. The code links on this page point at its main branch; [Status](/canton-zk-evm/status.md) names the commit DevNet runs. The apps are in [`apps/accounts`](https://github.com/rome-protocol/canton-zk-evm/tree/main/apps/accounts), [`apps/twin`](https://github.com/rome-protocol/canton-zk-evm/tree/main/apps/twin) (with its [registry service](https://github.com/rome-protocol/canton-zk-evm/tree/main/apps/twin/registry)) and [`apps/otc`](https://github.com/rome-protocol/canton-zk-evm/tree/main/apps/otc). Release [v0.1.0](https://github.com/rome-protocol/canton-zk-evm/releases/tag/v0.1.0) is the first tag, from before the apps.

## App builders

Ostia runs EVM contracts over HTTP JSON-RPC, on Canton DevNet. It is unaudited, its test coin has no value and DevNet may be reset. Rome runs the builder, the prover and the one confirming participant. Some behaviour differs from Ethereum; read [Differences from Ethereum](/canton-zk-evm/evm-differences.md) first. Contracts built for Osaka or earlier run here (`london` is a safe target), with the same deploy steps as on Ethereum. Check the [RPC limits](/canton-zk-evm/devnet.md#limits) before you connect an existing app.

**What you use**

* Foundry 1.8: `forge create` to deploy, and `forge verify-contract` against the explorer's Etherscan-compatible API.
* Hardhat 2 to deploy.
* ethers to read and send. The mixed-load kit (`load/mixed`) uses it. [Build on Ostia](/canton-zk-evm/build-on-ostia.md#viem-and-ethers) also has a viem setup.
* An EVM wallet, set up with the network values or with the button on the explorer's API page.
* OpenZeppelin contracts. ERC-20, ERC-721 and ERC-1155 tokens built on them have run on Ostia, along with an ERC-3643 (T-REX) permissioned token and Uniswap V2.
* The load kit also sent private transfers to TACEO's Merces contracts. Their Groth16 proofs were made on the client and checked on chain. No MPC network ran and nothing settled.

The viem setup and the wallet steps are written up, not tested end to end here. Other EVM tools have not been tried. The RPC has no WebSocket, no `eth_newFilter` and no `eth_subscribe`, so poll `eth_getLogs`. A receipt appears once the block is final on Canton, which takes about 10 to 30 seconds.

**Where to look**

* [Ostia DevNet](/canton-zk-evm/devnet.md): chain id, RPC, wallet values, limits, and pauses and maintenance.
* [Differences from Ethereum](/canton-zk-evm/evm-differences.md): PREVRANDAO, blob transactions, block time and the rest.
* [Build on Ostia](/canton-zk-evm/build-on-ostia.md): deploy and verify with Foundry or Hardhat, then connect with viem or ethers.
* [Explorer](/canton-zk-evm/explorer.md): the APIs, contract verification, the faucet and the External calls page.
* [The builder grant](/canton-zk-evm/devnet.md#the-builder-grant): 100 tROME for builders who sign in with GitHub.
* [Build with Canton](/canton-zk-evm/build-with-canton.md): twins, Canton Coin, payments with Canton parties and a Canton venue.
* [Use cases](/canton-zk-evm/use-cases.md): what works today, on DevNet or on a network of your own.
* [Try Ostia](https://github.com/rome-protocol/canton-zk-evm/blob/main/docs/TRY-OSTIA.md): the short version in the repository.
* [load/mixed](https://github.com/rome-protocol/canton-zk-evm/tree/main/load/mixed): the kit that deploys all of the above. It holds the scripts and our own contracts; package imports and a fetch step bring in the rest.

## Users

**What you use**

* A wallet with Ostia DevNet added.
* The faucet for test coin: 1 tROME per address a day for everyone, and 100 tROME for builders who sign in with GitHub. tROME has no value.
* The explorer to find your transaction, check its block and, on [External calls](/canton-zk-evm/explorer.md#external-calls), follow how each block commits on Canton.
* The [Bridge](/canton-zk-evm/bridge.md) page to move tokens between Ostia and Canton, and to send tokens on Canton, with a browser wallet.

**Where to look**

* [Ostia DevNet](/canton-zk-evm/devnet.md#add-it-to-a-wallet): wallet setup.
* [Get tROME](/canton-zk-evm/devnet.md#get-trome): the faucet and [the builder grant](/canton-zk-evm/devnet.md#the-builder-grant).
* [Explorer](/canton-zk-evm/explorer.md): read a block and check its proof in your browser.
* [External calls](/canton-zk-evm/explorer.md#external-calls): every block's Canton commit, with its settlement time.
* [Bridge](/canton-zk-evm/bridge.md): open a Canton account with one signature, move tokens and send them on Canton.
* [How it works](/canton-zk-evm/how-it-works.md#from-your-transaction-to-final-on-canton): what "final" means, from your transaction to a committed Canton block.

## Two-way Canton assets

Since 2026-10-29 assets move both ways. An ERC-20 on Ostia can stand on Canton as a twin: you pay it into the vault and a Canton account holds the same amount, and redeeming pays the ERC-20 back out. Canton Coin comes onto Ostia as the CC token and goes back. Since 2026-11-08 you can make these moves yourself on the explorer's [Bridge](/canton-zk-evm/bridge.md) page, with a browser wallet and one signature to open your Canton account. Get test tROME first. The explorer shows each twin's supply against what the vault holds.

**Where to look**

* [Bridge](/canton-zk-evm/bridge.md): the Bridge page, the four moves and measured times.
* [Deposits, withdrawals and payments](/canton-zk-evm/deposits-withdrawals-payments.md#canton-twins-of-erc-20-tokens): the lock and redeem flows and Canton Coin.
* [Ostia DevNet](/canton-zk-evm/devnet.md#canton-assets-on-devnet): the vault, the twins and the CC token addresses, and the twin registry service.
* [Explorer](/canton-zk-evm/explorer.md#twins-and-canton-assets): the `/twins` page.
* [Build with Canton](/canton-zk-evm/build-with-canton.md): the twin registry's calls, Canton Coin as an ERC-20, payments and the OTC venue.
* [Trust model and limits](/canton-zk-evm/trust-model.md#what-the-twins-trust): what the twins rest on.
* [Try Ostia](https://github.com/rome-protocol/canton-zk-evm/blob/main/docs/TRY-OSTIA.md#canton-twins-and-canton-coin-on-devnet): the short version in the repository.

## Canton validators and participant operators

On Ostia, Canton does not commit a block until a sidecar beside a confirming participant has checked it. On DevNet that participant is Rome's. The sidecar runs the verifier and checks the proof, the header and the transaction root. If the check fails, the block does not commit.

On DevNet, one participant, Rome's own, hosts every Ostia party. Its sidecar is the only confirmer. No other participant confirms Ostia DevNet blocks today. Rome's validator runs Splice 0.10.1 with Canton 3.7.2. [Trust model and limits](/canton-zk-evm/trust-model.md#local-demo-vs-ostia-devnet) compares this one-confirmer setup with the local network's two. Today you can run your own Ostia on a participant you already operate, in the existing-participant mode.

**What you use**

* The sidecar, which Canton calls through its external-call extension.
* The verifier it uses to check the wrapped proof.
* The Daml package that holds the chain and its blocks.
* The scripts that set Ostia up on a participant you already run.

**Where to look**

* [sidecar/](https://github.com/rome-protocol/canton-zk-evm/tree/main/sidecar): the service Canton calls.
* [verifier/](https://github.com/rome-protocol/canton-zk-evm/tree/main/verifier): the proof check, in plain Rust.
* [daml/](https://github.com/rome-protocol/canton-zk-evm/tree/main/daml): the Daml package, including `Advance`.
* [network/README.md](https://github.com/rome-protocol/canton-zk-evm/blob/main/network/README.md#running-on-an-existing-participant-the-canton-network): "Running on an existing participant".
* [network/external/](https://github.com/rome-protocol/canton-zk-evm/tree/main/network/external): the participant config, sidecar and setup scripts.
* [Run your own Ostia](/canton-zk-evm/run-it-locally.md#run-on-an-existing-participant): the same steps in these docs.
* [Trust model and limits](/canton-zk-evm/trust-model.md#operator-confirmer-and-gateway-authority): what the operator and confirmer can see and do.

## Prover operators

The prover turns each block into a proof that the confirmer's sidecar checks. You run ZisK with one GPU worker. The DevNet prover is one NVIDIA RTX PRO 6000 Blackwell Server Edition (96 GB) on a 48-vCPU machine. On DevNet Rome runs that one prover. These scripts are for running a prover for your own Ostia.

**What you use**

* `install.sh` to install the pinned ZisK release and its keys.
* `start.sh` to start the coordinator and the GPU worker.
* `prove-one.sh` to prove one input and verify the result.
* The guest, the program that is proven. Its build runs in one fixed folder, so you can check that your build gives the recorded programVK.

**Where to look**

* [prover/](https://github.com/rome-protocol/canton-zk-evm/tree/main/prover): the scripts above, plus `build-guest.sh`.
* [guest/](https://github.com/rome-protocol/canton-zk-evm/tree/main/guest): the guest and how to check that your build gives the recorded programVK.
* [Ostia prover host](/canton-zk-evm/prover-host.md): host requirements, build and run, and reproducing the guest key.
* [Measurements](/canton-zk-evm/measurements.md): proof times, and the hardware they were measured on.

## Auditors and researchers

**What you use**

* The chain rules compiled into the guest.
* The proof check and the storage-proof code.
* The Daml chain record and its `Advance` choice.
* The gateway contract.

**Where to look**

* [guest/](https://github.com/rome-protocol/canton-zk-evm/tree/main/guest): the program that is proven, and the rules it enforces.
* [verifier/](https://github.com/rome-protocol/canton-zk-evm/tree/main/verifier): the check of the wrapped proof.
* [mpt/](https://github.com/rome-protocol/canton-zk-evm/tree/main/mpt): Merkle-Patricia storage proofs.
* [daml/](https://github.com/rome-protocol/canton-zk-evm/tree/main/daml): the chain record and `Advance`.
* [gateway/](https://github.com/rome-protocol/canton-zk-evm/tree/main/gateway): the one EVM contract that tells Canton what a block needs.
* [Trust model and limits](/canton-zk-evm/trust-model.md) and [What is proven and what is not](/canton-zk-evm/what-is-proven.md): what the proof fixes and who checks what.
* [docs/DESIGN.md](https://github.com/rome-protocol/canton-zk-evm/blob/main/docs/DESIGN.md) and [SECURITY.md](https://github.com/rome-protocol/canton-zk-evm/blob/main/SECURITY.md): the design, and how to report a problem privately.

## Run your own Ostia

[Run your own Ostia](/canton-zk-evm/run-it-locally.md) covers the tests, a local Canton network with a GPU, and deploying on an existing Canton participant.


---

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