> 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/id/canton-zk-evm/build-on-ostia.md).

# Bangun di Ostia

Deploy kontrak Solidity di Ostia DevNet dengan Foundry atau Hardhat, verifikasi kontrak tersebut, lalu hubungkan dengan viem atau ethers.

Ostia adalah chain EVM, jadi alat yang sudah Anda gunakan dapat digunakan di sini. Ada beberapa perbedaan; lihat [Perbedaan dari Ethereum](https://docs.rome.builders/id/canton-zk-evm/evm-differences.md). Halaman ini menunjukkan cara men-deploy dan memverifikasi kontrak, membaca event, serta mengetahui kapan transaksi Anda menjadi final di Canton. Anda memerlukan alamat yang memiliki sejumlah tROME. Faucet [faucet](https://docs.rome.builders/id/canton-zk-evm/devnet.md#get-trome) memberikan 1 tROME, dan [Ostia DevNet](https://docs.rome.builders/id/canton-zk-evm/devnet.md) berisi detail jaringannya.

## Deploy dengan Foundry

Perintah ini telah diuji dengan Foundry 1.8. Jalankan `foundryup` (atau `brew upgrade foundry`) terlebih dahulu. Kerjakan di dalam proyek Foundry (`forge init ostia-counter` akan membuatnya, dengan kontrak `Counter` ) dan simpan kunci yang telah didanai di `PRIVATE_KEY`. `forge init` sudah menulis tabel `[profile.default]` di dalam `foundry.toml`. Tambahkan satu baris di bawahnya agar proses deploy dan verifikasi menggunakan pengaturan kompilasi yang sama:

```toml
[profile.default]
# ...biarkan baris yang ditulis forge init apa adanya
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
```

Sejauh ini, hal-hal berikut telah dijalankan di Ostia:

| Apa                                                                                         | Kompiler              | Versi EVM  |
| ------------------------------------------------------------------------------------------- | --------------------- | ---------- |
| Kit [campuran beban](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 dan 0.6.6 | `istanbul` |
| Kontrak Merces dari TACEO                                                                   | solc 0.8.37           | `osaka`    |

Chain Ostia telah menjalankan setiap fork hingga Osaka sejak 2026-10-28, sehingga chain menerima kode yang dibuat untuk target EVM apa pun hingga `osaka`. Target dalam tabel adalah yang telah dijalankan; `london` adalah pilihan yang aman. Opcode yang ditambahkan setelah Osaka tidak akan berjalan.

## Verifikasi dengan Foundry

Explorer ini menggunakan API Etherscan, sehingga `forge verify-contract` dapat digunakan dengan verifier Etherscan. Kunci API dapat berupa teks apa pun.

```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
```

Explorer menerima 30 verifikasi per jam dari satu klien. Jika melebihi batas tersebut, tunggu lalu kirim permintaan lagi. Kontrak yang telah diverifikasi menampilkan kode sumbernya di halaman kontrak explorer.

## Verifikasi kontrak berukuran besar

Kontrak dengan banyak berkas sumber dapat ditolak dengan HTTP `413`. Proksi depan explorer menerima sekitar 300 KB per permintaan, dan forge mengirim input dalam format URL-encoded, yang ukurannya lebih besar daripada berkasnya. `POST /api/verify` menerima input yang sama dengan JSON standar, yang ukurannya lebih kecil. Batas proksi berlaku untuk setiap permintaan, jadi isi JSON yang melebihi 300 KB juga akan ditolak.  [`verify-large.mjs`](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/load/mixed/scripts/verify-large.mjs) mengerjakan hal ini. Skrip tersebut mengirim JSON standar kontrak Merces berukuran 265 KB, yang tidak dapat dikirim forge. Untuk menggunakannya, ambil dulu JSON standar dari proyek Foundry Anda, lalu salin ke folder kit (`load/mixed` dalam klona repositori):

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

Kemudian, di folder kit, instal paket-paketnya dengan `npm ci` dan jalankan skrip. Skrip mengambil alamat explorer dari `config.json`milik kit. (Dengan Docker, `./run.sh node scripts/verify-large.mjs ...` melakukan hal yang sama.)

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

Masukkan compiler sebagai string versi lengkap. Untuk kontrak `Counter` yang dibuat dengan solc 0.8.28, optimizer aktif pada 200 iterasi, versi EVM `london` dan tanpa argumen konstruktor:

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

Explorer mengompilasi dengan pengaturan di dalam std.json, yang ditulis forge berdasarkan foundry.toml Anda, sehingga kontrak diverifikasi dengan pengaturan optimizer yang digunakan saat kontrak dibuat. Skrip mengirim permintaan verifikasi, lalu meminta `GET /api/verify/<guid>` hingga responsnya adalah `Pass` atau `Fail`. Batas 30 per jam juga berlaku.

## Deploy dengan Hardhat

Panduan ini ditujukan untuk Hardhat 2 (Hardhat 3 memerlukan konfigurasi ESM). Langkah-langkah ini dimulai dari folder kosong dan dijalankan dengan Ostia DevNet menggunakan Hardhat 2.29 pada Node 22. Simpan kunci yang memiliki saldo di `PRIVATE_KEY`, dengan awalan `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` mengajukan pertanyaan di terminal dan menulis contoh kontraknya sendiri, jadi buat ketiga file secara manual. Pertama, kontraknya:

```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++;
    }
}
```

Konfigurasinya. Versi `solidity` harus cocok dengan pragma:

```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,
    },
  },
};
```

Skrip deploy:

```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
```

Perintah ini mencetak `Counter deployed to 0x...`. `timeout` berlaku untuk setiap permintaan. Proses deploy juga menunggu tanda terimanya, yang baru diterima setelah finalitas Canton (lihat di bawah). Dalam pengujian pada 2026-10-25, perintah ini memerlukan waktu 20 hingga 23 detik, sebagian besar untuk menunggu blok mencapai finalitas.

## Verifikasi dengan Hardhat

Tambahkan penjelajah blok sebagai rantai khusus ke `@nomicfoundation/hardhat-verify`, yang `hardhat-toolbox` sertakan, dalam konfigurasi di atas. Kunci API boleh berupa teks apa pun. Pemeriksaan dilakukan dengan Hardhat 2.29.1 dan hardhat-verify 2.1.3 terhadap kontrak yang sudah diverifikasi: plugin menemukan rantai khusus tersebut, mengkueri API penjelajah blok, lalu menjawab "already verified". Pengiriman verifikasi baru belum dicoba, jadi beri tahu kami jika tidak berhasil. Plugin menampilkan peringatan penghentian penggunaan kunci API per jaringan. Peringatan ini memang diharapkan: tetap gunakan `apiKey` di bawah ini, karena format satu string tidak berfungsi pada rantai ini ("The selected network (ostia) is wrong").

```js
// hardhat.config.js, di sebelah solidity dan 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>
```

Gunakan `solidity` yang sama, termasuk `evmVersion`, seperti saat Anda melakukan deployment. Penjelajah mengompilasi dengan pengaturan yang diberikan. Batas yang sama, yaitu 30 verifikasi per jam, tetap berlaku.

## viem dan ethers

Definisi chain viem:

```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() });
```

Provider ethers:

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

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

RPC tidak menyediakan WebSocket maupun filter, jadi ethers v6 memerlukan `{ polling: true }` untuk memantau peristiwa (`contract.on`atau `provider.on` dengan filter). Receipt baru tersedia setelah bloknya final, jadi sediakan waktu sekitar 10 hingga 30 detik saat mengatur batas waktu. Kirim transaksi dari satu akun secara berurutan; lihat [Perbedaan dari Ethereum](https://docs.rome.builders/id/canton-zk-evm/evm-differences.md#nonces-and-the-order-of-sends).

Di viem, `multicall` memerlukan Multicall3 di chain. Ostia memilikinya di alamat yang umum digunakan, jadi tambahkan ke definisi chain: `contracts: { multicall3: { address: "0xcA11bde05977b3631167028862bE2a173976CA11" } }` (lihat [Perbedaan dari Ethereum](https://docs.rome.builders/id/canton-zk-evm/evm-differences.md#the-standard-contracts)).

## Receipt dan peristiwa

RPC hanya menampilkan blok yang sudah final di Canton. Setelah Anda mengirim transaksi, `eth_getTransactionReceipt` tidak mengembalikan apa pun hingga bloknya final, yang memerlukan waktu sekitar 10 hingga 30 detik. Saat mengatur batas waktu receipt di suatu alat, perhitungkan proses pembuktian dan konfirmasi Canton.

Tidak tersedia WebSocket maupun `eth_subscribe`, dan tidak ada `eth_newFilter`. Untuk mengikuti peristiwa, lakukan polling `eth_getLogs` dengan rentang blok sejak polling terakhir Anda. Polling setiap beberapa detik sudah cukup. Dalam 24 jam hingga 2026-10-25 01:34 UTC, jeda median antarblok saat chain sibuk adalah 16,6 detik, dan chain yang sepi menghasilkan blok kosong sekali setiap menit. Batasi hingga 300 panggilan per menit.

## Lihat transaksi Anda di Canton

1. Buka transaksi Anda di penjelajah, melalui `/tx/<hash>`.
2. Ikuti tautan bloknya, `/block/<number>`.
3. Halaman blok menampilkan pembaruan Canton yang memuat catatan blok, waktu Canton mencatatnya, serta fakta bukti di samping nilai yang diharapkan oleh penjelajah.
4. Tekan **Verifikasi**. Browser Anda menjalankan pemeriksaan bukti itu sendiri, terhadap bukti, header, dan transaksi yang disajikan penjelajah. Tombol akan dinonaktifkan selama blok masih dalam proses pembuktian.

Data yang sama tersedia di API, misalnya `GET /api/blocks/<number>` dan `GET /api/canton/updates/<update id>`.

## Contoh yang lebih besar

Folder [`load/mixed`](https://github.com/rome-protocol/canton-zk-evm/tree/v0.1.0/load/mixed) men-deploy sekumpulan kontrak dan mengirimkan lalu lintas campuran melalui kontrak tersebut: ERC-20, ERC-721, ERC-1155, token berizin ERC-3643, Uniswap V2, serta kontrak transfer privat Merces dari TACEO (buktinya diperiksa di chain; tidak ada yang diselesaikan). [README](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/load/mixed/README.md) berisi perintah-perintahnya. Kit ini juga memverifikasi setiap kontrak yang di-deploy-nya di penjelajah. Dengan konfigurasi bawaan, kit ini membutuhkan sekitar 12.000 tROME, jauh lebih banyak daripada yang diberikan faucet. Jadi, jalankan pada Ostia milik Anda sendiri (lihat [Jalankan Ostia Anda sendiri](https://docs.rome.builders/id/canton-zk-evm/run-it-locally.md#load-it-with-a-realistic-mix)). Unduhan kompilernya hanya berjalan di linux x64. Pada 2026-10-24, satu kali proses mengirim 13.496 transaksi dalam satu jam, dan semuanya menjadi final. [Hasil](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/load/mixed/RESULTS-2026-10-24.md) menjelaskan apa yang diukur dan apa yang tidak berhasil.


---

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