> 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/deposits-withdrawals-payments.md).

# Einzahlungen, Auszahlungen und Zahlungen

Wie das Gateway EVM-Einzahlungen, -Auszahlungen und -Zahlungen mit ihren Canton-Gegenstücken verknüpft und wie ERC-20-Zwillinge und Canton Coin in beide Richtungen bewegt werden.

Das Gateway ist ein EVM-Vertrag, der im Genesis-Block der Chain enthalten ist. Es hält fest, was Canton für einen Block tun soll. Jede Anfrage ist ein Leg. Der Proof des Blocks bindet den Zustand des Gateways ein, einschließlich des Hashes der Legs in der Reihenfolge, in der sie aufgezeichnet wurden.

Einzahlungen, Auszahlungen und Zahlungen sind auf Ostia DevNet verfügbar, das von Rome mit Testparteien betrieben wird. Sie wurden erstmals in der lokalen Demo vom 2026-10-05 ausgeführt. Am 2026-10-25 wurde ein Canton-Test-Token, TKB (das Referenz-Test-Token, das Splice bereitstellt), beim Gateway registriert. Seine Wrapped-Form, wTKB, ist auf Ostia unter `0x294d3049874526910a69f6b61da14d10a8b1b3af`zu finden. Seit dem 2026-11-08 kannst du Canton Coin selbst über die [Bridge](https://docs.rome.builders/de/canton-zk-evm/bridge.md) -Seite des Explorers einzahlen und abheben; siehe [Live auf DevNet](#live-on-devnet) weiter unten.

Seit dem 2026-10-29 unterstützt das Gateway außerdem Canton-Assets in beide Richtungen: Ein ERC-20 kann auf Canton als Twin abgebildet werden, und Canton Coin kann auf Ostia übertragen und wieder zurückgeführt werden. Siehe [Canton-Twins von ERC-20-Token](#canton-twins-of-erc-20-tokens) und [Canton Coin](#canton-coin).

Die meisten Links auf dieser Seite führen zum Release `v0.1.0`; der Link zur Gateway-README führt zum Main-Branch. DevNet führt jetzt Code aus dem Main-Branch des Repositorys mit dem Daml-Paket 0.5.0 aus, und für die Legs gelten dieselben Regeln. [Status](https://docs.rome.builders/de/canton-zk-evm/status.md) nennt den Commit. Was du auf Basis der Legs entwickeln kannst, erfährst du unter [Mit Canton entwickeln](https://docs.rome.builders/de/canton-zk-evm/build-with-canton.md). Lies die vollständige [Gateway-README](https://github.com/rome-protocol/canton-zk-evm/blob/main/gateway/README.md) und die [Daml-Schnittstelle](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/daml/README.md).

| Leg        | Gateway-Aufruf                   | EVM-Aktion                                                  | Canton-Aktion in `Advance`                                                           |
| ---------- | -------------------------------- | ----------------------------------------------------------- | ------------------------------------------------------------------------------------ |
| Einzahlung | `claim(id, token, amount)`       | Präge Wrapped-Token für den Aufrufer.                       | Führe die Zuteilung des Einzahlers an das Gateway aus.                               |
| Auszahlung | `withdraw(token, amount, party)` | Verbrenne die Wrapped-Token des Aufrufers.                  | Zahle den Canton-Token aus dem Verwahrbestand des Gateways an die angegebene Partei. |
| Zahlung    | `pay(id, token, to, amount)`     | Übertrage einen ERC-20 vom Zahler an den Zahlungsempfänger. | Führe die Zuteilung aus, die in den vereinbarten Zahlungsbedingungen festgelegt ist. |

## Live auf DevNet

Eine Einzahlung, eine Zahlung und eine Auszahlung wurden am 2026-10-25 zweimal auf DevNet ausgeführt:

| Ablauf                                                           | Einzahlung                                | Zahlung                                                                                                            | Auszahlung                                          |
| ---------------------------------------------------------------- | ----------------------------------------- | ------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------- |
| Erster Durchlauf, 08:08 bis 08:10 UTC                            | Block 780: 10 TKB hinein, 10 wTKB hinaus. | Block 783: V zahlte U 1 WtROME (Wrapped tROME, ein ERC-20 auf Ostia) im Gegenzug für Us Zuteilung von 10 TKB an V. | Block 784: 4 wTKB verbrannt, 4 TKB an U ausgezahlt. |
| Zweiter Durchlauf, 11:31 bis 11:34 UTC, mit dem Daml-Paket 0.2.0 | Block 1465.                               | Block 1471.                                                                                                        | Block 1473.                                         |

Jeder Leg erfolgte in einem eigenen Block. In jedem Fall waren der Blockdatensatz und die Änderung des Guthabens ein Canton-Update. Nach dem zweiten Durchlauf betrug der wTKB-Bestand 12, was jeder auf Ostia nachlesen kann. Beim Durchlauf von Rome wurde geprüft, dass das Gateway anschließend 12 TKB auf Canton hielt – entsprechend diesem Bestand. Seit dem 25.10.2026 zeigt der Explorer dies ebenfalls an: Auf der Token-Seite von wTKB gibt es eine Karte „Auf Canton gedeckt“ mit einem Verwahrbestand von 12 TKB neben einem Bestand von 12 wTKB.

U und V sind Testparteien, die Rome erstellt hat und auf seinem eigenen Participant betreibt; Rome hat jeden Schritt ausgeführt. Im Explorer können Sie die Legs verfolgen: Öffnen Sie [`/legs`](https://ostia.devnet.romeprotocol.xyz/legs) für die Liste oder die Seite eines Blocks, um die darin enthaltenen Legs anzuzeigen. Bei einer Auszahlung wird die Canton-Partei angegeben, an die sie gezahlt wurde. wTKB ist ein gewöhnlicher ERC-20-Token mit 10 Dezimalstellen, daher werden sein Bestand und seine Guthaben wie bei jedem anderen Token angezeigt (siehe [Explorer](https://docs.rome.builders/de/canton-zk-evm/explorer.md#legs-and-custody)).

Rome führt alle 10 Minuten eine Einzahlung, eine Zahlung und eine Auszahlung aus. Ihr Status wird alle 30 Sekunden überwacht.

Um Canton Coin selbst einzuzahlen und abzuheben, verbinden Sie Ihre Canton-Wallet auf der Seite [Bridge](https://docs.rome.builders/de/canton-zk-evm/bridge.md) des Explorers, sobald diese für Ihre Wallet aktiviert ist. Auf der Bridge-Seite werden außerdem tROME und TKA für Canton gesperrt (ein Gateway- `pay` in den Tresor). Die anderen Zahlungen und TKB-Einzahlungen auf dieser Seite werden von Romes Testparteien ausgeführt.

## Einen Canton-Token einzahlen

Der Einzahler weist dem Gateway einen Canton-Token zu, wobei der Operator als Executor fungiert. Der Einzahler signiert eine `DepositRequest` mit der Einzahlungs-ID, der zum Einlösen berechtigten EVM-Adresse und der Zuweisung. Die Einzahlungs-ID ist der SHA-256-Hash von `deposit,<depositor's party id>,<label>`, sodass nur der Einzahler eine ID aus seiner eigenen Party-ID erstellen kann.

Diese EVM-Adresse ruft `claim`auf. Das Gateway mintet Token für den Aufrufer und zeichnet den Einzahlungs-Leg auf. Der Empfänger benötigt tROME für Gas. Der Builder ordnet den Leg der Anfrage, dem registrierten Token und der Zuweisung zu.

`Advance` führt die Zuweisung aus und überträgt sie in die Verwahrung des Gateways; zugleich wird der Block festgeschrieben, in dem die Wrapped Token gemintet wurden. Ein Wrapped Token hat 10 Dezimalstellen und entspricht damit den Canton-Beträgen. Die Umrechnung zwischen den beiden Beträgen ist exakt und erfolgt ohne Rundung.

## An eine Canton-Partei auszahlen

Der Inhaber ruft `withdraw` mit dem Wrapped Token, dem Betrag und der vollständigen Canton-Party-ID auf. Das Gateway verbrennt die Wrapped Token und zeichnet den Empfänger im Leg auf.

Der Empfänger muss eine `WithdrawalAcceptance`signiert haben. Sie bleibt aktiv, bis sie archiviert wird. Außerdem benötigt der Builder ausreichend nicht gesperrte Gateway-Guthaben des registrierten Instruments. Sind diese Bedingungen nicht erfüllt, lässt er die Transaktion aus.

`Advance` zahlt über die Transfer-Factory der Token-Registry an den Empfänger. Die Canton-Übertragung und der Block mit der Verbrennung werden gemeinsam festgeschrieben. Wie in der [README des Builders](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/builder/README.md).

## Eine Zahlung an eine Zuweisung binden

Der Canton-Zahler weist dem Canton-Zahlungsempfänger einen Canton-Token zu. Die beiden Parteien signieren `DvpTerms` mit der Zuweisung, der Zahlungs-ID, dem EVM-Token, dem EVM-Zahlungsempfänger und dem Betrag. Die Zahlungs-ID ist der SHA-256-Hash des UTF-8-Texts `<Canton payer's party id>,<Canton payee's party id>,<label>`, dargestellt als Hexadezimalzahl in Kleinbuchstaben. Die Bedingungen weisen jede andere ID zurück.

Ein EVM-Zahler genehmigt das Gateway und ruft `pay` mit der vereinbarten ID, dem Token, dem Empfänger und dem Betrag auf. Das Gateway überträgt den ERC-20-Token vom EVM-Zahler an den EVM-Zahlungsempfänger und zeichnet den Zahlungs-Leg auf. In der Demo wurde der Zahler vom Canton-Zahlungsempfänger kontrolliert; das Protokoll setzt diese Beziehung nicht voraus. `Advance` verwendet die signierten Bedingungen, um die Zuweisung vom Canton-Zahler an den Canton-Zahlungsempfänger auszuführen. Die ERC-20-Zahlung und die Canton-Zahlung werden gemeinsam festgeschrieben, sodass keine der beiden ohne die andere endgültig ist.

Bei einer einfachen ERC-20-Übertragung wird kein Leg aufgezeichnet. Selbst eine Übertragung desselben Tokens an denselben Zahlungsempfänger im selben Block kann nicht als Ersatz für `pay`dienen. Der [Zahlungsablauf des Designs](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/docs/DESIGN.md#the-flows) erläutert diese Verknüpfung.

## Canton-Pendants von ERC-20-Token

Ein Pendant ist die Canton-Form eines ERC-20-Tokens, der auf Ostia existiert. Es handelt sich um einen CIP-0056-Token, den Canton-Token-Standard, mit der Instrument-ID `erc20:<token address>` und wird gemäß dem Transfer des Token-Standards zwischen Parteien bewegt, deren Teilnehmer Ostia-Twin geprüft haben. Das bedeutet heute Konten bei Teilnehmern auf Rome. Jeder Twin entspricht genau einem ERC-20-Token, den der Vault hält. TKA und WtROME (wrapped tROME) haben Twins auf DevNet.

**Sperren.** Sie zahlen den ERC-20-Token über ein einfaches Gateway mit `pay`in den Vault ein und geben die Canton-Partei an, die den Twin halten soll. Vor der Zahlung teilen Sie dem Twin-Registry-Dienst den Empfänger und einen `ref` Ihrer Wahl mit. Er gibt die Lock-ID zurück, den SHA-256-Hash von `lock,<receiver>,<ref>`. Der Block verbucht die Zahlung im Vault und prägt in derselben Canton-Transaktion die gleiche Menge des Twins für den Empfänger. Anschließend entspricht der Bestand des Twins dem Bestand im Vault.

**Einlösen.** Der Inhaber signiert eine Einlöseanforderung auf Canton. Anschließend wird `release` mit demselben `ref`auf dem Vault aufgerufen. Der Vault zahlt den ERC-20-Token an die in der Anforderung angegebene EVM-Adresse aus, und der Twin wird im selben Block verbrannt. Canton führt eine Auszahlung nur aus, wenn eine passende Einlöseanforderung vorliegt.

Nach den Regeln der Chain wird ein Twin nur in `Advance`geprägt und zwar nur gegen eine nachgewiesene Zahlung an einen registrierten Vault. Der Administrator des Twins, die Gateway-Partei, kann heute außerdem selbstständig prägen und verbrennen. [Vertrauensmodell und Grenzen](https://docs.rome.builders/de/canton-zk-evm/trust-model.md#what-the-twins-trust) erläutert, worauf das beruht.

| Schritt  | Vorgang                                                                | Canton-Aktion in `Advance`         |
| -------- | ---------------------------------------------------------------------- | ---------------------------------- |
| Sperren  | Ein Gateway `pay` an den Vault.                                        | Den Twin für den Empfänger prägen. |
| Einlösen | `release` auf dem Vault, gegen die signierte Anforderung des Inhabers. | Den Twin des Inhabers verbrennen.  |

Am 29.10.2026 wurde eine Sperre über 5 TKA für eine Canton-Partei in Block 28389 aufgenommen. Die Partei hielt daraufhin 5 Twin. Sie übertrug 2 Twin an eine zweite Partei auf Canton, und die Einlösung dieser 2 Twin wurde in Block 28392 aufgenommen. Danach betrugen sowohl der Bestand des Twins als auch das Guthaben des Vaults 3. Die Seite [`/twins`](https://ostia.devnet.romeprotocol.xyz/twins) des Explorers zeigt den Bestand jedes Twins neben dem Guthaben des Vaults an (siehe [Explorer](https://docs.rome.builders/de/canton-zk-evm/explorer.md#twins-and-canton-assets)).

Eine Sperre ist nur für einen Empfänger möglich, der Twins akzeptiert hat. Eine Partei signiert einmalig, dass sie Twins akzeptiert, und der Builder erstellt Sperren nur für solche Parteien. Wenn Sie auf der Seite [Bridge](https://docs.rome.builders/de/canton-zk-evm/bridge.md) eine Canton-Wallet verbinden, signiert sie diese Zustimmung im Rahmen ihrer Opt-in-Aktion. So können Sie den gesamten Ablauf mit einer eigenen Partei durchführen.

## Canton Coin

Canton Coin gelangt über dieselbe Gateway-Einzahlung wie jeder Canton-Token zu Ostia. Der Wrapped Token CC (`0x4db3dea7c13116961fd3e438542ccfcca61a7547`, 10 Dezimalstellen; in älteren Einträgen als wCC bezeichnet) ist bei der Factory registriert, die der Scan-Proxy des Validators angibt. Eine Partei weist Canton Coin dem Gateway zu und signiert eine gekennzeichnete Einzahlungsanforderung. Der Empfänger beansprucht CC auf Ostia, und bei einer Auszahlung wird Canton Coin zurückgezahlt. Für Canton Coin ist eine zusätzliche Eingabe erforderlich: ein Auswahlkontext, den der Scan-Proxy bereitstellt. Der Builder ruft ihn ab, bevor er den Block nachweist.

Am 29.10.2026 zahlte eine Partei über Block 28473 5 Canton Coin ein. Damit hielt sie 15, das Gateway 5 und der CC-Bestand betrug 5. Die Auszahlung in Block 28474 setzte alle drei Werte zurück: 20, 0 und 0. Für diese Transfers fielen auf DevNet keine Gebühren an.

## Was der Nachweis festlegt

Jeder Vorgang hält gegebenenfalls Typ, ID, Token, Konto, Betrag und Canton-Partei fest. Das Gateway bildet in dieser Reihenfolge einen Hash über die Vorgänge. `Advance` prüft, ob die angehängten Vorgänge den Hash ergeben, der im nachgewiesenen Gateway-Zustand gespeichert ist. Fehlt ein Vorgang, ist einer zusätzlich vorhanden, wurde die Reihenfolge geändert oder ein Vorgang verändert, schlägt die Transaktion fehl. Die Prüfung gilt auch für Blöcke ohne Vorgänge.

Der Nachweis des Blocks reserviert die Canton-Zuweisung nicht. Der Sender kann die Zuweisung vor der Abwicklung weiterhin zurücknehmen. Geschieht dies nach dem Nachweis, lehnt Canton `Advance` und reth kehrt zum letzten bestätigten Block zurück. Derselbe nachgewiesene Block kann nicht erneut ohne seinen entfernten Leg eingereicht werden. Beim nächsten Build wird die Zahlung ausgelassen, wie in [Lauf 4](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/demo/README.md#results).

## Token- und Verwahrungsgrenzen

Wer die Canton-Token verwahrt und welche Token-Verhaltensweisen das Gateway nicht abdeckt, wird in [Vertrauensmodell und Grenzen](https://docs.rome.builders/de/canton-zk-evm/trust-model.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/deposits-withdrawals-payments.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.
