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

# Vertrauensmodell und Grenzen

Die Prüfungen, Autoritäten, Verwahrungsannahmen und Limits von Ostia auf dem Canton Network DevNet.

Ostia ist eine frühe Veröffentlichung auf Canton Network DevNet. Rome betreibt alle Ostia-Dienste: den einzigen Builder, den Prover, den öffentlichen RPC, den Explorer, den Faucet, den Twin-Registry-Dienst und den Participant, auf dem alle Ostia-Parteien laufen (Romes eigener DevNet-Validator). Der Synchronizer von Canton Network DevNet, der die Blöcke ordnet, wird vom Netzwerk betrieben, nicht von Rome. Romes einziger Sidecar ist der einzige Confirmer. Auf dieser Seite wird erläutert, wer was prüft und wer worüber verfügt. Verwenden Sie Ostia nicht für Werte.

**Wem Sie heute vertrauen.** Rome betreibt den Prover und den einzigen bestätigenden Participant. Romes Participant verwahrt die Canton Coins und hat die Twin-Administratorrechte. Der Code und ZisK (Alpha) wurden nicht auditiert. Dies gilt ausschließlich für DevNet.

Diese Seite beschreibt die Veröffentlichung `v0.1.0` und, sofern angegeben, den aktuellen Betrieb auf DevNet. [Status](https://docs.rome.builders/de/canton-zk-evm/status.md) nennt den Commit, der auf DevNet ausgeführt wird. Lesen Sie das vollständige [Design](https://github.com/rome-protocol/canton-zk-evm/blob/main/docs/DESIGN.md) und die [Sicherheitsrichtlinie](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/SECURITY.md).

## Lokale Demo im Vergleich zu Ostia DevNet

Die Demo vom 2026-10-05 lief auf einem lokalen Canton-Netzwerk. Die Prüfungen verwenden auf beiden Seiten denselben Code. Die Vertrauenskonfiguration unterscheidet sich.

|                                          | Lokales Demo-Netzwerk                                                                             | Ostia DevNet                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| ---------------------------------------- | ------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Teilnehmer                               | Drei: Betreiber, Confirmer und Nutzer.                                                            | Ein Participant, der von Rome, hostet alle Ostia-Parteien. Ein zweiter Participant von Rome hostet bisher keine.                                                                                                                                                                                                                                                                                                                                                                     |
| Confirmer                                | 2, jeweils mit eigenem Sidecar.                                                                   | 1, der Sidecar neben diesem Participant.                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| Persistenz                               | Beim Neustart geht der Zustand verloren, sofern der Start nicht im persistenten Modus erfolgt.    | Die Chain bleibt auf dem Participant erhalten. DevNet kann dennoch zurückgesetzt werden.                                                                                                                                                                                                                                                                                                                                                                                             |
| Zugriff auf die Ledger-API               | Keine Authentifizierung, auf einem Rechner.                                                       | Jeder Nutzer der Ostia Ledger API benötigt ein kurzlebiges Token.                                                                                                                                                                                                                                                                                                                                                                                                                    |
| Wer betreibt was?                        | Wer auch immer den Start ausführt, betreibt alle Parteien auf einem Rechner.                      | Rome betreibt alle Ostia-Dienste: den Participant, auf dem die Parteien laufen, den Builder, Prover, RPC, Explorer, Faucet und Twin-Registry-Dienst. Das Netzwerk betreibt den Synchronizer.                                                                                                                                                                                                                                                                                         |
| Canton                                   | Canton 3.6.3 unter `v0.1.0`; bei den Ausführungen vom 2026-10-05 kamen 3.6-Snapshots zum Einsatz. | Romes Validator verwendet Splice 0.10.1 mit Canton 3.7.2 (seit 2026-11-07). Der Synchronizer von DevNet hat Protokollversion 37 (seit 2026-11-18). Daml SDK 3.6.0, damlc 3.6.2.                                                                                                                                                                                                                                                                                                      |
| Einzahlungen, Auszahlungen und Zahlungen | In der Demo vom 2026-10-05 gezeigt.                                                               | Seit 2026-10-25 mit dem Test-Token TKB live. Rome betreibt die Testparteien und jeden Schritt.                                                                                                                                                                                                                                                                                                                                                                                       |
| Twins und Canton Coin                    | Nicht in der Veröffentlichung enthalten `v0.1.0`.                                                 | Seit 2026-10-29 live: ERC-20-Twins über den Vault sowie Canton Coin in beide Richtungen. Vom 2026-11-08 bis zum 2026-11-17 konnte die Bridge-Seite über eine Wallet-Signatur ein Canton-Konto eröffnen; dieses Konto wurde stillgelegt (siehe [das über eine Wallet-Signatur erstellte Bridge-Konto](#the-bridge-account-made-from-a-wallet-signature)). Die Bridge-Seite verbindet die bereits vorhandene Canton-Wallet, wobei die Funktion für jede Wallet einzeln aktiviert wird. |

Die [README des Netzwerks](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/network/README.md#running-on-an-existing-participant-the-canton-network) bezeichnet einen einzelnen Confirmer als schwächer als das lokale Netzwerk und für DevNet als ausreichend.

## Wer prüft was?

| Bereich          | Prüfung oder Zuständigkeit                                                                                                                                                                                         |
| ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Gast             | Validiert den EVM-Block und weist eine Chain-Konfiguration zurück, die nicht den kompilierten Regeln von Ostia entspricht.                                                                                         |
| Sidecar `verify` | Prüft den Beweis, den festgelegten programVK und rootC, den nachgewiesenen Block-Hash, den Header und die Transaktionsliste.                                                                                       |
| Sidecar `legs`   | Prüft die Konto- und Speicherbeweise des Gateways und vergleicht die geordneten angehängten Legs mit dem nachgewiesenen Gateway-Hash.                                                                              |
| Daml `Advance`   | Prüft die Antworten des Sidecars, den Parent, die Nummer des nächsten Blocks, das Gaslimit und die von den Legs verwendeten Verträge. Wickelt die Legs ab und erstellt den nächsten Head sowie den Blockdatensatz. |
| Canton           | Ordnet Blöcke durch den Verbrauch des einzigen State-Contracts der Chain und übernimmt gemeinsam die Änderungen der Transaktion. Weist abweichende Antworten auf externe Aufrufe zurück.                           |
| Builder          | Wählt Transaktionen aus, prüft die für ihn sichtbaren Canton-Verträge, beschafft einen Beweis und übermittelt den Block. Er kann einen Block nicht selbst finalisieren.                                            |

Neben jedem bestätigenden Teilnehmer läuft ein Sidecar. Auf DevNet gibt es eines, und zwar neben dem Teilnehmer, der alle Ostia-Parteien hostet: Rome. Daher prüft heute der eigene Node von Rome den Beweis. Der Synchronizer von Canton ordnet die Blöcke und leitet die Nachrichten weiter; den Beweis sieht er nicht. Jedes Sidecar berechnet seine Antworten ausschließlich anhand der Eingabe, die im externen Aufruf übermittelt wurde. Daml vergleicht die Antworten; die kryptografische Beweisprüfung führt Daml nicht selbst durch. Die [Sidecar-README](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/sidecar/README.md) und [Daml-README](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/daml/README.md) beschreiben die Prüfungen und Anforderungen an die Berechtigungen.

## Was der Beweis festlegt

Der festgelegte Programmschlüssel identifiziert den Guest und seine Chain-Regeln. Der Beweis bindet einen Block-Hash. Die Prüfung des Headers bindet die State-Root und die Transaktions-Root. Konto- und Speicherbeweise binden dann den aufgezeichneten Leg-Hash des Gateways an diese State-Root.

Die angehängten Legs müssen dieselben Felder und dieselbe Reihenfolge aufweisen wie die vom Gateway aufgezeichneten. Wird ein Leg entfernt, hinzugefügt oder Empfänger, Betrag, Token oder ID geändert, schlägt der Hash-Vergleich fehl. Auch für einen Block ohne Legs muss deren Abwesenheit nachgewiesen werden. Der Vergleich der Legs beruht außerdem auf der Kollisionsresistenz von Keccak-256.

Die Genesis-State-Root des Chain-Datensatzes legt den Gateway-Code fest. Der Gateway-Contract hat weder einen Owner noch einen Admin-Schlüssel, eine Upgrade- oder eine Pausenfunktion. Die Canton-Partei besitzt weiterhin die Verfügungsgewalt über die von ihr gehaltenen Token.

## Berechtigungen von Operator, Confirmer und Gateway

Der Operator und das Gateway schlagen die Genesis, die Pins, das Gaslimit und den Builder der Chain vor. Der Confirmer nimmt den Vorschlag an. Von ihm wird erwartet, die Pins und den Genesis-Gateway-Code mit seinem eigenen Build abzugleichen. Die bereitgestellten Skripte schlagen übereinstimmende Werte vor und nehmen den Vorschlag im Namen des Confirmers sofort an.

Der Operator, der Confirmer und das Gateway unterzeichnen `ZkChain`. Sie bilden die Vertrauensbasis der Chain. Für Entscheidungen zur Abwicklung von Ein- und Auszahlungen sind alle drei erforderlich, für die Zahlungsabwicklung der Operator und der Confirmer. `Advance` erteilt ihnen die gemeinsame Berechtigung. Der Builder allein kann die Abwicklungsentscheidungen nicht ausführen.

Auf DevNet betreibt Rome den einzigen Teilnehmer, der all diese Parteien hostet. Rome kann als Operator jeden Ostia-Contract sehen und verfügt über alles, was nötig ist, um im Namen jeder Ostia-Partei zu handeln – einschließlich des Confirmers und des Gateways. Auch die Canton-Konten, die das inzwischen stillgelegte Bridge-Konto erstellt hat, werden dort gehostet (siehe [das Bridge-Konto, erstellt mit einer Wallet-Signatur](#the-bridge-account-made-from-a-wallet-signature)).

**Verwahrung.** Die Gateway-Partei verwahrt die Canton-Token, die die Wrapped Token auf der EVM absichern. Sie wird auf dem Teilnehmer des Operators gehostet. Wer diesen Teilnehmer betreibt – auf DevNet also Rome –, kann die gesperrten Token außerhalb der Auszahlungsregeln bewegen. Dass dem Gateway-Contract ein Admin-Schlüssel fehlt, schränkt die Handlungsfähigkeit der Canton-Partei über ihren Teilnehmer nicht ein. Auf DevNet verwahrt das Gateway nur Test-Token: Bei einem Lauf von Rome am 2026-10-25 wurde festgestellt, dass es 12 TKB hielt, den von Splice bereitgestellten Referenz-Test-Token, gegenüber einem wTKB-Angebot von 12, das jeder auf Ostia einsehen kann. Die ERC-20-Token, die die Twins absichern, liegen im Vault, einem EVM-Contract ohne Owner, den [der Abschnitt zu den Twins](#what-the-twins-trust) beschreibt.

Die Token-Registrierung ist eine weitere Vertrauensentscheidung. Der Operator und das Gateway schlagen die Zuordnung eines Canton-Instruments zu einem EVM-Wrapped-Token vor; der Confirmer nimmt sie an. Das Gateway führt den Daml-Transfercode des registrierten Tokens mit seiner eigenen Berechtigung aus. Die Registrierung eines Tokens bedeutet daher auch, dem Daml-Code seines Registers zu vertrauen.

Token, die direkt an die EVM-Adresse des Gateways gesendet werden, können nicht wiederhergestellt werden. Erhebt ein Token eine Transfergebühr oder überträgt es aus einem anderen Grund einen abweichenden Betrag, wird im Zahlungs-Leg trotzdem der angeforderte Betrag aufgezeichnet. Die [Netzwerk-README](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/network/README.md#the-canton-network) beschreibt das Hosting der Teilnehmer und die Prüfungen bei der Registrierung.

## Worauf die Twins vertrauen

Ein Twin ist die Canton-Entsprechung eines ERC-20-Tokens, das der Vault verwahrt (siehe [Einzahlungen, Auszahlungen und Zahlungen](https://docs.rome.builders/de/canton-zk-evm/deposits-withdrawals-payments.md#canton-twins-of-erc-20-tokens)). Darauf stützt er sich:

* **Die Chain prägt und verbrennt Token über `Advance`.** Nach den Regeln der Chain wird ein Twin innerhalb von `Advance`geprägt, gegen eine Sperrposition, die durch den Beweis festgelegt wurde: eine nachgewiesene Zahlung in einen Vault, die im Chain-Datensatz registriert ist. `Advance` verbrennt einen Twin nur gegen eine vom Inhaber unterzeichnete Einlösungsanfrage. Der Chain-Datensatz legt für jeden Twin die Token-Adresse, die Dezimalstellen und den Regel-Contract fest; eine Sperre für einen anderen Token wird abgelehnt.
* **Der Vault hat keinen Owner.** Es hat keinen Schlüssel, kein Upgrade und keinen Speicher, und es kann nicht dazu gebracht werden, eine ID zu bezahlen, die eine andere Zahlungsart haben könnte. Jeder kann seinen On-Chain-Code mit dem geprüften Build vergleichen.
* **Ein Vault wird von Menschen registriert.** Der Operator und das Gateway schlagen ihn vor, und der Bestätiger akzeptiert ihn, nachdem er den bereitgestellten Code gelesen hat. Was der Contract tut, wird durch diese Prüfung abgesichert.
* **Der Admin des Twins ist die Gateway-Partei.** Nur der Admin kontrolliert die Twin-Operationen `Mint` und `Burn`, daher kann die Gateway-Partei einen Twin auch außerhalb von `Advance`minten oder burnen, ohne Sperre und ohne Redeem-Anfrage. Die Gateway-Partei wird auf Romes Participant betrieben, sodass Rome auf DevNet für sie handeln kann, wie für jede Ostia-Partei, die es betreibt. Sie signiert jeden Twin-Bestand und kann daher die Twins jeder Canton-Partei burnen, minten und verschieben, einschließlich der Twins eines mit der [Bridge](https://docs.rome.builders/de/canton-zk-evm/bridge.md)verbundenen Canton-Wallets, ohne die Signatur dieser Partei. Vor dem Mainnet sollen auch der Operator und der Bestätiger Mint und Burn signieren. Der Explorer zeigt den Bestand jedes Twins im Vergleich zu den vom Vault gehaltenen Twins, sodass jeder sehen kann, ob sie übereinstimmen.
* **Der Registry-Dienst ist ein Hinweis.** Er teilt einem Zahler die Lock-ID und den Vault mit und besitzt keinen Schlüssel. Der Builder und `Advance` prüfen, ob die Bestandteile die ID ergeben; der Zahler prüft die ID selbst (den SHA-256-Hash von `lock,<receiver>,<ref>`) und bezieht die Vault-Adresse aus einer Quelle, der er vertraut. Der Chain-Eintrag, der die registrierten Vaults aufführt, ist nur für Romes Parteien lesbar; auf DevNet ist diese Quelle daher Rome.

## Das Bridge-Konto, das aus einer Wallet-Signatur erstellt wurde

Am 2026-11-17 außer Betrieb genommen. Vom 2026-11-08 bis zum 2026-11-17 konnte die [Bridge](https://docs.rome.builders/de/canton-zk-evm/bridge.md) -Seite mit einer einzigen Wallet-Signatur ein Canton-Konto öffnen: Die Seite wandelte die Signatur in einen Ed25519-Schlüssel um, der der einzige Signaturschlüssel des Kontos war. Der Kontodienst, der beim Öffnen dieser Konten half, wurde eingestellt, und die Seite bietet die Anmeldung nicht mehr an, erzeugt den Schlüssel nicht mehr und speichert ihn auch nicht mehr im Browser (sie löscht, was ein früherer Besuch gespeichert hat). Stattdessen wird die Verbindung mit dem eigenen Canton-Wallet aktiviert, Wallet für Wallet; siehe [Mit Canton entwickeln](https://docs.rome.builders/de/canton-zk-evm/build-with-canton.md#erc-20-twins-on-canton) zu den Voraussetzungen sowie [Bridge](https://docs.rome.builders/de/canton-zk-evm/bridge.md).

Die geöffneten Konten verbleiben mit ihren Beständen auf Canton DevNet, gehostet auf Romes Participant, bis DevNet zurückgesetzt wird. Nichts akzeptiert ihren Schlüssel mehr, sodass niemand – auch Rome nicht – für sie signiert oder Transaktionen übermittelt. Sie enthielten ausschließlich DevNet-Testwerte.

Zur Dokumentation: Was das Konto war:

* **Der Schlüssel wurde allein aus der Signatur abgeleitet.** EIP-712 bindet eine Signatur an die typisierten Daten, nicht an die anfragende Website. Daher konnte jeder, der die Signatur erhielt, den Schlüssel erstellen. Eine Wallet, die dieselbe Signatur nicht mehr erzeugte, konnte das Konto nicht erneut öffnen. Es gab weder Widerruf noch Wiederherstellung.
* **Rome konnte nicht für das Konto signieren, betrieb aber die Infrastruktur, auf der es beruhte.** Rome betrieb den Code, den die Contracts des Kontos verwendeten, den einzigen Node, der das Konto hostete, sowie den Twin-Admin. Daher konnte Rome die Twins, die ein Konto hielt, ohne die Signatur des Inhabers burnen, minten und verschieben. Die dauerhaft geltende Annahme von Auszahlungen durch das Konto ermöglichte es von Romes Parteien betriebenen Entscheidungen, bei einer eingehenden Auszahlung für das Konto zu handeln.

Der Twin-Admin und die Annahme von Auszahlungen gelten nicht nur für das Bridge-Konto: Die Gateway-Partei signiert jeden Twin-Bestand, und ein Canton-Wallet, das sich dafür entscheidet, signiert dieselben beiden Annahmen. Siehe [Worauf die Twins vertrauen](#what-the-twins-trust).

## Was einen Block verhindern kann

Um einen Vorgang aufzunehmen, benötigt der Builder Lesezugriff auf dessen Anfragen, Bedingungen, Annahmen, Zuweisungen, Token-Registrierungen und Gateway-Bestände. Er lässt eine Transaktion aus, deren Canton-Contracts er nicht einsehen kann.

Eine Zuweisung kann zurückgenommen werden, nachdem der Builder sie geprüft hat oder nachdem ein Nachweis erbracht wurde. Eine Token-Registry kann die Abwicklung außerdem nach ihren eigenen Regeln verweigern. Canton lehnt den Block dann ab, und nichts wird festgeschrieben.

Der Builder läuft kontinuierlich und erstellt einen Block, sobald aufnahmefähige Transaktionen anstehen. Der Standardwert im Code ist ein gleichzeitig in Bearbeitung befindlicher Block; auf DevNet sind es bis zu zwei. Bei einer nicht vorhersehbaren Ablehnung, etwa aufgrund einer Regel der Registry, markiert er eine Transaktion nach zwei aufeinanderfolgenden abgelehnten Blöcken als verdächtig und lässt sie für eine Abkühlphase aus, die standardmäßig 10 Minuten dauert. Nach Ende der Abkühlphase versucht er es erneut mit der Transaktion. Bei einem Neustart vergisst er, was er ausgelassen hat.

Der Builder begrenzt die Ausführungsschritte vor dem Erstellen des Nachweises nicht; ein Prover, der nie zurückkehrt, hält ihn an. Die [README des Builders](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/builder/README.md#not-here) führt seine Grenzen auf.

## Was diese Version nicht bietet

* **Dezentralisierung.** Es gibt einen Builder, einen Prover und einen Bestätiger, und Rome betreibt den Builder, Prover, RPC, Explorer, Faucet sowie den Participant, der jede Partei hostet.
* **Zensurresistenz oder erzwungene Aufnahme.** Der RPC und der Builder können eine Transaktion ablehnen oder auslassen, und es gibt keinen anderen Weg, eine Transaktion auf die Chain zu bringen. Der RPC und der Explorer sind von Rome betriebene Ansichten der Chain. Der Indexer des Explorers prüft jeden Eintrag anhand von reth, aber sie sind nicht vertrauenslos.
* **Datenschutz.** Jede EVM-Transaktion ist öffentlich, und Rome sieht als Betreiber des Participants jeden Ostia-Contract. Der Lasttest vom 2026-10-24 erstellte Nachweise für private Transfers im Client und verifizierte sie On-Chain, aber es läuft kein MPC-Netzwerk und nichts wird abgewickelt.
* **Wert oder Audits.** tROME hat keinen Wert. Der Code und ZisK 1.4.0-alpha wurden nicht auditiert.
* **Dauerhaftigkeit.** DevNet kann zurückgesetzt werden, einschließlich der Chain-Historie.

Es gibt keine Vorgaben zum Durchsatz oder zur Blockzeit. Die genauen Versionen und Hashes stehen unter [PINS](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/PINS).

Leser können die Blocknachweise erneut prüfen, aber `BlockRecord` enthält nicht die abgewickelten Legs. Die Schaltfläche „Verify“ im Browser prüft den Nachweis, den Header und die Transaktionen; sie wiederholt nicht die Canton-Prüfungen zur Abwicklung der Legs. [Was bewiesen wird – und was nicht](https://docs.rome.builders/de/canton-zk-evm/what-is-proven.md) erläutert, was ein Nachweis aussagt, und [Status und Roadmap](https://docs.rome.builders/de/canton-zk-evm/status.md) beschreibt die nächsten Schritte.

## Ein Sicherheitsproblem melden

Nutzen Sie die private Meldung von Sicherheitslücken auf GitHub für `canton-zk-evm`: Öffnen Sie im Repository den Tab „Security“ und wählen Sie **Eine Sicherheitslücke melden**. Erstellen Sie für ein Sicherheitsproblem kein öffentliches Issue.

Geben Sie die betroffene Komponente, den Commit, die Schritte zur Reproduktion und das beobachtete Ergebnis an. Fügen Sie den Nachweis oder Block bei, falls er zum Befund gehört. Die [Sicherheitsrichtlinie](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/SECURITY.md) legt den Geltungsbereich fest. Es gibt kein Bug-Bounty-Programm.


---

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