> 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/devnet.md).

# Ostia DevNet

Detalles de la red de Ostia DevNet, con el ID de cadena, RPC, explorador, APIs, configuración de wallet, faucet y límites.

Ostia DevNet es la red pública de Ostia. Se ejecuta en Canton Network DevNet y está activa desde **2026-10-22**. Las herramientas EVM habituales funcionan en ella: monederos, Foundry, Hardhat, ethers y viem. Esta página contiene los valores que necesitas para conectarte. [Desarrolla en Ostia](https://docs.rome.builders/es/canton-zk-evm/build-on-ostia.md) te guía desde ahí hasta desplegar y verificar un contrato.

Desde **2026-10-29** la cadena también permite transferir activos de Canton en ambos sentidos: los tokens ERC-20 tienen un equivalente en Canton, y Canton Coin llega a Ostia y puede volver. Las direcciones están en [Activos de Canton en DevNet](#canton-assets-on-devnet) más abajo.

## Detalles de la red

| Configuración                | Valor                                                                                                    |
| ---------------------------- | -------------------------------------------------------------------------------------------------------- |
| Nombre de la red             | Ostia DevNet                                                                                             |
| ID de cadena                 | `770101` (hexadecimal `0xbc035`)                                                                         |
| Moneda                       | tROME, 18 decimales. No tiene valor.                                                                     |
| RPC                          | `https://ostia.devnet.romeprotocol.xyz/rpc` (solo HTTP, únicamente bloques finalizados)                  |
| Explorador                   | [ostia.devnet.romeprotocol.xyz](https://ostia.devnet.romeprotocol.xyz)                                   |
| API compatible con Etherscan | `https://ostia.devnet.romeprotocol.xyz/api`                                                              |
| API REST                     | `https://ostia.devnet.romeprotocol.xyz/api/...`, descrita en el documento OpenAPI en `/api/openapi.json` |
| Estado y salud               | `/api/status` y `/api/health` en la dirección del explorador                                             |

El precio del gas es de aproximadamente 1 gwei y cada bloque admite hasta 60,000,000 unidades de gas. Una transacción individual puede usar como máximo 16,777,216 unidades de gas (2^24), el límite establecido por la bifurcación Osaka. Hay algunas diferencias con Ethereum, como que `block.prevrandao` sea 0 y que no haya transacciones con blobs; consulta [Diferencias con Ethereum](https://docs.rome.builders/es/canton-zk-evm/evm-differences.md).

## Añádela a un monedero

En MetaMask o en otro monedero, añade una red personalizada con estos valores:

| Campo                         | Valor                                       |
| ----------------------------- | ------------------------------------------- |
| Nombre de la red              | Ostia DevNet                                |
| URL del nuevo RPC             | `https://ostia.devnet.romeprotocol.xyz/rpc` |
| ID de cadena                  | `770101`                                    |
| Símbolo de la moneda          | `tROME`                                     |
| URL del explorador de bloques | `https://ostia.devnet.romeprotocol.xyz`     |

El explorador también puede hacerlo por ti. Abre su [página de API](https://ostia.devnet.romeprotocol.xyz/docs/api) y pulsa el botón para añadir la red a tu monedero.

## Obtener tROME

Todo el mundo recibe 1 tROME al día. Los desarrolladores pueden obtener 100 tROME con la subvención para desarrolladores, una vez cada 7 días. Abre el [dispensador](https://ostia.devnet.romeprotocol.xyz/faucet), pega tu dirección y solicítalos. También puedes solicitarlos desde una terminal:

```sh
curl -X POST https://ostia.devnet.romeprotocol.xyz/api/faucet \
  -H 'content-type: application/json' \
  -d '{"address":"0xYourAddress"}'
```

Una solicitud aceptada responde `202` con un `ticket`. Consulta `GET /api/faucet/ticket/<ticket>` hasta que su estado sea `final` (o `failed`). El estado pasa de `queued` a `sent` a `final`. Usa la dirección de tu monedero en lugar de `0xYourAddress`. El dispensador entrega:

* 1 tROME por dirección cada 24 horas;
* una solicitud por dirección IP cada 10 minutos;
* un máximo de 5.000 pagos por hora entre todos.

Los pagos se envían en lotes de hasta 100. Recibirás el tuyo cuando su bloque sea definitivo en Canton, lo que tarda entre 10 y 30 segundos desde que se envía. Un tROME cubre miles de transacciones ordinarias al precio actual del gas. Los límites del dispensador se describen en [la sección del dispensador del README del explorador](https://github.com/rome-protocol/canton-zk-evm/blob/main/explorer/README.md#the-faucet).

### La subvención para desarrolladores

Quienes desarrollen y inicien sesión con GitHub reciben 100 tROME en lugar de 1. En la página Faucet, escribe tu dirección y elige «Sign in with GitHub» en la línea «Building on Ostia? Sign in with GitHub for 100 tROME». La página Bridge ofrece el mismo paso en «Get test tROME» para el monedero que tengas conectado, siempre que aún no tenga tROME; de lo contrario, usa la página Faucet. GitHub te devuelve a la página Faucet, que sigue el estado de tu subvención hasta que sea definitiva, como cualquier otra solicitud. La página no solicita permisos a GitHub y solo consulta el número de tu cuenta y su fecha de creación.

* La cuenta de GitHub debe tener al menos 30 días de antigüedad.
* Una subvención por cuenta de GitHub y una por dirección cada 7 días.
* Un máximo de 200 subvenciones al día entre todos.

Todo el mundo sigue recibiendo 1 tROME al día, tenga o no una cuenta de GitHub. La respuesta de `GET /api/faucet` indica si la subvención está activa, así como su importe y sus límites. Las reglas se describen en la sección [de la subvención para desarrolladores](https://github.com/rome-protocol/canton-zk-evm/blob/main/explorer/README.md#the-builder-grant) del README del explorador.

### Canton Coin de prueba

La página Bridge ya no tiene un dispensador de Canton Coin desde el 17-11-2026 (solo atendía la cuenta Bridge, que se retiró). Obtén Canton Coin de prueba en tu propio monedero de Canton.

## Límites

El RPC en `/rpc` redirige a la cadena, con estas diferencias:

* Responde a 20 métodos: `eth_chainId`, `net_version`, `web3_clientVersion`, `eth_syncing`, `eth_blockNumber`, `eth_getBalance`, `eth_getCode`, `eth_getStorageAt`, `eth_getTransactionCount`, `eth_call`, `eth_estimateGas`, `eth_gasPrice`, `eth_maxPriorityFeePerGas`, `eth_feeHistory`, `eth_getBlockByNumber`, `eth_getBlockByHash`, `eth_getTransactionByHash`, `eth_getTransactionReceipt`, `eth_getLogs` y `eth_sendRawTransaction`. Cualquier otro método responde `-32601`.
* No hay WebSocket ni `eth_newFilter` ni `eth_subscribe`. Para seguir los eventos, consulta periódicamente `eth_getLogs`.
* Solo muestra los bloques que son finales en Canton. `latest`, `safe`, `pending` y `finalized` significan todos el bloque final más reciente (excepto `eth_getTransactionCount` con `pending`, que cuenta las transacciones pendientes para que tu cartera elija el siguiente nonce). El recibo aparece cuando el bloque es final, lo que tarda entre 10 y 30 segundos aproximadamente.
* Cada cliente puede realizar 300 llamadas por minuto. En un lote se contabilizan todas las llamadas que contiene, y puede incluir como máximo 20. El cuerpo de una solicitud puede tener un máximo de 256 KiB.
* Se rechaza una transacción cuyo nonce supera el siguiente nonce de la cuenta por existir un salto en la secuencia. Envía primero las transacciones que faltan.
* Se rechaza una transacción cuya comisión máxima por gas sea inferior a la comisión base actual. Las carteras y herramientas la establecen automáticamente.

Las API del explorador tienen sus propios límites por cliente y no requieren claves:

| Interfaz                              | Límite                                                                                                                                                                                  |
| ------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| API REST (`/api/...`)                 | 20 solicitudes por segundo, con ráfagas de 60. Si un cliente supera el límite, recibe `429` con `Retry-After`.                                                                          |
| API compatible con Etherscan (`/api`) | 10 solicitudes por segundo y 600 por minuto. Si un cliente supera el límite, recibe `Max rate limit reached`, como responde Etherscan.                                                  |
| Verificación de contratos             | 30 por hora. Una solicitud de más de unos 300 KB recibe `413` (consulta [Desarrollar en Ostia](https://docs.rome.builders/es/canton-zk-evm/build-on-ostia.md#verify-a-large-contract)). |

El [README del explorador](https://github.com/rome-protocol/canton-zk-evm/blob/main/explorer/README.md#the-public-rpc) de la rama principal describe íntegramente las reglas de RPC, incluido el límite global de llamadas pesadas.

## Una cadena inactiva genera un bloque por minuto

Ostia genera un bloque en cuanto hay transacciones en espera. Si no se ha generado ningún bloque en 60 segundos, genera uno vacío, un latido. En una cadena inactiva, el constructor inicia ese bloque 60 segundos después de registrar el compromiso anterior; a eso se suman la generación de la prueba y la liquidación, por lo que una cadena inactiva en buen estado no pasa más de un par de minutos sin un bloque nuevo. Si algo falla, el siguiente bloque puede retrasarse. Antes de la mañana del 2026-10-25 no había latidos, y una cadena inactiva podía pasar horas sin generar un bloque. Durante los intervalos de inactividad entre las 07:53 y las 08:49 UTC de ese día, los bloques vacíos se generaron con unos 75 segundos de diferencia (un minuto de espera, seguido del tiempo necesario para generar la prueba y confirmar un bloque vacío). Tu transacción no espera al latido: se incluye en el siguiente bloque que se genera, como antes.

Un bloque admite tantas transacciones como quepan dentro del límite de gas de 60,000,000, calculado según el gas que consumen, y del límite de bytes sin procesar, de 393,216 en DevNet. Unas 2,857 transferencias simples caben dentro del límite de gas. (Hasta el 2026-10-27, el límite de gas era de 30,000,000, lo que permitía 1,428 transferencias simples, y el límite de bytes era de 196,608 desde el 2026-10-25. Las cifras de rendimiento de [Mediciones](https://docs.rome.builders/es/canton-zk-evm/measurements.md) se obtuvieron con el límite de gas de 30,000,000 y límites de bytes de entre 65,536 y 196,608.)

## Activos de Canton en DevNet

Desde el 2026-10-29, los tokens ERC-20 pueden existir en Canton como representaciones gemelas, y Canton Coin puede transferirse a Ostia y volver. Depositas un ERC-20 en la bóveda, y la parte de Canton que indiques recibe la misma cantidad de su gemelo, un token CIP-0056 cuyo ID de instrumento es `erc20:<token address>`. Al canjearlo, se quema el gemelo y se devuelve el ERC-20 desde la bóveda. En el caso de Canton Coin, una parte la deposita a través de la pasarela y reclama el token CC en Ostia; al quemar CC, se devuelve Canton Coin. [Depósitos, retiros y pagos](https://docs.rome.builders/es/canton-zk-evm/deposits-withdrawals-payments.md) describe los flujos.

| Qué                                                                                                                                                                                    | Dirección en Ostia DevNet                    |
| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------- |
| Pasarela, el contrato al que llamas para `pay`, `withdraw` y `claim` (consulta el [README de la pasarela](https://github.com/rome-protocol/canton-zk-evm/blob/main/gateway/README.md)) | `0xa7E0000000000000000000000000000000000000` |
| Bóveda                                                                                                                                                                                 | `0x69f13a94f986021f1a7650eb611bf9b717aa495a` |
| TKA, un ERC-20 con un gemelo (18 decimales)                                                                                                                                            | `0xf4b69022b3e6501101600743f17fbe0659dd1af8` |
| WtROME, tROME envuelto, el segundo gemelo (18 decimales)                                                                                                                               | `0xc221fc4af51caa9d198e70e3cb3b8f3d9d2adc64` |
| CC, Canton Coin en Ostia (10 decimales; en registros anteriores se denomina wCC)                                                                                                       | `0x4db3dea7c13116961fd3e438542ccfcca61a7547` |

La página [`/twins`](https://ostia.devnet.romeprotocol.xyz/twins) del explorador muestra la oferta de cada gemelo junto a lo que contiene la bóveda. El servicio de registro de gemelos responde en `https://ostia.devnet.romeprotocol.xyz/twin-registry`; no guarda claves ni escribe nada en Canton. Solicita una ruta completa: la ruta sola `/twin-registry/` responde `404`. `GET /twin-registry/healthz` devuelve la cantidad de gemelos y las bóvedas, y `GET /twin-registry/twin/v1/twins` devuelve el token y el ID de instrumento de cada gemelo, así como las bóvedas.

Para bloquear o canjear en Canton, se necesita una parte de Canton que firme la operación. La página Bridge del explorador realiza las operaciones con la billetera de Canton que ya tienes; consulta [Bridge](https://docs.rome.builders/es/canton-zk-evm/bridge.md). La sección [Llamadas externas](https://docs.rome.builders/es/canton-zk-evm/explorer.md#external-calls) la vista muestra cómo se confirma cada bloque en Canton.

## Canton en DevNet

El validador de DevNet de Rome, con dos participantes, ejecuta Splice 0.10.1 con Canton 3.7.2 desde el 2026-11-07. El sincronizador de DevNet ejecuta la versión 37 del protocolo desde el 2026-11-18. Las pruebas de Ostia se ejecutan con las versiones 36 y 37 del protocolo.

## Pausas y mantenimiento

DevNet se pausa de vez en cuando, y algunas pausas están planificadas. Una pausa puede presentarse de dos maneras, según su causa:

* Durante el reinicio de una **máquina** no se puede acceder a la RPC y esta responde con un error del servidor (un 5xx del proxy frontal).
* Durante una pausa del **validador o del sincronizador** la RPC sigue respondiendo y acepta transacciones, pero no se confirma ningún bloque; por eso no llega ningún bloque final ni recibo hasta que `/api/health` indique `ok` de nuevo.

Las transacciones que Ostia aceptó antes de una pausa se conservan con sus bytes firmados y se vuelven a enviar después, durante un máximo de una hora. Por eso, espera a que `/api/health` indique `ok` antes de volver a enviarlas.

* **Reinicios de unos minutos.** Las máquinas de Ostia pueden reiniciarse sin previo aviso. El 2026-11-04 hubo tres reinicios, y cada máquina se recuperó por sí sola en unos 7 minutos.
* **Actualizaciones del validador.** El validador de DevNet de Rome se actualiza de vez en cuando, y Ostia deja de confirmar bloques mientras dura la actualización. La actualización del 2026-11-04 estaba prevista para durar 15 minutos.
* **2026-11-16: ajustes de acceso del validador de DevNet de Rome (de 09:00 a 10:30 UTC) y actualización del sistema de pruebas de conocimiento a ZisK 1.4.0-alpha (13:31 UTC).** Ostia se pausó en ambos casos. Las dos tareas terminaron y las transacciones y el puente se reanudaron después de cada pausa.
* **2026-11-18: actualización del sincronizador de DevNet a la versión 37 del protocolo (14:00 UTC).** Ostia siguió funcionando durante la actualización; el intervalo más largo entre bloques finales fue de 72 s.
* **2026-11-21, de 12:00 a 16:00 UTC:** Ostia pasa a Canton TestNet. Los bloques se pausan durante la migración; tROME, los tokens y los contratos se trasladan junto con la cadena. Nueva dirección: ostia.testnet.romeprotocol.xyz. Canton Coin y los demás tokens de Ostia respaldados por Canton permanecen en DevNet y no se trasladan.

Publicaremos aquí estas fechas y cualquier cambio, en la página [Estado y hoja de ruta](https://docs.rome.builders/es/canton-zk-evm/status.md#upcoming-maintenance) y en el [Discord de Rome](https://discord.gg/vZ9rnCdNSB).

## Tráfico de Canton: quién paga

Todas las transacciones de Canton usan tráfico. El participante que envía la transacción paga por ella, y cada participante que la confirma paga por las confirmaciones que envía. En DevNet, ambas cosas corren por cuenta del participante de Rome: envía y paga el `Advance` de cada bloque y los pasos de Canton que ejecutan las propias partes de Rome, y es el único participante que confirma los bloques de Ostia. Actualmente no pagas nada por el tráfico de Canton. Tu único costo es tROME para el gas en Ostia, y tROME no tiene valor.

Un bloque cuesta aproximadamente 8,4 KB de tráfico, más unos 100 bytes por cada transacción que contiene (medido durante una hora el 2026-10-24: 15,7 KB para un bloque en la mediana; consulta [Mediciones](https://docs.rome.builders/es/canton-zk-evm/measurements.md#what-a-block-costs-on-canton)). Con unos 2.200 bloques al día, eso equivale aproximadamente a entre 17 y 35 MB diarios. Rome limita el tráfico de Canton del puente por cuenta y por día. Esta página no indica un precio por MB, porque lo fija la red Canton, y todavía no se ha decidido cómo se pagará el tráfico en una red que no sea DevNet.

## Es posible que se restablezca DevNet

Ostia DevNet es una red de prueba. Se puede restablecer, lo que inicia una nueva cadena con el mismo ID de cadena, 770101. No guardes allí nada que no puedas volver a crear.

Como el ID de cadena no cambia, todas las transacciones firmadas para la cadena anterior también son válidas en la nueva. Cualquiera puede volver a enviar las transacciones firmadas antiguas, con los nonces 0, 1, 2 y sucesivos, y así repetir en la nueva cadena tus implementaciones y aprobaciones anteriores, así como los pagos públicos del faucet. No reutilices una clave importante después de un restablecimiento y usa una nueva dirección de implementación. El estado guardado de tus herramientas también se identifica por el ID de cadena y queda obsoleto: borra los datos de Hardhat Ignition en `deployments/chain-770101`y los de Foundry en `broadcast/<script>/770101`; también borra la actividad y el nonce de la red en tu billetera (en MetaMask: Configuración, Avanzado, Borrar datos de la pestaña Actividad). Cuando sea posible, anunciaremos los restablecimientos con antelación en los canales indicados en [Pausas y mantenimiento](#pauses-and-maintenance).

Qué se demuestra en DevNet y qué no se explica en [Qué está demostrado y qué no](https://docs.rome.builders/es/canton-zk-evm/what-is-proven.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/es/canton-zk-evm/devnet.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.
