> 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/build-on-ostia.md).

# Auf Ostia entwickeln

Stelle einen Solidity-Contract auf Ostia DevNet mit Foundry oder Hardhat bereit, verifiziere ihn und stelle mit viem oder ethers eine Verbindung her.

Ostia ist eine EVM-Chain, daher funktionieren die Tools, die Sie bereits verwenden, auch damit. Ein paar Dinge sind anders; siehe [Unterschiede zu Ethereum](https://docs.rome.builders/de/canton-zk-evm/evm-differences.md). Auf dieser Seite erfahren Sie, wie Sie einen Vertrag bereitstellen und verifizieren, Ereignisse auslesen und sehen, wann Ihre Transaktion auf Canton endgültig ist. Sie benötigen eine Adresse mit etwas tROME. Der [Faucet](https://docs.rome.builders/de/canton-zk-evm/devnet.md#get-trome) gibt 1 tROME aus, und [Ostia DevNet](https://docs.rome.builders/de/canton-zk-evm/devnet.md) enthält die Netzwerkdetails.

## Mit Foundry bereitstellen

Diese Befehle wurden mit Foundry 1.8 getestet. Führen Sie zuerst `foundryup` (oder `brew upgrade foundry`) aus. Arbeiten Sie in einem Foundry-Projekt (mit`forge init ostia-counter` wird eines erstellt, das einen Vertrag `Counter` enthält) und speichern Sie den aufgeladenen Schlüssel in `PRIVATE_KEY`. `forge init` schreibt bereits eine `[profile.default]` Tabelle in `foundry.toml`. Fügen Sie darunter eine Zeile ein, damit Bereitstellung und Verifizierung mit denselben Einstellungen kompiliert werden:

```toml
[profile.default]
# ...die von forge init geschriebenen Zeilen bleiben unverändert
evm_version = "london"
```

```sh
export RPC=https://ostia.devnet.romeprotocol.xyz/rpc
forge create src/Counter.sol:Counter \
  --rpc-url $RPC --private-key $PRIVATE_KEY --broadcast
```

Diese wurden bisher auf Ostia ausgeführt:

| Was                                                                                         | Compiler              | EVM-Version |
| ------------------------------------------------------------------------------------------- | --------------------- | ----------- |
| Das [Mixed-Load-Kit](https://github.com/rome-protocol/canton-zk-evm/tree/v0.1.0/load/mixed) | solc 0.8.17           | `london`    |
| Uniswap V2                                                                                  | solc 0.5.16 und 0.6.6 | `istanbul`  |
| Merces-Verträge von TACEO                                                                   | solc 0.8.37           | `osaka`     |

Auf der Ostia-Chain wurden seit dem 28.10.2026 alle Forks bis einschließlich Osaka ausgeführt. Daher akzeptiert die Chain Code, der für jedes EVM-Ziel bis einschließlich `osaka`erstellt wurde. Die Ziele in der Tabelle sind diejenigen, die bereits ausgeführt wurden; `london` ist eine sichere Wahl. Ein nach Osaka hinzugefügter Opcode wird nicht ausgeführt.

## Mit Foundry verifizieren

Der Explorer verwendet die Etherscan-API, daher `forge verify-contract` mit dem Etherscan-Verifier funktioniert. Der API-Schlüssel kann ein beliebiger Text sein.

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

Der Explorer verarbeitet 30 Verifizierungen pro Stunde von einem Client. Wenn du dieses Limit überschreitest, warte und sende die Anfrage erneut. Bei einem verifizierten Vertrag wird der Quellcode auf der Vertragsseite des Explorers angezeigt.

## Einen großen Vertrag verifizieren

Ein Vertrag mit vielen Quelldateien kann mit HTTP `413`abgelehnt werden. Der vorgeschaltete Proxy des Explorers verarbeitet etwa 300 KB pro Anfrage, und forge sendet seine Eingabe URL-kodiert, wodurch sie größer als die Dateien ist. `POST /api/verify` verarbeitet dieselbe Eingabe wie Standard-JSON, das kleiner ist. Die Proxy-Begrenzung gilt für jede Anfrage, daher wird auch ein JSON-Body mit mehr als 300 KB abgelehnt. Das Kit-Skript [`verify-large.mjs`](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/load/mixed/scripts/verify-large.mjs) übernimmt diese Aufgabe. Es hat das 265 KB große Standard-JSON der Merces-Verträge übermittelt, das forge nicht senden konnte. Um es zu verwenden, rufe zuerst das Standard-JSON aus deinem Foundry-Projekt ab und kopiere es in den Ordner des Kits (`load/mixed` in einem Klon des Repositorys):

```sh
forge verify-contract <address> <path:Name> --show-standard-json-input > std.json
cp std.json <your clone of canton-zk-evm>/load/mixed/
```

Installiere dann im Ordner des Kits die Pakete mit `npm ci` und führe das Skript aus. Es verwendet die Adresse des Explorers aus der `config.json`des Kits. (Mit Docker erledigt `./run.sh node scripts/verify-large.mjs ...` dasselbe.)

```sh
node scripts/verify-large.mjs <address> <path:Name> std.json <compiler> <runs> <evm> <constructor-args|->
```

Gib den Compiler als vollständige Versionszeichenfolge an. Für einen `Counter` -Vertrag, der mit solc 0.8.28, aktiviertem Optimierer mit 200 Durchläufen und der EVM-Version `london` ohne Konstruktorargumente erstellt wurde:

```sh
node scripts/verify-large.mjs 0xC249f8828EAe40Ad6a77178e4de88049ed5e962f \
  src/Counter.sol:Counter std.json v0.8.28+commit.7893614a 200 london -
```

Der Explorer kompiliert mit den Einstellungen in std.json, die forge aus deiner foundry.toml erstellt. Daher wird der Vertrag mit der Optimierereinstellung verifiziert, mit der er erstellt wurde. Das Skript übermittelt die Verifizierungsanfrage und fragt dann `GET /api/verify/<guid>` ab, bis die Antwort `Pass` oder `Fail`lautet. Es gilt dasselbe Limit von 30 pro Stunde.

## Mit Hardhat bereitstellen

Diese Anleitung gilt für Hardhat 2 (Hardhat 3 benötigt eine ESM-Konfiguration). Die Schritte beginnen mit einem leeren Ordner und wurden mit Hardhat 2.29 auf Node 22 gegen Ostia DevNet ausgeführt. Lege den aufgeladenen Schlüssel in `PRIVATE_KEY`ab, zusammen mit seinem `0x`.

```sh
mkdir ostia-hardhat && cd ostia-hardhat
npm init -y
npm i -D hardhat@2 @nomicfoundation/hardhat-toolbox@hh2
mkdir contracts scripts
```

`npx hardhat init` stellt seine Fragen im Terminal und schreibt einen eigenen Beispielvertrag. Erstellen Sie daher die drei Dateien von Hand. Zuerst der Vertrag:

```solidity
// contracts/Counter.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;

contract Counter {
    uint256 public number;

    function setNumber(uint256 newNumber) public {
        number = newNumber;
    }

    function increment() public {
        number++;
    }
}
```

Die Konfiguration. Ihre `solidity` Version stimmt mit der Pragma-Direktive überein:

```js
// hardhat.config.js
require("@nomicfoundation/hardhat-toolbox");

module.exports = {
  solidity: { version: "0.8.17", settings: { evmVersion: "london" } },
  networks: {
    ostia: {
      url: "https://ostia.devnet.romeprotocol.xyz/rpc",
      chainId: 770101,
      accounts: [process.env.PRIVATE_KEY],
      timeout: 120000,
    },
  },
};
```

Das Deploy-Skript:

```js
// scripts/deploy.js
const hre = require("hardhat");

async function main() {
  const counter = await hre.ethers.deployContract("Counter");
  await counter.waitForDeployment();
  console.log("Counter deployed to", await counter.getAddress());
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});
```

```sh
npx hardhat run scripts/deploy.js --network ostia
```

Die Ausgabe lautet `Counter deployed to 0x...`. Das `timeout` gilt für jede Anfrage. Bei einem Deploy wird außerdem auf den Transaktionsbeleg gewartet, der erst nach der Finalität von Canton verfügbar ist (siehe unten). Bei einem Test am 25.10.2026 dauerte der Befehl 20 bis 23 Sekunden; die meiste Zeit entfiel auf das Warten, bis der Block endgültig bestätigt war.

## Mit Hardhat verifizieren

Fügen Sie den Explorer in der obigen Konfiguration als benutzerdefinierte Chain zu `@nomicfoundation/hardhat-verify`hinzu, das `hardhat-toolbox` enthält. Als API-Schlüssel kann beliebiger Text verwendet werden. Die Abfrage wurde mit Hardhat 2.29.1 und hardhat-verify 2.1.3 anhand eines bereits verifizierten Vertrags getestet: Das Plugin fand die benutzerdefinierte Chain, fragte die API des Explorers ab und meldete „already verified“. Eine neue Übermittlung wurde nicht getestet. Teilen Sie uns daher bitte mit, falls es nicht funktioniert. Das Plugin gibt eine Deprecation-Warnung zu API-Schlüsseln pro Netzwerk aus. Die Warnung ist erwartungsgemäß: Behalten Sie den netzwerkspezifischen `apiKey` weiter unten bei, da die Form mit einer einzelnen Zeichenfolge auf dieser Chain fehlschlägt („The selected network (ostia) is wrong“).

```js
// hardhat.config.js, neben solidity und networks
etherscan: {
  apiKey: { ostia: "any" },
  customChains: [
    {
      network: "ostia",
      chainId: 770101,
      urls: {
        apiURL: "https://ostia.devnet.romeprotocol.xyz/api",
        browserURL: "https://ostia.devnet.romeprotocol.xyz",
      },
    },
  ],
},
```

```sh
npx hardhat verify --network ostia <address> <constructor arguments>
```

Behalte dieselben `solidity` Einstellungen bei, einschließlich `evmVersion`, wie bei der Bereitstellung. Der Explorer kompiliert mit den vorgegebenen Einstellungen. Es gilt dieselbe Begrenzung von 30 Verifizierungen pro Stunde.

## viem und ethers

Eine viem-Chain-Definition:

```ts
import { createPublicClient, defineChain, http } from "viem";

export const ostia = defineChain({
  id: 770101,
  name: "Ostia DevNet",
  nativeCurrency: { name: "tROME", symbol: "tROME", decimals: 18 },
  rpcUrls: { default: { http: ["https://ostia.devnet.romeprotocol.xyz/rpc"] } },
  blockExplorers: {
    default: { name: "Ostia explorer", url: "https://ostia.devnet.romeprotocol.xyz" },
  },
});

const client = createPublicClient({ chain: ostia, transport: http() });
```

Ein ethers-Provider:

```js
import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider(
  "https://ostia.devnet.romeprotocol.xyz/rpc",
  { chainId: 770101, name: "ostia-devnet" },
  { polling: true },
);
```

Der RPC unterstützt weder WebSockets noch Filter. Daher benötigt ethers v6 `{ polling: true }` um Ereignisse zu verfolgen (`contract.on`, oder `provider.on` mit einem Filter). Ein Receipt ist erst verfügbar, wenn der Block finalisiert ist. Plane daher beim Festlegen eines Timeouts etwa 10 bis 30 Sekunden ein. Sende die Transaktionen eines Kontos der Reihe nach; siehe [Unterschiede zu Ethereum](https://docs.rome.builders/de/canton-zk-evm/evm-differences.md#nonces-and-the-order-of-sends).

In viem benötigt `multicall` Multicall3 auf der Chain. Ostia hat es an der üblichen Adresse. Füge es daher der Chain-Definition hinzu: `contracts: { multicall3: { address: "0xcA11bde05977b3631167028862bE2a173976CA11" } }` (siehe [Unterschiede zu Ethereum](https://docs.rome.builders/de/canton-zk-evm/evm-differences.md#the-standard-contracts)).

## Receipts und Ereignisse

Der RPC zeigt nur Blöcke an, die auf Canton finalisiert sind. Nachdem du eine Transaktion gesendet hast, `eth_getTransactionReceipt` liefert nichts zurück, bis der Block finalisiert ist. Das dauert etwa 10 bis 30 Sekunden. Wenn du in einem Tool ein Receipt-Timeout festlegst, plane Zeit für den Nachweis und die Bestätigung durch Canton ein.

Es gibt weder WebSockets noch `eth_subscribe`, und kein `eth_newFilter`. Um Ereignisse zu verfolgen, fragen Sie `eth_getLogs` mit dem Blockbereich seit Ihrer letzten Abfrage ab. Eine Abfrage alle paar Sekunden reicht aus. In den 24 Stunden bis zum 25.10.2026, 01:34 UTC, betrug der mediane Abstand zwischen Blöcken bei ausgelasteter Chain 16,6 Sekunden; bei geringer Auslastung erzeugt die Chain einmal pro Minute einen leeren Block. Beschränken Sie sich auf 300 Aufrufe pro Minute.

## Ihre Transaktion auf Canton ansehen

1. Öffnen Sie Ihre Transaktion im Explorer unter `/tx/<hash>`.
2. Folgen Sie dem Link zum Block, `/block/<number>`.
3. Die Blockseite zeigt das Canton-Update, das den Datensatz des Blocks enthält, den Zeitpunkt, zu dem Canton ihn aufgezeichnet hat, sowie die Beweisdaten neben den erwarteten Werten des Explorers.
4. Klicken Sie auf **Verifizieren**. Ihr Browser führt die Beweisprüfung selbst durch – anhand des Beweises, des Headers und der Transaktionen, die der Explorer bereitstellt. Die Schaltfläche ist ausgegraut, solange der Block noch bewiesen wird.

Dieselben Daten sind auch über die API verfügbar, zum Beispiel über `GET /api/blocks/<number>` und `GET /api/canton/updates/<update id>`.

## Ein größeres Beispiel

Der Ordner [`load/mixed`](https://github.com/rome-protocol/canton-zk-evm/tree/v0.1.0/load/mixed) stellt eine Reihe von Contracts bereit und erzeugt darüber gemischten Datenverkehr: ERC-20, ERC-721, ERC-1155, einen zugriffsbeschränkten ERC-3643-Token, Uniswap V2 und die privaten Transfer-Contracts Merces von TACEO (ihre Beweise werden on-chain geprüft; es wird nichts abgewickelt). Die [README-Datei](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/load/mixed/README.md) enthält die Befehle. Das Kit verifiziert außerdem jeden Contract, den es im Explorer bereitstellt. Mit der mitgelieferten Konfiguration benötigt es etwa 12.000 tROME, deutlich mehr, als der Faucet bereitstellt. Führen Sie es daher auf Ihrer eigenen Ostia-Instanz aus (siehe [Eigene Ostia-Instanz ausführen](https://docs.rome.builders/de/canton-zk-evm/run-it-locally.md#load-it-with-a-realistic-mix)). Der Compiler-Download läuft nur unter Linux x64. Bei einem Durchlauf am 24.10.2026 wurden innerhalb einer Stunde 13.496 Transaktionen gesendet, und alle wurden finalisiert. Die [Ergebnisse](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/load/mixed/RESULTS-2026-10-24.md) zeigen, was gemessen wurde und was nicht funktioniert hat.


---

# 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/build-on-ostia.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.
