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

# Ostia DevNet

Network details for Ostia DevNet, with the chain id, RPC, explorer, APIs, wallet setup, faucet and limits.

Ostia DevNet is the public Ostia network. It runs on Canton Network DevNet and has been live since **2026-10-22**. Ordinary EVM tools work on it: wallets, Foundry, Hardhat, ethers and viem. This page has the values you need to connect. [Build on Ostia](/canton-zk-evm/build-on-ostia.md) takes you from there to a deployed, verified contract.

Since **2026-10-29** the chain also moves Canton assets both ways: ERC-20 tokens stand on Canton as twins, and Canton Coin comes onto Ostia and back. The addresses are in [Canton assets on DevNet](#canton-assets-on-devnet) below.

## Network details

| Setting                  | Value                                                                                                     |
| ------------------------ | --------------------------------------------------------------------------------------------------------- |
| Network name             | Ostia DevNet                                                                                              |
| Chain ID                 | `770101` (hex `0xbc035`)                                                                                  |
| Currency                 | tROME, 18 decimals. It has no value.                                                                      |
| RPC                      | `https://ostia.devnet.romeprotocol.xyz/rpc` (HTTP only, final blocks only)                                |
| Explorer                 | [ostia.devnet.romeprotocol.xyz](https://ostia.devnet.romeprotocol.xyz)                                    |
| Etherscan-compatible API | `https://ostia.devnet.romeprotocol.xyz/api`                                                               |
| REST API                 | `https://ostia.devnet.romeprotocol.xyz/api/...`, described by the OpenAPI document at `/api/openapi.json` |
| Status and health        | `/api/status` and `/api/health` on the explorer's address                                                 |

The gas price is about 1 gwei, and a block holds up to 60,000,000 gas. A single transaction may use at most 16,777,216 gas (2^24), the cap that the Osaka fork sets.

## Add it to a wallet

In MetaMask or another wallet, add a custom network with these values:

| Field              | Value                                       |
| ------------------ | ------------------------------------------- |
| Network name       | Ostia DevNet                                |
| New RPC URL        | `https://ostia.devnet.romeprotocol.xyz/rpc` |
| Chain ID           | `770101`                                    |
| Currency symbol    | `tROME`                                     |
| Block explorer URL | `https://ostia.devnet.romeprotocol.xyz`     |

The explorer can also do it for you. Open its [API page](https://ostia.devnet.romeprotocol.xyz/docs/api) and press the button that adds the network to your wallet.

## Get tROME

Everyone gets 1 tROME a day. Builders can get 100 tROME with the builder grant, once every 7 days. Open the [faucet](https://ostia.devnet.romeprotocol.xyz/faucet), paste your address and ask. You can also ask from a terminal:

```sh
curl -X POST https://ostia.devnet.romeprotocol.xyz/api/faucet \
  -H 'content-type: application/json' \
  -d '{"address":"0xYourAddress"}'
```

A request that is taken answers `202` with a `ticket`. Ask `GET /api/faucet/ticket/<ticket>` until its status is `final` (or `failed`). The status goes from `queued` to `sent` to `final`. Use your wallet's address in place of `0xYourAddress`. The faucet gives:

* 1 tROME per address every 24 hours;
* one request per IP address every 10 minutes;
* at most 5,000 payouts an hour to everyone together.

Payouts are sent in batches of up to 100. Yours arrives when its block is final on Canton, which takes about 10 to 30 seconds once it is sent. One tROME pays for thousands of ordinary transactions at today's gas price. The faucet's limits are in [the faucet section of the explorer README](https://github.com/rome-protocol/canton-zk-evm/blob/main/explorer/README.md#the-faucet).

### The builder grant

A builder who signs in with GitHub gets 100 tROME instead of 1. On the Faucet page, type your address and choose "Sign in with GitHub" in the line "Building on Ostia? Sign in with GitHub for 100 tROME." The Bridge page offers the same step under "Get test tROME", for the wallet you have connected, while that wallet holds no tROME yet; otherwise use the Faucet page. GitHub sends you back to the Faucet page, which follows your grant to final like any request. The page asks GitHub for no permissions and reads only your account's number and the date it was made.

* The GitHub account must be at least 30 days old.
* One grant per GitHub account and one per address every 7 days.
* At most 200 grants a day, to everyone together.

The 1 tROME a day stays for everyone, with or without a GitHub account. The faucet's `GET /api/faucet` answer shows whether the grant is on, with its amount and its limits. The rules are in [the builder grant](https://github.com/rome-protocol/canton-zk-evm/blob/main/explorer/README.md#the-builder-grant) section of the explorer README.

### Test Canton Coin

A Canton account opened on the [Bridge](/canton-zk-evm/bridge.md) page can get 20 test Canton Coin a day. Press "Get test Canton Coin" on the page. This faucet exists on DevNet only.

## Limits

The RPC at `/rpc` forwards to the chain, with these differences:

* It answers 20 methods: `eth_chainId`, `net_version`, `web3_clientVersion`, `eth_syncing`, `eth_blockNumber`, `eth_getBalance`, `eth_getCode`, `eth_getStorageAt`, `eth_getTransactionCount`, `eth_call`, `eth_estimateGas`, `eth_gasPrice`, `eth_maxPriorityFeePerGas`, `eth_feeHistory`, `eth_getBlockByNumber`, `eth_getBlockByHash`, `eth_getTransactionByHash`, `eth_getTransactionReceipt`, `eth_getLogs` and `eth_sendRawTransaction`. Any other method answers `-32601`.
* There is no WebSocket, and no `eth_newFilter` or `eth_subscribe`. To follow events, poll `eth_getLogs`.
* It shows only blocks that are final on Canton. `latest`, `safe`, `pending` and `finalized` all mean the newest final block (except `eth_getTransactionCount` with `pending`, which counts waiting transactions so that your wallet picks the next nonce). A receipt appears once its block is final, which takes about 10 to 30 seconds.
* Each client may make 300 calls a minute. A batch counts every call in it and holds at most 20 calls. A request body is at most 256 KiB.
* A transaction whose nonce is ahead of the account's next one is refused as a nonce gap. Send the missing ones first.
* A transaction whose max fee per gas is below the current base fee is refused. Wallets and tools set this on their own.

The explorer's APIs have their own limits, per client and with no keys:

| Surface                           | Limit                                                                                                                                       |
| --------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
| REST API (`/api/...`)             | 20 requests a second, bursts of 60. A client over the limit gets `429` with `Retry-After`.                                                  |
| Etherscan-compatible API (`/api`) | 10 requests a second and 600 a minute. A client over the limit gets `Max rate limit reached`, as Etherscan answers.                         |
| Contract verification             | 30 an hour. A request larger than about 300 KB gets `413` (see [Build on Ostia](/canton-zk-evm/build-on-ostia.md#verify-a-large-contract)). |

The [explorer README](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/explorer/README.md#the-public-rpc) describes the RPC rules in full.

## A quiet chain makes a block a minute

Ostia makes a block as soon as transactions are waiting. When no block has been made for 60 seconds, it makes an empty block, a heartbeat. On an idle chain the builder starts that block 60 seconds after it recorded the previous commit, and proving and settling it add to that, so a healthy quiet chain is not more than a couple of minutes without a new block. If something fails, the next block can be late. Before the morning of 2026-10-25 there was no heartbeat, and an idle chain could go hours without one. On quiet stretches between 07:53 and 08:49 UTC that day, empty blocks came about 75 seconds apart (a minute of waiting, then the time to prove and commit an empty block). Your transaction does not wait for the heartbeat: it goes into the next block that is cut, as before.

A block holds as many transactions as fit under the gas cap of 60,000,000, counted by the gas they use, and under a cap on their raw bytes, 393,216 on DevNet. About 2,857 plain transfers fit under the gas cap. (Until 2026-10-27 the gas cap was 30,000,000, which held 1,428 plain transfers, and the byte cap was 196,608 from 2026-10-25. The throughput figures on [Measurements](/canton-zk-evm/measurements.md) were taken under the 30,000,000 gas cap, at byte caps from 65,536 to 196,608.)

## Canton assets on DevNet

Since 2026-10-29, ERC-20 tokens can stand on Canton as twins, and Canton Coin can come onto Ostia and go back. You pay an ERC-20 into the vault, and the Canton party you name holds the same amount of its twin, a CIP-0056 token whose instrument id is `erc20:<token address>`. Redeeming burns the twin and pays the ERC-20 back out of the vault. For Canton Coin, a party deposits it through the gateway and claims the CC token on Ostia; burning CC pays the Canton Coin back. [Deposits, withdrawals and payments](/canton-zk-evm/deposits-withdrawals-payments.md) has the flows.

| What                                                                | Address on Ostia DevNet                      |
| ------------------------------------------------------------------- | -------------------------------------------- |
| Vault                                                               | `0x69f13a94f986021f1a7650eb611bf9b717aa495a` |
| TKA, an ERC-20 that has a twin (18 decimals)                        | `0xf4b69022b3e6501101600743f17fbe0659dd1af8` |
| WtROME, wrapped tROME, the second twin (18 decimals)                | `0xc221fc4af51caa9d198e70e3cb3b8f3d9d2adc64` |
| CC, Canton Coin on Ostia (10 decimals; earlier records call it wCC) | `0x4db3dea7c13116961fd3e438542ccfcca61a7547` |

The explorer's [`/twins`](https://ostia.devnet.romeprotocol.xyz/twins) page shows each twin's supply next to what the vault holds. The twin registry service answers under `https://ostia.devnet.romeprotocol.xyz/twin-registry`; it holds no key and writes nothing to Canton. Ask for a full path: a bare `/twin-registry/` answers `404`. `GET /twin-registry/healthz` gives the number of twins and the vaults, and `GET /twin-registry/twin/v1/twins` gives each twin's token and instrument id, and the vaults.

The Canton side of a lock or a redeem needs a Canton party that signs. On the explorer's Bridge page you open a Canton account with one wallet signature and make the moves yourself; see [Bridge](/canton-zk-evm/bridge.md). The explorer's [External calls](/canton-zk-evm/explorer.md#external-calls) view shows how each block commits on Canton.

## Canton on DevNet

Rome's DevNet validator, with two participants, runs Splice 0.10.1 with Canton 3.7.2, since 2026-11-07. DevNet's synchronizer runs protocol version 36. Ostia's tests run on protocol versions 36 and 37.

## DevNet may be reset

Ostia DevNet is a test network. It can be reset, which starts a new chain with the same chain id. Do not keep anything on it that you cannot recreate.

What is proven on DevNet, and what is not, is on [What is proven and what is not](/canton-zk-evm/what-is-proven.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/devnet.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.
