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

# Construa na Ostia

Implante um contrato Solidity na Ostia DevNet com Foundry ou Hardhat, verifique-o e conecte-se usando viem ou ethers.

Ostia é uma chain EVM, então as ferramentas que você já usa funcionam nela. Algumas coisas são diferentes; consulte [Diferenças em relação ao Ethereum](https://docs.rome.builders/pt-br/canton-zk-evm/evm-differences.md). Esta página mostra como implantar e verificar um contrato, como ler eventos e onde acompanhar a finalização da sua transação na Canton. Você precisa de um endereço com algum tROME. A [torneira](https://docs.rome.builders/pt-br/canton-zk-evm/devnet.md#get-trome) fornece 1 tROME, e [Ostia DevNet](https://docs.rome.builders/pt-br/canton-zk-evm/devnet.md) contém os detalhes da rede.

## Implantar com Foundry

Estes comandos foram testados com o Foundry 1.8. Primeiro, execute `foundryup` (ou `brew upgrade foundry`). Trabalhe em um projeto Foundry (`forge init ostia-counter` cria um, com um contrato `Counter` ) e mantenha a chave com fundos em `PRIVATE_KEY`. `forge init` já cria uma tabela `[profile.default]` em `foundry.toml`. Adicione uma linha abaixo dela para que a implantação e a verificação sejam compiladas com as mesmas configurações:

```toml
[profile.default]
# ...mantenha como estão as linhas criadas por forge init
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
```

Estes já foram executados na Ostia:

| O quê                                                                                         | Compilador          | Versão da EVM |
| --------------------------------------------------------------------------------------------- | ------------------- | ------------- |
| O [kit de carga mista](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 e 0.6.6 | `istanbul`    |
| Contratos Merces da TACEO                                                                     | solc 0.8.37         | `osaka`       |

A chain Ostia executa todos os forks até Osaka desde 2026-10-28, então aceita código compilado para qualquer alvo EVM até `osaka`. Os alvos na tabela são os que já foram executados; `london` é uma opção segura. Um opcode adicionado após Osaka não será executado.

## Verificar com Foundry

O explorer usa a API da Etherscan, então `forge verify-contract` funciona com o verificador da Etherscan. A chave de API pode ser qualquer texto.

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

O explorer aceita 30 verificações por hora de um mesmo cliente. Se você ultrapassar esse limite, aguarde e envie a solicitação novamente. Um contrato verificado exibe seu código-fonte na página do contrato no explorer.

## Verificar um contrato grande

Um contrato com muitos arquivos-fonte pode ser recusado com HTTP `413`. O proxy de entrada do explorer aceita cerca de 300 KB por solicitação, e o forge envia a entrada codificada em URL, que fica maior do que os arquivos. `POST /api/verify` aceita a mesma entrada que o JSON padrão, que é menor. O limite do proxy se aplica a todas as solicitações, então um corpo JSON com mais de 300 KB também é recusado. O [`verify-large.mjs`](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/load/mixed/scripts/verify-large.mjs) do kit faz isso. Ele enviou o JSON padrão de 265 KB dos contratos Merces, que o forge não conseguiu enviar. Para usá-lo, primeiro obtenha o JSON padrão do seu projeto Foundry e copie-o para a pasta do kit (`load/mixed` em um clone do repositório):

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

Em seguida, na pasta do kit, instale os pacotes com `npm ci` e execute o script. Ele obtém o endereço do explorer no `config.json`do kit. (Com Docker, `./run.sh node scripts/verify-large.mjs ...` faz o mesmo.)

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

Informe o compilador usando a string completa da versão. Para um contrato `Counter` compilado com solc 0.8.28, otimizador ativado com 200 execuções e versão da EVM `london` e sem argumentos de construtor:

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

O explorer compila usando as configurações contidas em std.json, que o forge gera a partir do seu foundry.toml; assim, o contrato é verificado com a configuração de otimização usada na compilação. O script envia a solicitação de verificação e, em seguida, consulta `GET /api/verify/<guid>` até que a resposta seja `Pass` ou `Fail`. O mesmo limite de 30 por hora se aplica.

## Implantar com Hardhat

Estas instruções são para o Hardhat 2 (o Hardhat 3 exige uma configuração ESM). As etapas começam em uma pasta vazia e foram executadas no Ostia DevNet com Hardhat 2.29 e Node 22. Mantenha a chave com fundos em `PRIVATE_KEY`, com o `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` faz perguntas no terminal e grava um contrato de exemplo próprio, então crie os três arquivos manualmente. Primeiro, o contrato:

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

A configuração. A versão de `solidity` corresponde à 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,
    },
  },
};
```

O script de implantação:

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

Ele imprime `Counter deployed to 0x...`. O `timeout` se aplica a cada solicitação. A implantação também aguarda o recibo, que só chega após a finalização do Canton (veja abaixo). Em um teste realizado em 2026-10-25, o comando levou de 20 a 23 segundos, a maior parte desse tempo aguardando a finalização do bloco.

## Verificar com Hardhat

Adicione o explorador como uma rede personalizada a `@nomicfoundation/hardhat-verify`, que `hardhat-toolbox` inclui, na configuração acima. A chave da API pode ser qualquer texto. A consulta foi verificada com Hardhat 2.29.1 e hardhat-verify 2.1.3 usando um contrato que já havia sido verificado: o plugin encontrou a rede personalizada, consultou a API do explorador e respondeu "já verificado". Não foi feita uma nova submissão; portanto, avise-nos se não funcionar. O plugin exibe um aviso de descontinuação sobre chaves de API por rede. O aviso é esperado: mantenha o `apiKey` por rede abaixo, pois o formato de uma única string falha nesta rede ("A rede selecionada (ostia) está incorreta").

```js
// hardhat.config.js, ao lado de solidity e 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>
```

Mantenha as mesmas `solidity` configurações, incluindo `evmVersion`, usadas na implantação. O explorador compila com as configurações fornecidas. O mesmo limite de 30 verificações por hora se aplica.

## viem e ethers

Uma definição de cadeia do 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() });
```

Um provedor ethers:

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

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

O RPC não oferece WebSocket nem filtros, então o ethers v6 precisa de `{ polling: true }` para acompanhar eventos (`contract.on`, ou `provider.on` com um filtro). Um recibo só é disponibilizado quando o bloco é finalizado, então considere cerca de 10 a 30 segundos ao definir um tempo limite. Envie as transações de uma conta em ordem; consulte [Diferenças em relação ao Ethereum](https://docs.rome.builders/pt-br/canton-zk-evm/evm-differences.md#nonces-and-the-order-of-sends).

No viem, `multicall` precisa do Multicall3 na cadeia. Ostia o tem no endereço habitual, então adicione-o à definição da cadeia: `contracts: { multicall3: { address: "0xcA11bde05977b3631167028862bE2a173976CA11" } }` (consulte [Diferenças em relação ao Ethereum](https://docs.rome.builders/pt-br/canton-zk-evm/evm-differences.md#the-standard-contracts)).

## Recibos e eventos

O RPC mostra apenas blocos finalizados no Canton. Depois que você envia uma transação, `eth_getTransactionReceipt` não retorna nada até que o bloco seja finalizado, o que leva cerca de 10 a 30 segundos. Ao definir um tempo limite para o recibo em uma ferramenta, considere o tempo de geração da prova e da confirmação pelo Canton.

Não há WebSocket nem `eth_subscribe`, e nenhum `eth_newFilter`. Para acompanhar eventos, consulte periodicamente `eth_getLogs` com o intervalo de blocos desde a última consulta. Uma consulta a cada poucos segundos é suficiente. Nas 24 horas até 2026-10-25 01:34 UTC, o intervalo mediano entre blocos enquanto a cadeia estava movimentada foi de 16,6 segundos, e uma cadeia tranquila produz um bloco vazio por minuto. Limite-se a 300 chamadas por minuto.

## Veja sua transação na Canton

1. Abra sua transação no explorador, em `/tx/<hash>`.
2. Siga o link do bloco, `/block/<number>`.
3. A página do bloco mostra a atualização da Canton que contém o registro do bloco, o horário em que a Canton o registrou e os fatos da prova ao lado dos valores esperados pelo explorador.
4. Clique em **Verificar**. Seu navegador executa a verificação da prova por conta própria, usando a prova, o cabeçalho e as transações fornecidos pelo explorador. O botão fica desativado enquanto o bloco ainda está sendo provado.

Os mesmos dados estão disponíveis na API, por exemplo, em `GET /api/blocks/<number>` e `GET /api/canton/updates/<update id>`.

## Um exemplo maior

A pasta [`load/mixed`](https://github.com/rome-protocol/canton-zk-evm/tree/v0.1.0/load/mixed) implanta um conjunto de contratos e gera tráfego misto por meio deles: ERC-20, ERC-721, ERC-1155, um token permissionado ERC-3643, Uniswap V2 e os contratos de transferência privada Merces da TACEO (as provas são verificadas on-chain; nada é liquidado). Seu [README](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/load/mixed/README.md) contém os comandos. O kit também verifica no explorador cada contrato que implanta. Com a configuração fornecida, ele precisa de cerca de 12.000 tROME, muito mais do que o faucet oferece; portanto, execute-o na sua própria Ostia (consulte [Execute sua própria Ostia](https://docs.rome.builders/pt-br/canton-zk-evm/run-it-locally.md#load-it-with-a-realistic-mix)). O download do compilador funciona apenas em Linux x64. Em 2026-10-24, uma execução enviou 13.496 transações em uma hora, e todas se tornaram finais. Os [resultados](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/load/mixed/RESULTS-2026-10-24.md) informam o que foi medido e o que não funcionou.


---

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