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

# Ostia DevNet

Netzwerkdetails für Ostia DevNet, mit der Chain-ID, RPC, dem Explorer, den APIs, der Wallet-Einrichtung, dem Faucet und den Limits.

Ostia DevNet ist das öffentliche Ostia-Netzwerk. Es läuft auf Canton Network DevNet und ist seit **2026-10-22**live. Darauf funktionieren herkömmliche EVM-Tools: Wallets, Foundry, Hardhat, ethers und viem. Auf dieser Seite findest du die Werte, die du für die Verbindung benötigst. [Mit Ostia entwickeln](https://docs.rome.builders/de/canton-zk-evm/build-on-ostia.md) führt dich von dort zu einem bereitgestellten und verifizierten Contract.

Seit **2026-10-29** bewegt die Chain Canton-Assets auch in beide Richtungen: ERC-20-Token existieren auf Canton als Zwillinge, und Canton Coin kommt zu Ostia und wieder zurück. Die Adressen findest du weiter unten unter [Canton-Assets auf DevNet](#canton-assets-on-devnet) .

## Netzwerkdetails

| Einstellung              | Wert                                                                                                       |
| ------------------------ | ---------------------------------------------------------------------------------------------------------- |
| Netzwerkname             | Ostia DevNet                                                                                               |
| Chain-ID                 | `770101` (hexadezimal `0xbc035`)                                                                           |
| Währung                  | tROME, 18 Dezimalstellen. Der Token hat keinen Wert.                                                       |
| RPC                      | `https://ostia.devnet.romeprotocol.xyz/rpc` (nur HTTP, nur finale Blöcke)                                  |
| Explorer                 | [ostia.devnet.romeprotocol.xyz](https://ostia.devnet.romeprotocol.xyz)                                     |
| Etherscan-kompatible API | `https://ostia.devnet.romeprotocol.xyz/api`                                                                |
| REST-API                 | `https://ostia.devnet.romeprotocol.xyz/api/...`, beschrieben im OpenAPI-Dokument unter `/api/openapi.json` |
| Status und Zustand       | `/api/status` und `/api/health` unter der Adresse des Explorers                                            |

Der Gaspreis beträgt etwa 1 gwei, und ein Block fasst bis zu 60.000.000 Gas. Eine einzelne Transaktion darf höchstens 16.777.216 Gas (2^24) verbrauchen – die Obergrenze, die der Osaka-Fork festlegt. Einige Dinge unterscheiden sich von Ethereum, zum Beispiel `block.prevrandao` mit dem Wert 0 und das Fehlen von Blob-Transaktionen; siehe [Unterschiede zu Ethereum](https://docs.rome.builders/de/canton-zk-evm/evm-differences.md).

## Zu einer Wallet hinzufügen

Füge in MetaMask oder einer anderen Wallet ein benutzerdefiniertes Netzwerk mit diesen Werten hinzu:

| Feld                    | Wert                                        |
| ----------------------- | ------------------------------------------- |
| Netzwerkname            | Ostia DevNet                                |
| Neue RPC-URL            | `https://ostia.devnet.romeprotocol.xyz/rpc` |
| Chain-ID                | `770101`                                    |
| Währungssymbol          | `tROME`                                     |
| URL des Block-Explorers | `https://ostia.devnet.romeprotocol.xyz`     |

Der Explorer kann das auch für dich erledigen. Öffne seine [API-Seite](https://ostia.devnet.romeprotocol.xyz/docs/api) und klicke auf die Schaltfläche, um das Netzwerk zu deiner Wallet hinzuzufügen.

## tROME erhalten

Jede Person erhält täglich 1 tROME. Builder können über den Builder-Zuschuss alle 7 Tage 100 tROME erhalten. Öffne den [Faucet](https://ostia.devnet.romeprotocol.xyz/faucet), füge deine Adresse ein und fordere tROME an. Du kannst die Anfrage auch über ein Terminal stellen:

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

Eine angenommene Anfrage wird mit einem `202` ticket `ticket`beantwortet. Rufe `GET /api/faucet/ticket/<ticket>` so lange auf, bis der Status `final` (oder `failed`) ist. Der Status wechselt von `queued` zu `sent` zu `final`. Verwende statt `0xYourAddress`die Adresse deiner Wallet. Das Faucet gibt Folgendes aus:

* 1 tROME pro Adresse alle 24 Stunden;
* eine Anfrage pro IP-Adresse alle 10 Minuten;
* höchstens 5.000 Auszahlungen pro Stunde insgesamt.

Auszahlungen erfolgen in Batches von bis zu 100. Deine Auszahlung trifft ein, sobald der zugehörige Block auf Canton final ist. Nach dem Versand dauert das etwa 10 bis 30 Sekunden. Mit einem tROME lassen sich beim heutigen Gaspreis Tausende gewöhnliche Transaktionen bezahlen. Die Limits des Faucets findest du im [Faucet-Abschnitt der README des Explorers](https://github.com/rome-protocol/canton-zk-evm/blob/main/explorer/README.md#the-faucet).

### Der Builder-Zuschuss

Builder, die sich mit GitHub anmelden, erhalten 100 statt 1 tROME. Gib auf der Faucet-Seite deine Adresse ein und wähle in der Zeile „Baust du auf Ostia? Melde dich mit GitHub an und erhalte 100 tROME“ die Option „Mit GitHub anmelden“. Auf der Bridge-Seite wird derselbe Schritt unter „Test-tROME erhalten“ für die verbundene Wallet angeboten, solange diese noch kein tROME enthält. Andernfalls verwende die Faucet-Seite. GitHub leitet dich zurück zur Faucet-Seite, die deinen Zuschuss wie jede andere Anfrage bis zum Status „final“ verfolgt. Die Seite fordert bei GitHub keine Berechtigungen an und liest nur die Anzahl deiner Konten sowie deren Erstellungsdatum aus.

* Das GitHub-Konto muss mindestens 30 Tage alt sein.
* Ein Zuschuss pro GitHub-Konto und einer pro Adresse alle 7 Tage.
* Höchstens 200 Zuschüsse pro Tag insgesamt.

Die täglichen 1 tROME stehen allen weiterhin zur Verfügung, unabhängig davon, ob sie ein GitHub-Konto haben. Die Antwort von `GET /api/faucet` zeigt, ob der Zuschuss aktiviert ist, sowie dessen Höhe und Limits. Die Regeln findest du im Abschnitt [zum Builder-Zuschuss](https://github.com/rome-protocol/canton-zk-evm/blob/main/explorer/README.md#the-builder-grant) in der README des Explorers.

### Test-Canton-Coin

Seit dem 17.11.2026 gibt es auf der Bridge-Seite kein Canton-Coin-Faucet mehr (es bediente nur das inzwischen stillgelegte Bridge-Konto). Besorge dir Test-Canton-Coin in deiner eigenen Canton-Wallet.

## Limits

Der RPC unter `/rpc` leitet Anfragen an die Chain weiter, mit folgenden Abweichungen:

* Er beantwortet 20 Methoden: `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` und `eth_sendRawTransaction`. Jede andere Methode antwortet `-32601`.
* Es gibt weder WebSocket noch `eth_newFilter` oder `eth_subscribe`. Um Ereignisse zu verfolgen, rufe regelmäßig `eth_getLogs`.
* Es werden nur Blöcke angezeigt, die auf Canton final sind. `latest`, `safe`, `pending` und `finalized` bezeichnen alle den neuesten finalen Block (außer `eth_getTransactionCount` mit `pending`, das wartende Transaktionen mitzählt, damit dein Wallet die nächste Nonce auswählt). Ein Receipt erscheint, sobald der zugehörige Block final ist. Das dauert etwa 10 bis 30 Sekunden.
* Jeder Client kann 300 Aufrufe pro Minute tätigen. Bei einem Batch wird jeder darin enthaltene Aufruf mitgezählt; ein Batch kann höchstens 20 Aufrufe enthalten. Der Request-Body darf höchstens 256 KiB groß sein.
* Eine Transaktion, deren Nonce über der nächsten Nonce des Kontos liegt, wird wegen einer Nonce-Lücke abgelehnt. Sende zuerst die fehlenden Transaktionen.
* Eine Transaktion, deren maximale Gebühr pro Gas unter der aktuellen Base Fee liegt, wird abgelehnt. Wallets und Tools legen diesen Wert selbst fest.

Für die APIs des Explorers gelten eigene Limits pro Client; API-Schlüssel sind nicht erforderlich:

| Schnittstelle                     | Limit                                                                                                                                                                             |
| --------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| REST-API (`/api/...`)             | 20 Anfragen pro Sekunde, mit Spitzen von bis zu 60. Clients, die das Limit überschreiten, erhalten `429` mit `Retry-After`.                                                       |
| Etherscan-kompatible API (`/api`) | 10 Anfragen pro Sekunde und 600 pro Minute. Clients, die das Limit überschreiten, erhalten `Max rate limit reached`, wie es auch bei Etherscan der Fall ist.                      |
| Verifizierung von Smart Contracts | 30 pro Stunde. Eine Anfrage mit mehr als etwa 300 KB wird `413` (siehe [Auf Ostia bauen](https://docs.rome.builders/de/canton-zk-evm/build-on-ostia.md#verify-a-large-contract)). |

Die [README des Explorers](https://github.com/rome-protocol/canton-zk-evm/blob/main/explorer/README.md#the-public-rpc) im Main-Branch beschreibt die RPC-Regeln vollständig, einschließlich der globalen Obergrenze für umfangreiche Aufrufe.

## Eine ruhige Chain erzeugt einen Block pro Minute

Ostia erzeugt einen Block, sobald Transaktionen anstehen. Wenn 60 Sekunden lang kein Block erzeugt wurde, erstellt das Netzwerk einen leeren Block, einen Heartbeat. Auf einer inaktiven Chain beginnt der Builder mit diesem Block 60 Sekunden nach der Erfassung des vorherigen Commits. Das Erstellen des Nachweises und das Finalisieren kommen noch hinzu. Daher vergehen auf einer gesunden, ruhigen Chain höchstens ein paar Minuten ohne neuen Block. Wenn etwas fehlschlägt, kann sich der nächste Block verspäten. Vor dem Morgen des 25.10.2026 gab es keinen Heartbeat, und eine inaktive Chain konnte stundenlang ohne Block bleiben. In den ruhigen Phasen zwischen 07:53 und 08:49 UTC an diesem Tag lagen etwa 75 Sekunden zwischen den leeren Blöcken (eine Minute Wartezeit, danach die Zeit für den Nachweis und den Commit eines leeren Blocks). Deine Transaktion wartet nicht auf den Heartbeat: Wie bisher kommt sie in den nächsten erzeugten Block.

Ein Block enthält so viele Transaktionen, wie unter die Gasobergrenze von 60.000.000 passen, gemessen am verbrauchten Gas, und unter die Obergrenze für ihre Rohdaten, auf DevNet 393.216 Byte. Unter die Gasobergrenze passen etwa 2.857 einfache Transfers. (Bis zum 27.10.2026 lag die Gasobergrenze bei 30.000.000, was 1.428 einfache Transfers zuließ; die Byte-Obergrenze lag ab dem 25.10.2026 bei 196.608. Die Durchsatzangaben unter [Messungen](https://docs.rome.builders/de/canton-zk-evm/measurements.md) wurden bei einer Gasobergrenze von 30.000.000 und Byte-Obergrenzen zwischen 65.536 und 196.608 ermittelt.)

## Canton-Assets auf DevNet

Seit dem 29.10.2026 können ERC-20-Token auf Canton als Zwillinge existieren, und Canton Coin kann auf Ostia übertragen und wieder zurückgebucht werden. Du zahlst einen ERC-20-Token in den Vault ein, und die von dir angegebene Canton-Partei hält denselben Betrag als Zwilling – einen CIP-0056-Token mit der Instrument-ID `erc20:<token address>`. Bei der Einlösung wird der Zwilling verbrannt und der ERC-20-Token aus dem Vault zurückgezahlt. Für Canton Coin zahlt eine Partei den Coin über das Gateway ein und beansprucht den CC-Token auf Ostia; beim Verbrennen von CC wird Canton Coin zurückgezahlt. [Einzahlungen, Auszahlungen und Zahlungen](https://docs.rome.builders/de/canton-zk-evm/deposits-withdrawals-payments.md) beschreibt die Abläufe.

| Was                                                                                                                                                                                   | Adresse auf Ostia DevNet                     |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------- |
| Gateway, der Vertrag, den du für `pay`, `withdraw` und `claim` aufrufst (siehe die [README des Gateways](https://github.com/rome-protocol/canton-zk-evm/blob/main/gateway/README.md)) | `0xa7E0000000000000000000000000000000000000` |
| Vault                                                                                                                                                                                 | `0x69f13a94f986021f1a7650eb611bf9b717aa495a` |
| TKA, ein ERC-20-Token mit Zwilling (18 Dezimalstellen)                                                                                                                                | `0xf4b69022b3e6501101600743f17fbe0659dd1af8` |
| WtROME, verpacktes tROME, der zweite Zwilling (18 Dezimalstellen)                                                                                                                     | `0xc221fc4af51caa9d198e70e3cb3b8f3d9d2adc64` |
| CC, Canton Coin auf Ostia (10 Dezimalstellen; in älteren Datensätzen als wCC bezeichnet)                                                                                              | `0x4db3dea7c13116961fd3e438542ccfcca61a7547` |

Die Seite [`/twins`](https://ostia.devnet.romeprotocol.xyz/twins) des Explorers zeigt neben dem Bestand im Vault das Angebot jedes Zwillings. Der Twin-Registry-Dienst ist unter `https://ostia.devnet.romeprotocol.xyz/twin-registry`erreichbar; er besitzt keinen Schlüssel und schreibt nichts nach Canton. Gib den vollständigen Pfad an: eine alleinstehende `/twin-registry/` liefert `404`. `GET /twin-registry/healthz` liefert die Anzahl der Zwillinge und der Vaults, und `GET /twin-registry/twin/v1/twins` liefert für jeden Zwilling den Token und die Instrument-ID sowie die Vaults.

Für eine Sperrung oder Einlösung auf der Canton-Seite ist eine Canton-Partei erforderlich, die signiert. Auf der Bridge-Seite des Explorers kannst du die Aktionen mit der Canton-Wallet ausführen, die du bereits verwendest; siehe [Bridge](https://docs.rome.builders/de/canton-zk-evm/bridge.md). Die Seite [Externe Aufrufe](https://docs.rome.builders/de/canton-zk-evm/explorer.md#external-calls) Ansicht zeigt, wie jeder Block auf Canton bestätigt wird.

## Canton auf DevNet

Der DevNet-Validator von Rome mit zwei Teilnehmern läuft seit dem 07.11.2026 mit Splice 0.10.1 und Canton 3.7.2. Der Synchronizer von DevNet läuft seit dem 18.11.2026 mit Protokollversion 37. Die Tests von Ostia laufen mit den Protokollversionen 36 und 37.

## Pausen und Wartungsarbeiten

DevNet wird von Zeit zu Zeit pausiert; einige Pausen sind geplant. Je nach Ursache zeigt sich eine Pause auf eine von zwei Arten:

* Während eines **Neustarts einer Maschine** ist die RPC-Schnittstelle nicht erreichbar und antwortet mit einem Serverfehler (einem 5xx-Fehler vom vorgeschalteten Proxy).
* Während einer **Pause eines Validators oder Synchronizers** antwortet die RPC-Schnittstelle weiterhin und nimmt Transaktionen entgegen, aber es wird kein Block bestätigt. Daher gibt es keinen neuen finalen Block und keinen Beleg, bis `/api/health` wieder `ok` meldet.

Eine Transaktion, die Ostia vor einer Pause angenommen hat, wird bis zu einer Stunde lang mit ihren signierten Bytes gespeichert und danach erneut gesendet. Warte daher, bis `/api/health` wieder `ok` meldet, bevor du sie erneut sendest.

* **Neustarts von wenigen Minuten Dauer.** Die Maschinen von Ostia können ohne Vorwarnung neu gestartet werden. Am 04.11.2026 gab es drei Neustarts, die jeweils nach etwa 7 Minuten automatisch behoben waren.
* **Validator-Upgrades.** Der DevNet-Validator von Rome wird von Zeit zu Zeit aktualisiert; währenddessen bestätigt Ostia keine Blöcke. Für das Upgrade am 04.11.2026 waren 15 Minuten eingeplant.
* **16.11.2026: Zugriffseinstellungen des DevNet-Validators von Rome (09:00 bis 10:30 UTC) und Upgrade des Beweissystems auf ZisK 1.4.0-alpha (13:31 UTC).** Ostia wurde für beide Vorgänge pausiert. Beide sind abgeschlossen, und Transaktionen sowie die Bridge wurden nach jeder Pause wieder aufgenommen.
* **18.11.2026: Upgrade des DevNet-Synchronizers auf Protokollversion 37 (14:00 UTC).** Ostia lief währenddessen weiter; die längste Lücke zwischen finalen Blöcken betrug 72 s.
* **21.11.2026, 12:00 bis 16:00 UTC:** Ostia wechselt zu Canton TestNet. Während des Wechsels werden die Blöcke pausiert; tROME, Token und Verträge wechseln mit der Chain. Neue Adresse: ostia.testnet.romeprotocol.xyz. Canton Coin und andere von Canton unterstützte Token auf Ostia bleiben auf DevNet und werden nicht verschoben.

Wir veröffentlichen diese Termine und etwaige Änderungen hier auf der Seite [Status und Roadmap](https://docs.rome.builders/de/canton-zk-evm/status.md#upcoming-maintenance) sowie im Rome- [Discord](https://discord.gg/vZ9rnCdNSB).

## Canton-Traffic: Wer zahlt

Jede Canton-Transaktion verbraucht Traffic. Der Teilnehmer, der die Transaktion einreicht, zahlt dafür; jeder bestätigende Teilnehmer zahlt für die von ihm gesendeten Bestätigungen. Auf DevNet ist Rome in beiden Fällen der Teilnehmer: Er reicht jeden Block ein und zahlt für dessen `Advance` sowie für die Canton-Schritte, die die eigenen Parteien von Rome ausführen, und ist der einzige Teilnehmer, der die Blöcke von Ostia bestätigt. Für Canton-Traffic zahlst du derzeit nichts. Deine Kosten sind tROME für Gas auf Ostia, und tROME hat keinen Wert.

Ein Block verursacht etwa 8,4 KB Traffic plus rund 100 Byte pro Transaktion darin (gemessen über eine Stunde am 24.10.2026: median 15,7 KB pro Block; siehe [Messungen](https://docs.rome.builders/de/canton-zk-evm/measurements.md#what-a-block-costs-on-canton)). Bei etwa 2.200 Blöcken pro Tag sind das ungefähr 17 bis 35 MB täglich. Rome begrenzt den Canton-Traffic der Bridge pro Konto und Tag. Auf dieser Seite wird kein Preis pro MB angegeben, da dieser vom Canton-Netzwerk festgelegt wird und noch nicht entschieden ist, wie Traffic in einem Netzwerk außerhalb von DevNet bezahlt wird.

## DevNet kann zurückgesetzt werden

Ostia DevNet ist ein Testnetzwerk. Es kann zurückgesetzt werden; dabei wird eine neue Chain mit derselben Chain-ID 770101 gestartet. Bewahre dort nichts auf, was du nicht wiederherstellen kannst.

Da die Chain-ID gleich bleibt, ist jede für die alte Chain signierte Transaktion auch auf der neuen gültig. Jeder kann die alten signierten Transaktionen mit den Nonces 0, 1, 2 und so weiter erneut senden und dadurch deine früheren Deployments und Genehmigungen sowie die öffentlichen Auszahlungen des Faucets auf der neuen Chain wiederholen. Verwende keinen wichtigen Schlüssel über einen Reset hinweg und nutze danach eine neue Deployer-Adresse. Auch der gespeicherte Zustand deiner Tools ist an die Chain-ID gebunden und wird dadurch veraltet: Lösche Hardhat Ignition- `deployments/chain-770101`sowie Foundrys `broadcast/<script>/770101`und die Aktivitäten sowie den Nonce deiner Wallet für das Netzwerk (in MetaMask: Einstellungen, Erweitert, Tab „Aktivitätsdaten löschen“). Wenn möglich, kündigen wir einen Reset im Voraus an den unter [Pausen und Wartungsarbeiten](#pauses-and-maintenance).

aufgeführten Stellen an. Was auf DevNet nachgewiesen ist und was nicht, erfährst du auf [Was bewiesen ist und was nicht](https://docs.rome.builders/de/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/de/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.
