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

# Explorer

Ein Leitfaden zum Live-Ostia-DevNet-Explorer, seinem Faucet, seinen APIs und der Proof-Prüfung im Browser.

Der Ostia-Explorer ist verfügbar unter [ostia.devnet.romeprotocol.xyz](https://ostia.devnet.romeprotocol.xyz). Er kombiniert die EVM-Daten von reth mit den Canton-Datensätzen jedes Blocks, die er als Reader-Partei ausliest. Damit kannst du nach einem Block oder einer Transaktion suchen, einen Proof im Browser prüfen, einen Vertrag verifizieren, tROME erhalten und dieselben Daten über eine API abrufen.

Diese Seite beschreibt Release `v0.1.0` und, sofern ausdrücklich angegeben, den aktuellen Stand auf DevNet. [Status](https://docs.rome.builders/de/canton-zk-evm/status.md) nennt den Commit, der auf DevNet ausgeführt wird. Lies die vollständige [Explorer-README](https://github.com/rome-protocol/canton-zk-evm/blob/main/explorer/README.md).

Der Explorer kennzeichnet einen Block erst dann als final, wenn sein Datensatz auf Canton vorliegt. Bis dahin zeigt er den Block von reth als in Prüfung an; eine gerade gesendete Transaktion wird als ausstehend angezeigt. Wenn keine Transaktionen anstehen, erstellt der Builder einmal pro Minute einen leeren Block. Daher ist der neueste Block auf einer ruhigen Chain höchstens ein paar Minuten alt. Die Zeitangaben auf allen Seiten sind in UTC.

## Rundgang durch die Seiten

| Seite           | Möglichkeiten                                                                                                                                                                                                                                                                                                                                                                                                |
| --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Startseite      | Suche nach Block, Transaktion, Adresse oder Canton-Update-ID. Sieh dir den neuesten finalen Block, den gerade geprüften Block, die Zeit bis zur Finalität, die Proof-Zeit und die neuesten Blöcke an. Eine Statusleiste zeigt, ob der EVM-Knoten, Canton, der Producer, der Prover, der Faucet und der Verifier einsatzbereit sind. Über die Kachel zur Canton-Commit-Zeit gelangst du zu „Externe Aufrufe“. |
| Blöcke          | Liste finale Blöcke auf, filtere nach Blöcken mit Transaktionen, lade eine CSV-Datei herunter oder öffne einen Block.                                                                                                                                                                                                                                                                                        |
| Transaktionen   | Liste Transaktionen auf und filtere nach noch nicht finalen, fehlgeschlagenen oder Vertragsaufrufen. Eine Transaktion zeigt ihr Ergebnis, den Block, das Canton-Update, die Gebühr, die dekodierte Eingabe und eine Zeitleiste ihrer vier Finalitätsschritte.                                                                                                                                                |
| Verträge        | Sieh nach, welche Verträge verifiziert sind und wie häufig sie verwendet werden. Auf einer Vertragsseite findest du den verifizierten Quellcode, die ABI, Ereignisse sowie Lese- und Schreibaufrufe. Schreibaufrufe laufen über deine Wallet.                                                                                                                                                                |
| Token           | Durchsuche ERC-20-, ERC-721- und ERC-1155-Token samt Inhabern und Transfers. Auf einem Tab werden Token von Canton aufgeführt, etwa wTKB und CC.                                                                                                                                                                                                                                                             |
| Externe Aufrufe | Sieh dir an, wie jeder Block auf Canton committet wurde: eine Zeile pro Block mit Status, Abwicklungszeit und Anzahl der Versuche. Über den Header-Link „Externe Aufrufe“ gelangst du dorthin. Siehe [Externe Aufrufe](#external-calls).                                                                                                                                                                     |
| Statistiken     | Sieh dir die Zeit bis zur Finalität, die Proof-Zeit, die Canton-Commit-Zeit, Transaktionen pro Sekunde und die Erfolgsrate für 1 Stunde, 6 Stunden, 24 Stunden, 7 Tage oder 30 Tage an. Eine Canton-Assets-Karte zeigt für jedes Asset den Bestand im Vergleich zu den Guthaben im Vault und Gateway. Eine Karte zu externen Aufrufen zeigt, wie die Commits an Canton laufen.                               |
| Twins           | Sieh dir die bidirektionalen Canton-Assets unter [`/twins`](https://ostia.devnet.romeprotocol.xyz/twins)an: den Bestand jedes Twins im Vergleich zum Guthaben des Vaults sowie die neuesten Locks und Redeems.                                                                                                                                                                                               |
| Swaps           | Sieh dir unter [`/swaps`](https://ostia.devnet.romeprotocol.xyz/swaps)die Swaps an, die ein Canton-Handelsplatz mit der EVM durchgeführt hat, und öffne einzelne Swaps mit ihrer Zahlung und ihrem Claim.                                                                                                                                                                                                    |
| Bridge          | Verbinde deine Wallet, erhalte Test-tROME und verschiebe Token zwischen Ostia und Canton mit der Canton-Wallet, die du bereits verwendest (wird Wallet für Wallet aktiviert; bis dahin steht auf der Schaltfläche „Demnächst verfügbar“). Siehe [Bridge](https://docs.rome.builders/de/canton-zk-evm/bridge.md).                                                                                             |
| Faucet          | Fordere tROME an oder melde dich mit GitHub an, um den Builder-Zuschuss von 100 tROME zu erhalten, und verfolge deine Anfrage bis zur Finalität.                                                                                                                                                                                                                                                             |
| API             | Lies die API-Referenz, die aus dem OpenAPI-Dokument erstellt wurde. Über eine Schaltfläche kannst du Ostia DevNet zu deiner Wallet hinzufügen.                                                                                                                                                                                                                                                               |

Der Header enthält auf jeder Seite außer der Startseite ein Suchfeld; dort gibt es ein eigenes. Mit der `/` -Taste wird es fokussiert. Blöcke, Transaktionen, Transaktionen und Transfers einer Adresse sowie Transfers eines Tokens lassen sich als CSV herunterladen. Die Seiten folgen einem Live-Stream, sodass neue Blöcke ohne Neuladen erscheinen. Adress- und Gateway-Leg-Seiten lassen sich über Links öffnen; Adressen können auch über die Suche geöffnet werden. Im Header gibt es dafür keinen Eintrag.

## Einen Block ansehen

Die Blockseite zeigt die EVM-Daten neben der Canton-Seite: die Update-ID, den Erfassungszeitpunkt sowie den Betreiber und den Bestätiger, die den Datensatz signiert haben. Sie vergleicht den Block-Hash von reth, den Hash des Datensatzes und den Hash des darin erfassten Headers und zeigt an, ob alle drei übereinstimmen. Außerdem zeigt sie den Programmschlüssel, das ZisK-Release und den Block-Hash aus dem Proof neben den erwarteten Werten des Explorers an. Ein abweichender Wert wird rot angezeigt.

Vier Kacheln fassen den Block in Zahlen zusammen: Transaktionen, Proof-Zeit, Canton-Commit (die Zeit zwischen dem Absenden des Blocks und seinem Erfassungszeitpunkt auf Canton) sowie die Zeit vom Erstellen des Blocks bis zur Finalität. Die Canton-Commit-Karten auf der Startseite und unter „Statistiken“ messen die Zeit vom Absenden bis zum Empfang der Antwort von Canton durch den Builder; ihre Werte liegen daher über denen dieser Kachel. Ein Bereich mit dem Titel „So wurde dieser Block final“ listet die Schritte samt Zeitangaben auf.

Ein Block, der gerade geprüft wird, ist noch nicht auf Canton. Die Seite weist darauf hin und aktualisiert sich, bis der Block final ist. Eine Transaktion kann ausstehend, in Prüfung oder final sein. Die Blockseite listet die Gateway-Legs so auf, wie sie von der EVM erfasst wurden. `BlockRecord` enthält nicht, wie die einzelnen Legs auf Canton abgewickelt wurden; der Explorer kann das daher nicht anzeigen. Siehe [Legs und Verwahrung](#legs-and-custody) für die auf DevNet aktiven Legs.

## Legs und Verwahrung

Die Legs des Gateways sind auf DevNet aktiv, das von Rome mit Testparteien betrieben wird (siehe [Einzahlungen, Auszahlungen und Zahlungen](https://docs.rome.builders/de/canton-zk-evm/deposits-withdrawals-payments.md)); diese Seiten enthalten daher jetzt Inhalte. Im Header gibt es noch keinen Eintrag dafür; rufe [`/legs`](https://ostia.devnet.romeprotocol.xyz/legs) direkt auf oder folge einem Leg von seinem Block aus.

* **Die Liste** unter `/legs` zeigt jedes Leg mit seiner Art (Einzahlung, Zahlung oder Auszahlung), seinem Block, Token, Konto und Betrag. Öffne eines, um die eigene Seite unter `/leg/<id>`anzuzeigen. Bei einer Auszahlung wird die Canton-Partei genannt, an die sie gezahlt wurde. Um 11:54 UTC am 2026-10-25 enthielt die Liste sechs Legs aus den beiden Durchläufen dieses Tages (Blöcke 780, 783, 784, 1465, 1471 und 1473).
* **Die API** stellt dieselben Daten unter `/api/legs`, `/api/legs/<id>` und `/api/blocks/<number>/legs`.
* **Der Wrapped Token** wTKB unter `0x294d3049874526910a69f6b61da14d10a8b1b3af`hat wie jeder ERC-20-Token eine eigene Token-Seite (10 Dezimalstellen). Sein Bestand betrug bei Block 1473 12 wTKB, und der Durchlauf von Rome bestätigte, dass das Gateway 12 TKB auf Canton hielt.
* **Verwahrung im Verhältnis zum Bestand.** Die Seite eines durch Canton gedeckten Tokens zeigt eine Karte „Auf Canton gedeckt“: den Bestand des Gateways auf Canton neben dem Wrapped-Bestand, ermittelt bei demselben Block, und `GET /api/tokens/<address>` liefert dieselben Werte in einem `canton` -Objekt. Angezeigt wird nur der Gesamtbetrag, niemals ein einzelner Bestand. Die Verwahrungsabfrage ist seit dem 2026-10-25 um 12:27 UTC auf DevNet verfügbar. Am selben Tag um 12:52 UTC ergab die Abfrage für wTKB eine Verwahrung von 12 TKB in zwei Beständen bei einem Wrapped-Bestand von 12 wTKB.

## Twins und Canton-Assets

Der Explorer zeigt die zweiseitigen Canton-Assets (siehe [Einzahlungen, Auszahlungen und Zahlungen](https://docs.rome.builders/de/canton-zk-evm/deposits-withdrawals-payments.md#canton-twins-of-erc-20-tokens)). Öffne [`/twins`](https://ostia.devnet.romeprotocol.xyz/twins). Dort findest du:

* **Das Registry.** Die Vaults, die im Chain-Datensatz registriert sind, jeweils mit ihrem Code-Hash, sowie die Twins, auf die sie verweisen, mit deren Dezimalstellen.
* **Eine Karte für jeden Twin.** Sein Bestand auf Canton neben dem Bestand im Vault, ermittelt bei demselben Block, einschließlich des Blocks, bis zu dem die Werte gezählt werden, sowie der Anzahl der Locks und Redeems. Nach jedem Lock und Redeem stimmen die beiden Werte überein.
* **Verwahrung im Verhältnis zum Bestand** für die Canton-Token, etwa wTKB und CC: den Bestand des Gateways auf Canton neben dem Wrapped-Bestand.
* **Die neuesten Locks und Redeems.** Jeder Eintrag verweist auf sein Leg, seine Transaktion, seinen Block und das Canton-Update.
* **Der Registry-Dienst.** Eine Zeile mit einem Link zur Gesundheitsprüfung des Twin-Registry-Dienstes.

Die Karte „Canton-Assets“ unter „Stats“ zeigt dieselben Bestände im Vergleich zu den Beständen im Vault und beim Gateway, und `GET /api/twins` liefert die gesamte Seite als JSON. Angezeigt werden nur Gesamtbeträge, niemals einzelne Bestände.

## Externe Aufrufe

Öffnen **Externe Aufrufe** in der Kopfzeile unter [`/canton`](https://ostia.devnet.romeprotocol.xyz/canton). Ostia verbucht jeden Block als eine Canton-Transaktion. Der externe Aufruf des bestätigenden Teilnehmers prüft den Beweis des Blocks; auf DevNet ist dieser Teilnehmer Rome. Auf dieser Seite sehen Sie, wie die einzelnen Verbuchungen abliefen.

**Die Kopfzeile** zeigt die Kennzahlen für alle Blöcke:

* verbuchte Blöcke;
* die Erfolgsquote, also den Anteil der erfolgreichen Verbuchungen an allen Versuchen: 99,99 % aller Blöcke bis zum 09.11.2026;
* die Abwicklungsdauer als Durchschnitt und p95 für die letzten 24 Stunden oder die letzten 7 Tage (am 09.11.2026 betrug sie für 24 Stunden etwa 9,1 s bzw. 10,7 s);
* die von Canton abgelehnten Verbuchungen sowie die Blöcke, die nach einem erneuten Versuch verbucht wurden;
* die abgewickelten Legs, aufgeschlüsselt nach Art.

**Die Liste** enthält eine Zeile pro Block. Jede Zeile zeigt:

* das Canton-Update und den darin enthaltenen EVM-Block sowie die Anzahl der abgewickelten EVM-Transaktionen;
* den Status: beim ersten Versuch oder nach weiteren Versuchen verbucht, einschließlich der Anzahl der Ablehnungen durch Canton;
* die Auswahl `Advance` im Vertrag `ZkChain` der Chain;
* die vom Block abgewickelten Legs, aufgeschlüsselt nach Art;
* die Abwicklungsdauer vom Start des Blockbeweises bis zum Erfassungszeitpunkt bei Canton sowie den Erfassungszeitpunkt.

Zeigen Sie alle Blöcke oder nur die beim ersten Versuch verbuchten, erneut versuchten, mindestens einmal von Canton abgelehnten oder Legs abwickelnden Blöcke an. Sortieren Sie die Liste nach den neuesten oder ältesten Einträgen. **CSV** lädt die ersten 1.000 Zeilen der geöffneten Ansicht in der angezeigten Reihenfolge herunter. Mit `GET /api/canton/updates?format=csv&filter=<all|first|retried|refused|legs>&order=<desc|asc>` erhalten Sie dieselbe Datei.

**Ein Update** öffnet eine Seite mit einer Zeitleiste (Block erstellt, Beweiserstellung gestartet, Beweiserstellung abgeschlossen, an Canton übermittelt, bei Canton verbucht), allen Verbuchungsversuchen bis einschließlich des erfolgreichen Versuchs, der Beweisprüfung und den vom Block abgewickelten Legs. Daneben sehen Sie den eigenen Vergleich des Explorers zwischen dem Beweis und den festgelegten Werten. Die Angaben stammen aus dem Canton-Datensatz und dem eigenen Protokoll des Builders (die Seite kennzeichnet diese Angaben als „Producer-Protokoll“). Für einen Block, zu dem das Protokoll keine Daten enthält, werden nur die bei Canton gespeicherten Informationen angezeigt.

Die wichtigsten Kennzahlen finden Sie auf der Seite **Statistiken** in einer Karte „Externe Aufrufe“. Mit `GET /api/canton/stats` werden sie als JSON bereitgestellt.

## Beweis im Browser prüfen

Das Auslesen von Werten aus dem Beweis verifiziert ihn nicht. Wenn Sie auf „Verifizieren“ klicken, wird ein WebAssembly-Build der Funktion `verify` des Sidecars heruntergeladen und mit dem aufgezeichneten Beweis, Header und den Transaktionen ausgeführt.

Die Prüfung verifiziert den PLONK-Beweis anhand des festgelegten Programmschlüssels und der ZisK-Version. Sie prüft, ob der Header den bewiesenen Block-Hash ergibt und ob die Transaktionen mit dem Transaktions-Root des Headers übereinstimmen. Außerdem muss der Block-Hash dem Hash entsprechen, den reth für den Block angibt.

Die erwarteten festgelegten Werte stammen aus der Statusantwort des Explorers. „Verifizieren“ führt die Blockprüfung des Sidecars aus, nicht die separate Prüfung `legs` aus. Während der Block bewiesen wird, ist die Schaltfläche deaktiviert. Nach der Prüfung zeigt die Karte das Ergebnis, die Dauer und die Downloadgröße des Moduls an. Die Downloadzeit ist nicht in der Dauer enthalten. Weitere Informationen finden Sie in der [README zur Browser-Verifizierung](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/explorer/verify/README.md).

## Den tROME-Faucet verwenden

Der Faucet gibt bei jeder Anfrage 1 tROME aus, für alle zugänglich. tROME ist die Testwährung von Ostia DevNet und hat keinen Wert. Öffnen Sie die Faucet-Seite oder senden Sie `POST /api/faucet`. Es gelten folgende Limits:

* eine Anfrage pro Adresse innerhalb von jeweils 24 Stunden;
* eine Anfrage pro IP-Adresse alle 10 Minuten;
* 5.000 Auszahlungen pro Stunde über alle Clients hinweg.

Eine Anfrage wird sofort in die Warteschlange gestellt und mit einem Ticket beantwortet. Der Faucet zahlt die Warteschlange in Stapeln von bis zu 100 aus, und deine Auszahlung trifft ein, sobald der zugehörige Block final ist. `GET /api/faucet/ticket/<id>` zeigt an, wo sich deine Anfrage befindet. Die Limits werden in der Datenbank gespeichert und daher durch einen Neustart nicht zurückgesetzt. Einzelheiten findest du im [Faucet-Abschnitt](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 tROME statt 1. Gib deine Adresse auf der Faucet-Seite ein und wähle die Zeile „Baust du auf Ostia? Melde dich mit GitHub an, um 100 tROME zu erhalten.“ mit „Mit GitHub anmelden“. GitHub leitet dich zurück zur Seite, die deinen Zuschuss bis zur Finalität verfolgt. Das GitHub-Konto muss mindestens 30 Tage alt sein. Jedes GitHub-Konto und jede Adresse erhält alle 7 Tage einen Zuschuss, und der Faucet vergibt insgesamt höchstens 200 Zuschüsse pro Tag. Die Seite fordert bei GitHub keine Berechtigungen an. [Ostia DevNet](https://docs.rome.builders/de/canton-zk-evm/devnet.md#the-builder-grant) enthält die Schritte und Limits.

## APIs verwenden

Alle drei APIs sind ohne Schlüssel frei zugänglich. Die Limits gelten pro Client.

| API                                         | Adresse    | Limit                                        |
| ------------------------------------------- | ---------- | -------------------------------------------- |
| JSON-RPC, nur finale Blöcke, nur HTTP       | `/rpc`     | 300 Aufrufe pro Minute, Stapel mit bis zu 20 |
| REST, beschrieben unter `/api/openapi.json` | `/api/...` | 20 Anfragen pro Sekunde, Spitzen von 60      |
| Etherscan-kompatibel                        | `/api`     | 10 Anfragen pro Sekunde und 600 pro Minute   |

RPC unterstützt weder WebSocket noch Filter. Frage daher `eth_getLogs`. `GET /api/stream` ist der Live-Stream, den die Seiten verwenden. `GET /api/status` meldet die Chain, den festgelegten Programmschlüssel und den Zustand der einzelnen Komponenten.

Um den Quellcode eines Vertrags zu verifizieren, verwende `forge verify-contract` mit dem Etherscan-Verifizierer:

```sh
forge verify-contract <address> src/Counter.sol:Counter \
  --chain-id 770101 \
  --evm-version london \
  --verifier etherscan \
  --verifier-url https://ostia.devnet.romeprotocol.xyz/api \
  --etherscan-api-key any
```

Verwende dieselbe Compilerversion, dieselben Optimizer-Einstellungen und dieselbe EVM-Version wie beim Deployment. Du kannst 30 Verifizierungen pro Stunde senden. Bei einem Vertrag mit vielen Quelldateien kann forge den HTTP-Fehler 413 zurückgeben, da forge seine Eingabe URL-kodiert sendet und der vorgeschaltete Proxy des Explorers pro Anfrage etwa 300 KB verarbeitet. Siehe [Große Verträge verifizieren](https://docs.rome.builders/de/canton-zk-evm/build-on-ostia.md#verify-a-large-contract). [Auf Ostia entwickeln](https://docs.rome.builders/de/canton-zk-evm/build-on-ostia.md) behandelt das Deployment; die [Ratenlimits](https://github.com/rome-protocol/canton-zk-evm/blob/main/explorer/README.md#rate-limits) stehen in der README des Explorers.

## Was die Reader-Partei sehen kann

Der Explorer liest Canton als Reader-Partei mit einem schreibgeschützten Token aus. Diese Partei kann den Blockdatensatz sehen, aber nichts anderes im Daml-Paket von Ostia. Sie sieht für jeden Datensatz die Nummer, den Hash, den Parent-Hash, den Header, die Transaktionen und den Proof sowie die Update-ID, den Datensatzzeitpunkt und die beiden Signierer. Einzahlungsanfragen, Auszahlungsannahmen oder Zahlungsbedingungen kann sie nicht sehen; deshalb werden diese im Explorer nicht angezeigt.

Die Bestände des Gateways stammen von einem zweiten, schreibgeschützten Client, der die Daten aus Sicht der Gateway-Partei ausliest. Er zeigt Summen an: die Karte „Auf Canton gedeckt“, die Seite `/twins` , die Karte zu Canton-Assets auf „Stats“ und `GET /api/twins`. Außerdem liest er die Venue-Trades und finanzierten Ansprüche hinter `/swaps` und `GET /api/swaps`, wobei die Zahlung, der Anspruch und ihre Canton-Aktualisierungen erhalten bleiben und die Canton-Parteien des Handelsplatzes und des Verkäufers entfernt werden.

Die Grenzen des Lesers sind die des Explorers selbst. Der Betreiber des Teilnehmers, auf dem die Ostia-Parteien gehostet werden, kann weiterhin alles einsehen. Auf DevNet ist dieser Betreiber Rome, das den Teilnehmer als eigenen Canton-DevNet-Validator betreibt. [Vertrauensmodell und Einschränkungen](https://docs.rome.builders/de/canton-zk-evm/trust-model.md) erläutert, was das bedeutet. Verify führt die Prüfung des Sidecars in deinem Browser anhand der Daten aus, die dieser Explorer bereitstellt.

Wie du deinen eigenen Explorer samt Datenbank betreibst, erfährst du unter [Eigenes Ostia betreiben](https://docs.rome.builders/de/canton-zk-evm/run-it-locally.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/explorer.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.
