For the complete documentation index, see llms.txt. This page is also available as Markdown.

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, the account 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.

This page describes release v0.1.0 and, where it says so, what DevNet runs now. Status names the commit DevNet runs. Read the full design and security policy.

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, twin registry and account service. 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 36. 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. Since 2026-11-08 the Bridge page lets anyone open a Canton account that only their own key controls; Rome's validator hosts it and cannot move its holdings. Since 2026-11-09 that key is kept in the browser between visits (see the key in your browser).

The network README 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. 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 and Daml README 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. A Canton account opened on the Bridge page is hosted there too, but only its holder's key signs for it.

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 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 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). 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 cannot act for a Canton account opened on the Bridge page: only the holder's key signs for one. 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 Canton account key in your browser

A Canton account opened on the Bridge page has a key that your wallet's signature makes. Since 2026-11-09 the page keeps that key in your browser between visits, so a reload does not ask your wallet to sign again. The key is stored so that it cannot be read out: no code, the page's own included, can copy its bytes or take it to another browser. A script that runs on the page can still use it, though. While the key is kept, such a script can sign with it whether or not your wallet is connected. The page allows only its own scripts, and it decodes and checks every transaction it signs. Pressing Close my Canton account on this browser removes the key, and so does clearing the site's data. Rome serves the page, so the page's code is part of what you trust here, as it was when the page held the key only during a sign-in.

The Bridge account made from a wallet signature

The Bridge page lets you open a Canton account with a wallet signature alone. This is the account's trust model, and it has two limits you should know before you use it. Both come from how the key is made.

How the key is made. The page asks your wallet to sign one fixed EIP-712 message. Its EIP-712 domain names "Ostia bridge", version 1 and the Ostia chain id. Its message is a short fixed statement. The page turns that signature into an Ed25519 key. That key controls your Canton account (a Canton party). Its fingerprint is the party's namespace, and it is the party's only signing key, with a signing threshold of 1. If your wallet makes the same signature again, you get the same key. That is how the page finds your account on any browser. See Risk 2 for when it may not.

Risk 1: anyone who gets the signature gets the account. EIP-712 binds a signature to the typed data, not to the site that asks for it. Another site can ask your wallet to sign the identical typed data. Nothing in the signed data names the site that asks. Your wallet signs the same digest for any site and, if it signs deterministically, gives the same signature. The key is made from the signature alone, by public code, so whoever holds the signature can make the key and sign for your account. Sign this message only on the Bridge's own site, ostia.devnet.romeprotocol.xyz, and never send the signature to anyone. If your wallet shows the site that asks, check that it is ostia.devnet.romeprotocol.xyz; not every wallet shows it.

Risk 2: your wallet may not make the same signature again. The same typed data always gives the same signing digest. The same signature bytes are not certain. They depend on how the wallet signs. A wallet that uses deterministic nonces (RFC 6979) gives the same bytes every time. A wallet that does not gives different bytes, and so a different key. The page checks this once, the first time you open an account: it asks your wallet to sign twice and compares the results. That shows only that this wallet gave the same signature at that moment. It does not promise that it will tomorrow. A different wallet, a wallet update, a hardware wallet may sign differently, and a smart-contract wallet cannot open an account at all (see Tested wallets below). If your wallet stops making the same signature, the page gets a different key. That key belongs to a different, new account, not yours. The page cannot reopen the one you had.

Tested wallets. We test browser-extension wallets with a throwaway key: each signs the Bridge's message twice, and again after the browser restarts, and we compare the signatures with a reference signature that standard signing software makes from the same key, and with each other. Results from 2026-11-10:

Wallet
Version
Same signature on every try, also after a restart
Same as the other wallets
Opens the same account on the live Bridge

MetaMask

13.56.0

yes

yes

yes

Rabby

0.94.15

yes

yes

yes

OKX Wallet

4.23.0

yes

yes

not tried

Coinbase Wallet

3.151.0

not tested yet

not tested yet

not tried

Phantom (EVM)

26.38.1

not tested yet

not tested yet

not tried

A "yes" holds for that version only; a wallet update can change it. Coinbase Wallet and Phantom could not be driven by the test yet, so they have no result. Hardware wallets (Ledger, Trezor) are not tested. Smart-contract wallets (Safe and others) cannot open a Bridge account: the page checks that the signature comes from the connected address. The full results, with each package's source and SHA-256, and the steps to run the test again are in the repository: results and how to run it.

What follows: no revocation and no recovery today. The derived key's fingerprint is the party's namespace, and the key is its only signing key. So:

  • If the signature leaks, there is no way to take the account back. The namespace is the key's own fingerprint, and the page has no way to move the account to another key. Revoking the namespace needs that same key, and whoever holds the leaked signature holds it too.

  • If your wallet stops making the signature, the account cannot be reopened and the page has no way to move it to another key. Nobody holds another key for it. While the page still keeps your key in your browser (see the key in your browser), it keeps working there. Clearing the site's data removes it.

  • Rome cannot step in. Rome's validator hosts the account but cannot sign for it.

Where this stands. Use this account with DevNet test tokens only, which have no value. It is a Bridge-only option. It will not go beyond DevNet in this form. People who already have a Canton wallet will be able to connect it to the Bridge instead. That is coming.

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 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.3.2-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.

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 sets out what a proof tells you, and Status and roadmap 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 defines the scope. There is no bug bounty.

Last updated

Was this helpful?