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

# Construye sobre Ostia

Implementa un contrato de Solidity en Ostia DevNet con Foundry o Hardhat, verifícalo y conéctate con viem o ethers.

Ostia es una cadena EVM, así que las herramientas que ya usas funcionan en ella. Hay algunas diferencias; consulta [Diferencias con Ethereum](https://docs.rome.builders/es/canton-zk-evm/evm-differences.md). En esta página se explica cómo desplegar y verificar un contrato, cómo leer eventos y dónde ver cuándo finaliza tu transacción en Canton. Necesitas una dirección con algo de tROME. El [grifo](https://docs.rome.builders/es/canton-zk-evm/devnet.md#get-trome) entrega 1 tROME, y [Ostia DevNet](https://docs.rome.builders/es/canton-zk-evm/devnet.md) contiene los detalles de la red.

## Desplegar con Foundry

Estos comandos se probaron con Foundry 1.8. Primero, ejecuta `foundryup` (o `brew upgrade foundry`). Trabaja en un proyecto de Foundry (`forge init ostia-counter` crea uno, con un contrato `Counter` ) y guarda la clave financiada en `PRIVATE_KEY`. `forge init` ya escribe una tabla `[profile.default]` en `foundry.toml`. Añade una línea debajo para que la compilación del despliegue y la verificación utilicen la misma configuración:

```toml
[profile.default]
# ...las líneas que escribió forge init se mantienen tal cual
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
```

Hasta ahora, se han ejecutado en Ostia estos contratos:

| Qué                                                                                            | Compilador          | Versión de EVM |
| ---------------------------------------------------------------------------------------------- | ------------------- | -------------- |
| El [kit de carga mixta](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 y 0.6.6 | `istanbul`     |
| Contratos Merces de TACEO                                                                      | solc 0.8.37         | `osaka`        |

La cadena de Ostia ha ejecutado todas las bifurcaciones hasta Osaka desde el 28-10-2026, por lo que la cadena acepta código compilado para cualquier destino EVM hasta `osaka`. Los destinos de la tabla son los que se han ejecutado; `london` es una opción segura. Los códigos de operación añadidos después de Osaka no se ejecutarán.

## Verificar con Foundry

El explorador utiliza la API de Etherscan, por lo que `forge verify-contract` funciona con el verificador de Etherscan. La clave de API puede ser cualquier 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
```

El explorador acepta 30 verificaciones por hora de un mismo cliente. Si superas ese límite, espera y vuelve a enviar la solicitud. Un contrato verificado muestra su código fuente en la página del contrato del explorador.

## Verificar un contrato grande

Un contrato con muchos archivos fuente puede ser rechazado con HTTP `413`. El proxy frontal del explorador admite unos 300 KB por solicitud, y forge envía la entrada codificada en URL, que ocupa más espacio que los archivos. `POST /api/verify` acepta la misma entrada que el formato JSON estándar, que ocupa menos espacio. El límite del proxy se aplica a todas las solicitudes, así que también se rechaza un cuerpo JSON de más de 300 KB. El kit incluye [`verify-large.mjs`](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/load/mixed/scripts/verify-large.mjs) y lo hace. Envió el JSON estándar de 265 KB de los contratos Merces, que forge no pudo enviar. Para usarlo, primero obtén el JSON estándar de tu proyecto de Foundry y cópialo en la carpeta del kit (`load/mixed` en un clon del repositorio):

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

Luego, en la carpeta del kit, instala sus paquetes con `npm ci` y ejecuta el script. Este obtiene la dirección del explorador del archivo `config.json`del kit. (Con Docker, `./run.sh node scripts/verify-large.mjs ...` hace lo mismo.)

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

Indica el compilador con una cadena de versión completa. Para un contrato `Counter` compilado con solc 0.8.28, con el optimizador activado y 200 ejecuciones, y con la versión de EVM `london` y sin argumentos de constructor:

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

El explorador compila con la configuración incluida en std.json, que forge genera a partir de tu foundry.toml, por lo que el contrato se verifica con la configuración del optimizador con la que se compiló. El script envía la solicitud de verificación y luego consulta `GET /api/verify/<guid>` hasta que la respuesta sea `Pass` o `Fail`. Se aplica el mismo límite de 30 por hora.

## Desplegar con Hardhat

Estas instrucciones son para Hardhat 2 (Hardhat 3 requiere una configuración ESM). Los pasos parten de una carpeta vacía y se ejecutaron en Ostia DevNet con Hardhat 2.29 en Node 22. Guarda la clave con fondos en `PRIVATE_KEY`con su `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` formula sus preguntas en una terminal y escribe un contrato de ejemplo propio, así que crea los tres archivos a mano. Primero, el 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++;
    }
}
```

La configuración. Su versión de `solidity` coincide con la directiva 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,
    },
  },
};
```

El script de implementación:

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

Imprime `Counter deployed to 0x...`. El `timeout` se aplica a cada solicitud. La implementación también espera el recibo, que solo llega después de la finalidad de Canton (véase más abajo). En una prueba realizada el 2026-10-25, el comando tardó entre 20 y 23 segundos; la mayor parte del tiempo se pasó esperando a que el bloque alcanzara la finalidad.

## Verificar con Hardhat

Añade el explorador como cadena personalizada a `@nomicfoundation/hardhat-verify`, que `hardhat-toolbox` incluye, en la configuración anterior. La clave de API puede ser cualquier texto. Se comprobó la consulta con Hardhat 2.29.1 y hardhat-verify 2.1.3, usando un contrato que ya estaba verificado: el complemento encontró la cadena personalizada, consultó la API del explorador y respondió «already verified». No se ha probado un nuevo envío, así que avísanos si no funciona. El complemento muestra una advertencia de obsolescencia sobre las claves de API por red. La advertencia es esperada: mantén la `apiKey` de cada red a continuación, porque el formato de una sola cadena falla en esta red («The selected network (ostia) is wrong»).

```js
// hardhat.config.js, junto a solidity y 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>
```

Mantén la misma `solidity` configuración, incluida `evmVersion`, que usaste al desplegar. El explorador compila con la configuración que se le proporciona. Se aplica el mismo límite de 30 verificaciones por hora.

## viem y ethers

Una definición de cadena de 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() });
```

Un proveedor de ethers:

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

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

El RPC no tiene WebSocket ni filtros, por lo que ethers v6 necesita `{ polling: true }` para seguir eventos (`contract.on`, o `provider.on` con un filtro). El recibo solo llega cuando el bloque es definitivo, así que al configurar un tiempo de espera, calcula entre 10 y 30 segundos. Envía las transacciones de una cuenta en orden; consulta [Diferencias con Ethereum](https://docs.rome.builders/es/canton-zk-evm/evm-differences.md#nonces-and-the-order-of-sends).

En viem, `multicall` necesita Multicall3 en la cadena. Ostia lo tiene en la dirección habitual, así que añádelo a la definición de la cadena: `contracts: { multicall3: { address: "0xcA11bde05977b3631167028862bE2a173976CA11" } }` (consulta [Diferencias con Ethereum](https://docs.rome.builders/es/canton-zk-evm/evm-differences.md#the-standard-contracts)).

## Recibos y eventos

El RPC muestra solo los bloques que son definitivos en Canton. Después de enviar una transacción, `eth_getTransactionReceipt` no devuelve nada hasta que su bloque es definitivo, lo que tarda entre 10 y 30 segundos. Al configurar el tiempo de espera de un recibo en una herramienta, deja tiempo para la prueba y la confirmación de Canton.

No hay WebSocket ni `eth_subscribe`, y ningún `eth_newFilter`. Para seguir los eventos, consulta `eth_getLogs` con el rango de bloques desde la última consulta. Basta con consultar cada pocos segundos. En las 24 horas anteriores al 2026-10-25 01:34 UTC, la mediana del intervalo entre bloques mientras la cadena estaba activa fue de 16,6 segundos; cuando hay poca actividad, se produce un bloque vacío cada minuto. Limítate a 300 llamadas por minuto.

## Consulta tu transacción en Canton

1. Abre tu transacción en el explorador, en `/tx/<hash>`.
2. Sigue el enlace a su bloque, `/block/<number>`.
3. La página del bloque muestra la actualización de Canton que contiene el registro del bloque, la hora en que Canton la registró y los datos de la prueba junto a los valores esperados del explorador.
4. Pulsa **Verificar**. Tu navegador realiza la comprobación de la prueba por sí mismo, usando la prueba, la cabecera y las transacciones que proporciona el explorador. El botón aparece atenuado mientras se sigue generando la prueba del bloque.

Los mismos datos están disponibles en la API, por ejemplo, `GET /api/blocks/<number>` y `GET /api/canton/updates/<update id>`.

## Un ejemplo más completo

La carpeta [`load/mixed`](https://github.com/rome-protocol/canton-zk-evm/tree/v0.1.0/load/mixed) implementa un conjunto de contratos y genera tráfico variado a través de ellos: ERC-20, ERC-721, ERC-1155, un token con permisos ERC-3643, Uniswap V2 y los contratos de transferencia privada Merces de TACEO (sus pruebas se verifican en la cadena; no se liquida nada). Su [README](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/load/mixed/README.md) contiene los comandos. El kit también verifica en el explorador cada contrato que implementa. Con la configuración incluida, necesita unos 12.000 tROME, mucho más de lo que ofrece el grifo, así que ejecútalo en tu propia instancia de Ostia (consulta [Ejecutar tu propia instancia de Ostia](https://docs.rome.builders/es/canton-zk-evm/run-it-locally.md#load-it-with-a-realistic-mix)). La descarga del compilador solo funciona en Linux x64. El 2026-10-24, una ejecución envió 13.496 transacciones en una hora y todas quedaron finalizadas. Los [resultados](https://github.com/rome-protocol/canton-zk-evm/blob/v0.1.0/load/mixed/RESULTS-2026-10-24.md) indican qué se midió y qué no funcionó.


---

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