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

# Trust model and limits

The checks, authorities, custody assumptions and limits of Ostia on Canton Network DevNet.

Ostia is an early release on Canton Network DevNet. Rome runs every Ostia service: the one builder, the prover, the public RPC, the explorer, the faucet, the twin registry service and the participant that hosts every Ostia party (Rome's own DevNet validator). Canton Network DevNet's synchronizer, which orders the blocks, is run by the network, not by Rome. Rome's one sidecar is the only confirmer. This page sets out who checks what and who holds what. Do not use Ostia for anything of value.

**Who you trust today.** Rome runs the prover and the only confirming participant. Rome's participant holds the Canton Coin custody and the twin admin. The code and ZisK (alpha) are unaudited. This is DevNet only.

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 [design](https://github.com/rome-protocol/canton-zk-evm/blob/main/docs/DESIGN.md) and [security policy](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/SECURITY.md).

## Local demo vs Ostia DevNet

The 2026-10-05 demo ran on a local Canton network. The checks are the same code on both. The trust setup is not.

|                                    | Local demo network                                                 | Ostia DevNet                                                                                                                                                                                                                                                                                                                                                                                                        |
| ---------------------------------- | ------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Participants                       | Three: operator, confirmer and users.                              | One participant, Rome's, hosts every Ostia party. A second participant of Rome's hosts none yet.                                                                                                                                                                                                                                                                                                                    |
| Confirmers                         | 2, each with its own sidecar.                                      | 1, the sidecar beside that participant.                                                                                                                                                                                                                                                                                                                                                                             |
| Persistence                        | Loses its state when restarted, unless started in persistent mode. | The chain persists on the participant. DevNet may still be reset.                                                                                                                                                                                                                                                                                                                                                   |
| Ledger API access                  | No authentication, on one machine.                                 | Each Ostia Ledger API user needs a short-lived token.                                                                                                                                                                                                                                                                                                                                                               |
| Who operates what                  | Whoever starts it runs every party, on one machine.                | Rome runs every Ostia service: the participant that hosts the parties, the builder, prover, RPC, explorer, faucet and twin registry. The network runs the synchronizer.                                                                                                                                                                                                                                             |
| Canton                             | Canton 3.6.3 at `v0.1.0`; the 2026-10-05 runs used 3.6 snapshots.  | Rome's validator runs Splice 0.10.1 with Canton 3.7.2 (since 2026-11-07). DevNet's synchronizer is at protocol version 37 (since 2026-11-18). Daml SDK 3.6.0, damlc 3.6.2.                                                                                                                                                                                                                                          |
| Deposits, withdrawals and payments | Shown in the 2026-10-05 demo.                                      | Live since 2026-10-25 with the test token TKB. Rome runs the test parties and every step.                                                                                                                                                                                                                                                                                                                           |
| Twins and Canton Coin              | Not in release `v0.1.0`.                                           | Live since 2026-10-29: ERC-20 twins through the vault, and Canton Coin in and out. From 2026-11-08 to 2026-11-17 the Bridge page could open a Canton account from a wallet signature; that account is retired (see [the Bridge account made from a wallet signature](#the-bridge-account-made-from-a-wallet-signature)). The Bridge page connects the Canton wallet you already have, switched on wallet by wallet. |

The [network README](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/network/README.md#running-on-an-existing-participant-the-canton-network) calls one confirmer weaker than the local network and fine for DevNet.

## Who checks what

| Part             | Check or authority                                                                                                                                                   |
| ---------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Guest            | Validates the EVM block and rejects a chain configuration other than Ostia's compiled rules.                                                                         |
| Sidecar `verify` | Checks the proof, pinned programVK and rootC, proven block hash, header and transaction list.                                                                        |
| Sidecar `legs`   | Checks the gateway's account and storage proofs and compares the ordered attached legs with the proven gateway hash.                                                 |
| Daml `Advance`   | Checks the sidecar's answers, parent, next block number, gas cap and the contracts used by the legs. It settles the legs and creates the next head and block record. |
| Canton           | Orders blocks through the consumption of the chain's one state contract and commits the transaction's changes together. It rejects differing external-call answers.  |
| Builder          | Selects transactions, checks the Canton contracts it can see, obtains a proof and submits the block. It cannot finalize a block itself.                              |

One sidecar runs beside each confirming participant. On DevNet there is one, beside the participant that hosts every Ostia party, which is Rome's. So the proof is checked by Rome's own node today. Canton's synchronizer orders the blocks and relays the messages; it does not see the proof. Each sidecar computes its answers solely from the input sent in the external call. Daml compares their answers; it does not perform the cryptographic proof check itself. The [sidecar README](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/sidecar/README.md) and [Daml README](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/daml/README.md) give the checks and authority requirements.

## What the proof fixes

The pinned program key identifies the guest and its chain rules. The proof commits to a block hash. Checking its header binds the state root and transaction root. Account and storage proofs then bind the gateway's recorded leg hash to that state root.

The attached legs must have the same fields and order as those the gateway recorded. Removing a leg, adding one or changing a recipient, amount, token or id fails the hash comparison. A block with no legs must prove that absence too. The leg comparison also relies on Keccak-256's collision resistance.

The chain record's genesis state root fixes the gateway code. The gateway contract has no owner, admin key, upgrade or pause. The Canton party still has custody authority over the tokens it holds.

## Operator, confirmer and gateway authority

The operator and gateway propose the chain's genesis, pins, gas cap and builder. The confirmer accepts the proposal. It is expected to compare the pins and genesis gateway code with its own build. The supplied scripts propose matching values and immediately accept the proposal on the confirmer's behalf.

The operator, confirmer and gateway sign `ZkChain`. They are the chain's root of trust. Deposit and withdrawal settlement choices require all three, and payment settlement requires the operator and confirmer. `Advance` provides their joint authority. The builder alone cannot exercise the settlement choices.

On DevNet Rome runs the one participant that hosts all of these parties. Rome, as its operator, can see every Ostia contract and holds what it takes to act as every Ostia party, the confirmer and the gateway included. The Canton accounts that the retired Bridge account made are hosted there too (see [the Bridge account made from a wallet signature](#the-bridge-account-made-from-a-wallet-signature)).

**Custody.** The gateway party holds the Canton tokens that back wrapped tokens on the EVM. It is hosted on the operator's participant. Whoever runs that participant, which on DevNet is Rome, can move the locked tokens outside the withdrawal rules. The gateway contract's lack of an admin key does not constrain that Canton party's ability to act through its participant. On DevNet the gateway holds test tokens only: Rome's run of 2026-10-25 checked that it held 12 TKB, the reference test token that Splice ships, against a wTKB supply of 12, which anyone can read on Ostia. The ERC-20 tokens that back the twins sit in the vault, an EVM contract with no owner, which [the twins' section](#what-the-twins-trust) describes.

Token registration is another trust decision. The operator and gateway propose the mapping from a Canton instrument to an EVM wrapped token, and the confirmer accepts it. The gateway executes the registered token's Daml transfer code with its own authority, so registering a token also means trusting its registry's Daml code.

Tokens sent directly to the gateway's EVM address cannot be recovered. If a token charges a transfer fee or otherwise transfers a different amount, the payment leg still records the requested amount. The [network README](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/network/README.md#the-canton-network) describes the participant hosting and registration checks.

## What the twins trust

A twin is the Canton form of an ERC-20 that the vault holds (see [Deposits, withdrawals and payments](https://docs.rome.builders/canton-zk-evm/deposits-withdrawals-payments.md#canton-twins-of-erc-20-tokens)). These are the points it rests on:

* **The chain mints and burns through `Advance`.** Under the chain's rules a twin is minted inside `Advance`, against a lock line that the proof fixed: a proven payment into a vault that the chain record registers. `Advance` burns a twin only against a redeem request that its holder signed. The chain record pins each twin's token address, decimals and rules contract, and a lock for another token is refused.
* **The vault has no owner.** It has no key, no upgrade and no storage, and it cannot be made to pay an id that another kind of payment could have. Anyone can compare its on-chain code with the reviewed build.
* **A vault is registered by people.** The operator and the gateway propose it, and the confirmer accepts it once it has read the deployed code. What the contract does is guarded by that reading.
* **The twin's admin is the gateway party.** The admin alone controls the twin's `Mint` and `Burn`, so the gateway party can also mint or burn a twin outside `Advance`, with no lock and no redeem request. The gateway party is hosted on Rome's participant, so on DevNet Rome can act for it, as it can for every Ostia party it runs. It signs every twin holding, so it can burn, mint and move the twins any Canton party holds, including those of a Canton wallet connected to the [Bridge](https://docs.rome.builders/canton-zk-evm/bridge.md), without that party's signature. Before mainnet the operator and the confirmer are to sign mint and burn as well. The explorer shows each twin's supply against what the vault holds, so anyone can see whether they match.
* **The registry service is a hint.** It tells a payer the lock id and the vault, and it holds no key. The builder and `Advance` check that the parts give the id; the payer checks the id itself (the SHA-256 of `lock,<receiver>,<ref>`) and takes the vault address from a source it trusts. The chain record that names the registered vaults is readable only by Rome's parties, so on DevNet that source is Rome's.

## The Bridge account made from a wallet signature

Retired on 2026-11-17. From 2026-11-08 to 2026-11-17 the [Bridge](https://docs.rome.builders/canton-zk-evm/bridge.md) page could open a Canton account from one wallet signature: the page turned the signature into an Ed25519 key, and that key was the account's only signing key. The account service that helped to open those accounts was stopped, and the page no longer offers the sign-in, makes the key or keeps one in the browser (it deletes what an earlier visit kept). Connecting your own Canton wallet takes its place, switched on wallet by wallet; see [Build with Canton](https://docs.rome.builders/canton-zk-evm/build-with-canton.md#erc-20-twins-on-canton) for what it waits on, and [Bridge](https://docs.rome.builders/canton-zk-evm/bridge.md).

The accounts that were opened stay on Canton DevNet, hosted on Rome's participant, with what they hold, until DevNet is reset. Nothing accepts their key any more, so nobody, Rome included, signs or submits for them. They held DevNet test value only.

What the account was, for the record:

* **The key came from the signature alone.** EIP-712 binds a signature to the typed data, not to the site that asks, so anyone who got the signature could make the key. A wallet that stopped making the same signature could not reopen the account. There was no revocation and no recovery.
* **Rome could not sign for it, but Rome ran what it rested on.** Rome ran the code the account's contracts used, the only node that hosted the account and the twin admin, so Rome could burn, mint and move the twins an account held without its holder's signature. The account's standing withdrawal acceptance let choices that Rome's parties run act for it when a withdrawal arrived.

The twin admin and the withdrawal acceptance are not the Bridge account's alone: the gateway party signs every twin holding, and a Canton wallet that opts in signs the same two acceptances. See [What the twins trust](#what-the-twins-trust).

## What can stop a block

To include a leg, the builder needs read access to its requests, terms, acceptances, allocations, token registrations and gateway holdings. It leaves out a transaction whose Canton contracts it cannot see.

An allocation can be taken back after the builder checks it or after proving. A token registry can also refuse settlement under its own rules. Canton then refuses the block and nothing commits.

The builder runs continuously and cuts a block whenever includable transactions wait. The code's default is one block in flight, and DevNet runs up to two. For a refusal it could not predict, such as a registry's own rule, it suspects a transaction after two refused blocks in a row and leaves it out for a cool-down, 10 minutes by default. It tries the transaction again when the cool-down ends. A restart makes it forget what it has left out.

The builder does not cap execution steps before proving, and a prover that never returns stops it. The [builder README](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/builder/README.md#not-here) lists its limits.

## What this release does not provide

* **Decentralisation.** There is one builder, one prover and one confirmer, and Rome runs the builder, prover, RPC, explorer, faucet and the participant that hosts every party.
* **Censorship resistance or forced inclusion.** The RPC and the builder can refuse or omit a transaction, and a transaction has no other path onto the chain. The RPC and the explorer are Rome-run views of the chain. The explorer's indexer checks every record against reth, but they are not trustless.
* **Privacy.** Every EVM transaction is public, and Rome, as the participant's operator, sees every Ostia contract. The 2026-10-24 load made private-transfer proofs in the client and verified them on-chain, but no MPC network runs and nothing is settled.
* **Value or audits.** tROME has no value. The code and ZisK 1.4.0-alpha have not been audited.
* **Permanence.** DevNet may be reset, and the chain's history with it.

There are no throughput or block-time targets. The exact versions and hashes are in [PINS](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/PINS).

The reader can re-check block proofs, but `BlockRecord` does not carry the settled legs. The browser's Verify button checks the proof, header and transactions; it does not repeat the Canton leg settlement checks. [What is proven and what is not](https://docs.rome.builders/canton-zk-evm/what-is-proven.md) sets out what a proof tells you, and [Status and roadmap](https://docs.rome.builders/canton-zk-evm/status.md) says what comes next.

## Report a security problem

Use GitHub's private vulnerability reporting for `canton-zk-evm`: open the repository's Security tab and choose **Report a vulnerability**. Do not open a public issue for a security problem.

Include the affected component, commit, steps to reproduce and observed result. Attach the proof or block if it is part of the finding. The [security policy](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/SECURITY.md) defines the scope. There is no bug bounty.


---

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