Saltar al contenido principal

Desplegar un rollup

Puedes configurar un rollup específico de aplicación de tres maneras: a través del Dashboard (un formulario de solicitud, no una transacción on-chain), a través de la CLI de la cadena (qorechaind, con control total sobre la transacción on-chain) o con el RDK de TypeScript (@qorechain/rdk más el generador de plantillas create-qorechain-rollup), que cubre la configuración, las lecturas y, cuando le proporcionas una clave post-cuántica, las transacciones firmadas en modo híbrido (consulta RDK 0.8.0: cambios y límites). Esta página cubre las tres opciones, además del ciclo de vida del operador y los comandos de lotes.

Capacidad en fase temprana

No se ha creado ningún rollup en la mainnet (GET /qorechain/rdk/v1/rollups devolvió una lista vacía el 12 de noviembre de 2026); la testnet se comprobó por última vez el 30 de octubre de 2026, cuando no tenía ninguno. Los comandos siguientes usan la testnet qorechain-diana (EVM chain ID 9800, versión de cadena v3.2.8: la v3.2.4 se aplicó allí el 19 de octubre de 2026, la v3.2.5 el 26 de octubre en la altura 8,890,800, la v3.2.6 el 27 de octubre en la altura 8,970,638, la v3.2.7 el 6 de noviembre en la altura 9,594,600 y la v3.2.8 el 12 de noviembre en la altura 9,929,500; la v3.2.8 no está en la mainnet). La mainnet (qorechain-vladi, EVM chain ID 9801, en producción desde el 7 de junio de 2026) ejecuta la versión de cadena v3.2.7 desde el 12 de noviembre de 2026 (aplicada en la altura 4,164,600 por la propuesta de gobernanza 16; la v3.2.6 se aplicó en la altura 4,020,000 el 4 de noviembre de 2026 por la propuesta 15; la v3.2.5 se aplicó en la altura 3,906,833 el 29 de octubre de 2026 por la propuesta 14 y la v3.2.4 en la altura 3,742,566 el 23 de octubre de 2026 por la propuesta 13), de modo que lo que cambia la v3.2.5 para los rollups está marcado como «desde v3.2.5» y se aplica en ambas redes (hay una tabla resumen en la Visión general de los Rollups). Las versiones anteriores difieren en algunos detalles, que esta página marca como «desde v3.2.4». La testnet es una red de pruebas con sus propios parámetros de módulo (por ejemplo, una ventana de desafío por defecto de 3,600 segundos frente a 604,800 en la mainnet, y como máximo 200 rollups frente a 100); lee GET /qorechain/rdk/v1/params en la red a la que apuntas. Valida cada despliegue primero en la testnet.

Comisiones y firma

La red impone un precio de gas mínimo de 0.1uqor, por lo que un simple --fees 500uqor es rechazado, y toda transacción del carril nativo necesita la cofirma híbrida post-cuántica. Por eso los ejemplos de CLI de esta página construyen la transacción con --generate-only y la cofirman con qorechaind tx pqc cosign, que la firma y la difunde (crea la clave una sola vez con qorechaind tx pqc gen-key y regístrala on-chain una sola vez con qorechaind tx pqc register-key, o a través de QoreX o del SDK, que lo hacen por ti). La comisión queda fijada cuando se genera el archivo sin firmar, así que define el límite de gas y la comisión juntos: la comisión debe ser al menos el límite de gas × 0,1 uqor. Los límites de gas de abajo son orientativos — simula antes de fiarte de ellos. Consulta Primera transacción y Firma post-cuántica.


Requisitos​

RequisitoDetalles
Stake mínimoAl menos 10,000 QOR (min_stake_for_rollup); el stake se deposita en garantía (escrow) cuando se crea el rollup
Quema de creaciónEl 1 % del stake aportado se quema de forma permanente en la creación (una creación que no pueda aplicar la quema es rechazada); el resto queda en garantía y se devuelve cuando el rollup se detiene
Stake de registro de capaLa creación también registra la capa del rollup en el módulo multilayer, lo que bloquea otros 1,000 QOR (min_sidechain_stake) del creador, que se devuelven cuando la capa se desmantela al detener el rollup. Si la capa no puede registrarse (saldo insuficiente, o se alcanzó el límite de 10 sidechains de multilayer), el rollup se crea de todos modos pero no tiene capa, por lo que sus lotes no pueden anclarse
ID del rollupUsa de 3 a 64 caracteres: letras minúsculas, dígitos, ., _ y -, empezando por una letra o un dígito. La cadena impone esta regla en ambas redes desde la v3.2.2 (la CLI la comprueba antes de construir la transacción), por lo que un ID que no la cumpla es rechazado
CuentaUna cuenta de QoreChain con fondos y con una clave post-cuántica registrada, con saldo suficiente para el stake, el stake de la capa y las comisiones de transacción

Consulta los parámetros vivos del módulo para conocer el stake mínimo y la tasa de quema actuales antes de desplegar:

qorechaind query rdk config

Desplegar mediante el Dashboard (Tools → Rollups)​

El Dashboard ofrece un formulario Deploy a Rollup en Tools → Rollups. Es un formulario de solicitud: al enviarlo se registra una solicitud de aprovisionamiento para tu cuenta, revisada por The Qore Trust, y una solicitud nueva muestra el estado provisioning. No difunde una transacción create-rollup on-chain — para registrar un rollup on-chain, usa la CLI que sigue.

Pasos​

  1. Inicia sesión. El formulario requiere una sesión autenticada para enviar una solicitud y para listar tus solicitudes existentes.
  2. Ponle nombre a tu rollup. Introduce un nombre de rollup (2–41 caracteres: letras, números, espacios, guiones o guiones bajos).
  3. Elige una máquina virtual. El registro on-chain almacena una etiqueta de VM. Tu rollup se ejecuta off-chain en su propio runtime; la elección no se ejecuta en los propios carriles EVM, QoreChain Native o SVM de QoreChain:
    • EVM — contratos en Solidity / Vyper con todas las herramientas de Ethereum (Hardhat, Foundry, MetaMask)
    • QoreChain Native — contratos inteligentes en Rust sobre el runtime del Cosmos SDK (el runtime CosmWasm), con IBC nativo
    • SVM — la Solana Virtual Machine, para aplicaciones de alto rendimiento con ejecución en paralelo
  4. Elige una capa de disponibilidad de datos. Dónde publica tu rollup los datos de transacciones para que cualquiera pueda reconstruir el estado: QoreChain DA, Celestia o EigenDA. Ten en cuenta que EigenDA es una opción a nivel de Dashboard, mientras que los backends de DA on-chain de x/rdk son native, Celestia o ambos — consulta Disponibilidad de datos.
  5. Define un token de gas. El token que se usa para pagar la ejecución en tu rollup. Por defecto es QOR; introduce un símbolo personalizado para usar tu propio token nativo.
  6. Elige un secuenciador. Quién ordena las transacciones antes de la liquidación: Shared sequencer (el conjunto compartido de QoreChain), Dedicated (single) (ejecuta tu propio secuenciador único) o Decentralized (un conjunto de secuenciadores sin permisos).
  7. Elige un destino de liquidación. Dónde ancla el rollup sus raíces de estado y pruebas de validez: QoreChain mainnet o Ethereum.
  8. Envía la solicitud. El aprovisionamiento lo revisa The Qore Trust, por lo que una solicitud recién enviada aparece con estado provisioning hasta que la revisión termina.

Las solicitudes que envíes aparecen en la lista Your rollups con su VM, capa de DA, token de gas, secuenciador, destino de liquidación y estado actual.

nota

Las opciones del formulario (máquina virtual, capa de disponibilidad de datos, token de gas, secuenciador, destino de liquidación) describen lo que estás solicitando; son más amplias que lo que el módulo on-chain x/rdk admite actualmente. On-chain, la disponibilidad de datos es native (Celestia no está activo), y la secuenciación la realiza el creador del rollup o una dirección de secuenciador configurada. Consulta Disponibilidad de datos.


Desplegar mediante la CLI​

La CLI crea el rollup directamente on-chain. create-rollup toma tres argumentos posicionales — el ID del rollup, un perfil y el importe del stake (en uqor) — más un flag opcional --vm.

consejo

A partir de la versión de cadena v3.1.74, create-rollup aplica automáticamente el preset del perfil elegido — el modo de liquidación, el secuenciador, la DA, el modelo de gas y la VM se toman todos del preset. Ya no necesitas configurarlos a mano (antes el mensaje fijaba en el código una configuración soberana). El flag --vm ahora está vacío por defecto, de modo que se aplica la VM del perfil salvo que la sobreescribas explícitamente.

qorechaind tx rdk create-rollup [rollup-id] [profile] [stake-amount] \
--from mykey \
--chain-id qorechain-diana \
--gas 600000 --fees 60000uqor \
--generate-only > create-rollup.json

Ejemplo — crea un rollup a partir del preset defi (la liquidación, el secuenciador, la DA y la VM vienen todos del preset; defi se resuelve en liquidación zk sobre la EVM). Construye la transacción sin firmar y, después, añade la cofirma post-cuántica y difúndela:

# 1. Build the unsigned transaction (10,000 QOR stake)
qorechaind tx rdk create-rollup my-defi-rollup defi 10000000000 \
--from mykey \
--chain-id qorechain-diana \
--gas 600000 --fees 60000uqor \
--generate-only > create-rollup.json

# 2. Cosign with your post-quantum key and broadcast
qorechaind tx pqc cosign create-rollup.json \
--from mykey --pqc-key mypqckey --chain-id qorechain-diana

No crees todavía un rollup defi (ZK) en la mainnet. La cadena acepta la creación y deposita el stake en garantía. Los mensajes de verification key están habilitados en la mainnet desde la cadena v3.2.7 (12 de noviembre de 2026) y se aceptaron en la testnet, pero RDK 0.8.0 no tiene un constructor para ellos y no se ha probado ningún rollup ZK en ninguna de las dos redes. Por ahora elige un perfil optimistic como nft o custom (consulta ZK / STARK y retiros).

Flags:

FlagPor defectoDescripción
--vm(vacío — usa la VM del perfil)Sobreescribe el tipo de VM del rollup: evm, cosmwasm, svm o custom. Déjalo sin definir para aplicar la VM del preset. (En los clientes del RDK el runtime Wasm es el tipo de VM native — QoreChain Native — con cosmwasm mantenido como alias heredado; cosmwasm es el valor on-wire, que es lo que acepta este flag a nivel de cadena.)
La etiqueta de VM son metadatos

--vm registra qué runtime usa tu rollup. La cadena anfitriona solo liquida el rollup; no ejecuta sus contratos. La subida de QoreChain Native de la propia cadena anfitriona está actualmente cerrada y su carril de transacciones SVM está deshabilitado en toda la red, lo que no afecta a la liquidación de un rollup off-chain pero sí significa que no puedes desplegar contratos para un rollup en esos carriles de la cadena anfitriona.

El argumento [profile] selecciona una configuración preset que se aplica automáticamente — consulta Perfiles preconfigurados. El [stake-amount] es el bono en uqor; la quema de creación es el 1 % del mismo.

Inspecciona lo que has desplegado​

# Query a specific rollup by ID
qorechaind query rdk rollup my-defi-rollup

# List all registered rollups
qorechaind query rdk list-rollups

Desplegar con el RDK de TypeScript (@qorechain/rdk)​

El Rollup Development Kit se distribuye como dos paquetes públicos de npm para el mismo módulo on-chain x/rdk que la CLI. Todavía no existe ningún rollup en ninguna de las dos redes, así que ninguna vía de transacción del kit se ha ejercitado en un rollup en vivo; lee RDK 0.8.0: cambios y límites antes de fiarte de él para enviar transacciones:

  • @qorechain/rdk (v0.9.0) — el SDK de TypeScript: un constructor de configuración con perfiles preset, helpers de transacción para los ciclos de vida del rollup y de los lotes de liquidación, DA nativa, clientes de lectura tipados, recibos de liquidación con una firma ML-DSA-87, el QCAI Rollup Copilot, helpers de calldata cross-VM y el watchtower. Depende de @qorechain/sdk ^0.10.0 (desde la 0.7.0; la 0.6.x usaba ^0.9.0) y de @qorechain/evm ^0.8.0.
  • create-qorechain-rollup (v0.9.0) — un generador que clona una plantilla inicial ejecutable por perfil (incluida la plantilla multivm-rollup).

Están publicados en npm. El repositorio también incluye una CLI de operador publicada, @qorechain/rdk-cli (qorollup, v0.9.0), con los comandos doctor, create, status, watch, params, suggest, de ciclo de vida (pause/resume/stop), keygen, manifest, withdraw y faucet, además de los comandos receipt, advise y watchtower. Desde la 0.7.1 sus comandos de transacción firman en modo híbrido (véanse los límites más abajo).

Aspectos destacados por versión:

  • v0.4.2 — funciona contra la red en vivo sin configuración adicional. Los presets mainnet y testnet ahora incluyen los endpoints públicos de qore.host (REST en api.qore.host / api-testnet.qore.host), de modo que createRdkClient({ network }) alcanza la cadena sin endpoints manuales — sobreescríbelos solo para apuntar a tu propio nodo. La misma versión renombró el identificador de la VM de rollup Wasm a native (QoreChain Native); cosmwasm sigue siendo un alias heredado aceptado, y ambos se mapean a cosmwasm on-wire — la cadena, el explorador y el Dashboard no cambian.
  • v0.4.3 — actualización de dependencias por la corrección de la codificación de la firma híbrida del SDK. El propio cliente de transacciones del RDK seguía firmando solo en modo clásico.
  • v0.4.4 — sigue a @qorechain/sdk ^0.7.0, la versión del SDK para los carriles de autenticadores de la cadena v3.1.85. Sin cambios en la API del RDK.
  • v0.5.0 (18 de octubre de 2026) — la verificación de recibos de liquidación comprueba contra el estado de la cadena y nunca da por válido un recibo a partir de sus propios campos; el cliente de transacciones de TypeScript firma en modo híbrido cuando se le pasa un pqcKeypair. Depende de @qorechain/sdk ^0.8.0.
  • v0.6.0 (versión de GitHub del 20 de octubre de 2026) — la versión de compatibilidad para las versiones de cadena v3.2.2 a v3.2.4: lotes anclados, recibos de liquidación que pueden verificarse, ventanas de desafío medidas como las mide la cadena, un codificador que coincide con el formato cross-VM de la cadena, plantillas que firman en modo híbrido y @qorechain/sdk ^0.9.0. Los detalles están más abajo.
  • v0.6.1 (versión de GitHub del 25 de octubre de 2026) — una versión de correcciones de seguridad y de plantillas para la cadena v3.2.3 en adelante, en los cinco lenguajes: la verificación de recibos de liquidación compara todos los campos que declara el recibo con el ancla de la cadena, las seis plantillas iniciales ya no envían lotes que la cadena rechaza (dejan dataHash vacío) y las plantillas optimistas publican la raíz de estado canónica de la cadena en lugar de un marcador de posición. Mantiene los rangos @qorechain/sdk ^0.9.0 y @qorechain/evm ^0.8.0. Los detalles están más abajo.
  • v0.6.2 (versión de GitHub del 27 de octubre de 2026): una corrección urgente de la CLI sin cambios en las bibliotecas: qorollup instalado desde npm (local, global o con npx) vuelve a ejecutarse, y qorollup --version y create-qorechain-rollup --version imprimen sus versiones reales. Los demás paquetes se volvieron a publicar como 0.6.2 para que todos los registros se mantengan en una sola versión.
  • v0.7.0 (versión de GitHub del 27 de octubre de 2026): preparada para la cadena v3.2.5 en los cinco lenguajes (ambas redes la ejecutan, y también la v3.2.6 y la v3.2.7: la mainnet aplicó la v3.2.5 el 29 de octubre de 2026, la v3.2.6 el 4 de noviembre y la v3.2.7 el 12 de noviembre, la testnet la v3.2.5 el 26 de octubre y la v3.2.6 el 27 de octubre; la testnet ha pasado desde entonces a la v3.2.7 y después a la v3.2.8), y corrige cómo se calculan los hashes de los retiros y de los blobs de disponibilidad de datos: las pruebas de retiro construidas con los valores por defecto de la 0.6.x nunca se verificaban on-chain, y la 0.7.0 construye el árbol exacto de la cadena. Pasa a @qorechain/sdk ^0.10.0, y las plantillas fijan @qorechain/rdk ^0.7.0. Los detalles están más abajo.
  • v0.7.1 (versión de GitHub del 30 de octubre de 2026): una corrección urgente de la CLI de operador qorollup, cuyos comandos de transacción ahora firman en modo híbrido, como exigen ambas redes.
  • v0.8.0 (versión de GitHub del 30 de octubre de 2026): los clientes de Python, Go, Rust y Java también firman en modo híbrido, así que todos los clientes del RDK pueden enviar transacciones en la mainnet y la testnet. Se requiere Java 21.
  • v0.9.0 (versión de GitHub del 12 de noviembre de 2026; actual): admite la cadena v3.2.8 (la testnet la ejecuta desde el 12 de noviembre de 2026): publicación de datos del rollup, secuenciación basada, rollups optimistas qledger-v1 con pruebas de fraude, rollups privados, entradas ZK canónicas; la liquidación STARK está en pausa. Consulta las notas de la versión en GitHub. Una cuenta nueva debe registrar su clave post-cuántica en una transacción propia antes de hacer cualquier otra cosa; los clientes del RDK 0.9.0 hacen ese registro por ti.

Versiones publicadas (comprobadas en todos los registros el 12 de noviembre de 2026). npm @qorechain/rdk, @qorechain/rdk-cli y create-qorechain-rollup: 0.9.0 (latest); PyPI qorechain-rdk: 0.9.0; crates.io qorechain-rdk: 0.9.0; Maven Central io.github.qorechain:qorechain-rdk: 0.9.0 (las versiones anteriores siguen disponibles); módulo de Go github.com/qorechain/qorechain-rdk/packages/go: v0.9.0 (el @latest del proxy de módulos puede ir por detrás de una etiqueta nueva, así que fija @v0.9.0 de forma explícita). La versión de GitHub es v0.9.0.

RDK 0.8.0: cambios y límites​

Esta sección indica qué hacen los paquetes publicados 0.8.0 (y lo que cambiaron antes la 0.7.1, la 0.7.0, la 0.6.2, la 0.6.1 y la 0.6.0), comprobado contra el contenido de los paquetes y las notas de la versión de GitHub, y qué siguen sin poder hacer. Ninguno de estos puntos es un comportamiento de la cadena. Donde una frase dice «no probado en vivo», no existe ningún rollup en ninguna de las dos redes, así que la vía solo se ha comprobado contra el código y sin conexión.

Qué cambiaron la 0.8.0 y la 0.7.1 (las notas de la versión 0.8.0 y 0.7.1 tienen la lista completa). Ambas redes exigen una firma híbrida (ML-DSA-87 + secp256k1) en las transacciones del carril nativo.

  • 0.7.1: las transacciones de qorollup se aceptan. create, pause, resume, stop y withdraw firmaban solo en modo clásico en la 0.7.0 y anteriores, así que las redes rechazaban todas. La CLI ahora firma en modo híbrido. Resuelve la clave post-cuántica como lo hacen las plantillas: derivada de --mnemonic o QORE_MNEMONIC y contrastada con la clave que la cadena tiene registrada, o tomada de --pqc-seed o QORE_PQC_SEED_HEX junto con --key. Sin una clave se niega a enviar en lugar de pagar una transacción rechazada.
  • 0.7.1: corrección de paridad en Python. transition_root_version_for_batch, RestClient.get_applied_plan_height y BatchView.withdrawals_bound ahora también están en el cliente de Python (las notas de la 0.6.1 habían contado la primera en los cinco lenguajes; estaba en cuatro).
  • 0.8.0: Python, Go, Rust y Java firman en modo híbrido. Antes, solo funcionaban sus lecturas en la mainnet y la testnet. Cada uno firma ahora en modo híbrido cuando se le da un par de claves post-cuántico, mediante su propio SDK de QoreChain publicado (0.10.x), con la forma de los bytes a firmar (v1 o v2) resuelta desde la cadena. Las notas de la versión indican que todos los clientes producen transacciones idénticas byte a byte a las del cliente de TypeScript para la misma entrada (un fixture compartido contiene cuatro transacciones híbridas que cada lenguaje reproduce exactamente).
  • 0.8.0: resolución de claves en todos los lenguajes, igual que en TypeScript: a partir de un mnemónico, con la derivación canónica o la heredada, la que la cadena tenga registrada; o una semilla de 32 bytes de QORE_PQC_SEED_HEX, contrastada con la clave registrada. Python resolve_pqc_keypair / pqc_keypair_from_env, Go ResolvePqcKeypair / PqcKeypairFromEnv, Rust resolve_pqc_keypair / pqc_keypair_from_env, Java Accounts.resolvePqcKeypair / pqcKeypairFromEnv.
  • 0.8.0: se requiere Java 21 (antes 17), porque el SDK de Java de QoreChain del que depende lo necesita.
  • 0.8.0: nuevas dependencias. qorechain-sdk 0.10.x en PyPI, el módulo de Go github.com/qorechain/qorechain-sdk/packages/go v0.10.0, qorechain-sdk 0.10 en crates.io (Rust pasa a cosmrs 0.22) e io.github.qorechain:qorechain-sdk [0.10.0,0.11) en Maven. Las plantillas fijan @qorechain/rdk ^0.8.0.
  • 0.8.0: RdkTxClient.Sign de Go devuelve ([]byte, error), porque la firma híbrida puede fallar. Esto rompe el código de Go que usaba el antiguo valor de retorno único.
  • No probado en vivo. No existe ningún rollup en ninguna de las dos redes, así que ninguna transacción híbrida de ningún cliente se ha enviado a través de un rollup en vivo.

Qué cambió en la 0.7.0 (los cinco lenguajes, salvo que una línea indique otra cosa; las notas de la versión tienen la lista completa). El comportamiento que pertenece a la cadena v3.2.5 está etiquetado con su red: ambas redes ejecutan la v3.2.5 o posterior (la mainnet ejecuta la v3.2.7 desde el 12 de noviembre de 2026, la testnet la v3.2.8 desde el 12 de noviembre).

  • Las pruebas de retiro se verifican on-chain. Los helpers de Merkle y de retiros usaban SHA-256 por defecto y volvían a calcular el hash de cada hoja, mientras que la cadena calcula el hash de los nodos con SHAKE-256 y construye sus hojas a partir del propio retiro, así que una prueba construida con los valores por defecto de la 0.6.x nunca se verificaba. withdrawalsTree ahora construye la raíz de retiros de un lote y cada prueba exactamente como lo hace la cadena (la posición de la hoja es el índice del retiro): con hojas de primera forma, o con hojas de segunda forma que además nombran el ID de cadena, que la cadena usa para los lotes desde la v3.2.5 (ambas redes). withdrawalLeafV1 y withdrawalLeafV2 construyen una hoja, assembleWithdrawalProof construye por defecto el árbol de la cadena, y los helpers genéricos de Merkle usan SHAKE-256 por defecto. Es un cambio incompatible para el código que dependía de los valores por defecto de SHA-256 (pasa hash explícitamente para conservarlos). Los nuevos formatos de bytes se probaron con vectores producidos por el propio código de la cadena, y el verificador de la cadena acepta todas las pruebas de retiro de esos vectores. Consulta Codificación de hojas y nodos.
  • qorollup withdraw comprueba antes de pagar. Toma los retiros del lote (qorollup withdraw --file withdrawal.json [--dry-run]), construye la prueba bajo el propio vínculo del lote y se niega, antes de pagar una comisión, cuando el resultado no es el withdrawals_root on-chain del lote.
  • buildDaBlob se compromete como lo hace la cadena. Su compromiso es SHAKE-256, no SHA-256 (ninguna transacción publica un blob, así que dataHash sigue quedando vacío).
  • Watchtower. El Watchtower distinguía los lotes solo por el índice, así que se le escapaba un lote reenviado en un índice rechazado. Desde la cadena v3.2.5 (ambas redes), un fraude confirmado rechaza el lote y todos los posteriores aún no finalizados, y el secuenciador los reenvía bajo los mismos índices; el Watchtower ahora distingue los lotes por índice y raíz de estado y nunca valida un lote rechazado. Nuevos helpers transitionRootValidator (un predicado validate que aplica la regla de fraude de la cadena) y fraudProofForBatch (la prueba que gana, o ninguna para un lote honesto), y qorollup watchtower --canonical, que informa de los lotes que un desafío ganaría.
  • Helpers de liquidación de la cadena v3.2.5 (ambas redes): getRollupHealth informa de heldBackBy cuando el último lote podría finalizar con su propia ventana pero un lote anterior sigue en submitted o challenged (los lotes finalizan en orden), y qorollup status lo imprime; stopRollupError y una comprobación previa en stopRollup (TypeScript y Rust), porque un rollup cuyo último lote está en submitted o challenged no puede detenerse; MAX_PENDING_OPTIMISTIC_BATCHES (4,096); withdrawalsRootError (una raíz de retiros está vacía o tiene exactamente 32 bytes), comprobado antes de cada envío de lote en los cinco lenguajes.
  • Helpers cross-VM para la cadena v3.2.5 (ambas redes): getCrossVmParams (la lista de permitidos, en /qorechain/crossvm/v1/params), crossVmTargetReady (precompile activo, puente habilitado y destino en la lista de permitidos, con el motivo del bloqueo), decodeCrossVmResult (la respuesta es abi.encode(bytes)) y decodeRevertReason (un rechazo es Error(string)), comprobados contra codificaciones que produjo Solidity. Consulta Multi-VM.
  • Decodificación de errores y pequeñas adiciones. decodeRdkTxError y RDK_ERRORS nombran los códigos de error del módulo rdk (2 a 36) y qué hacer con los que se encuentra un operador; qorehash (SHAKE-256, 32 bytes) se exporta en los cinco lenguajes; FEATURE_RDK_CHALLENGE_SETTLEMENT nombra el indicador de función de la cadena.
  • La plantilla defi se detiene antes de malgastar una comisión. Ninguna versión de la cadena hasta la v3.2.6 puede registrar una verification key de ZK, así que todo lote ZK era rechazado allí. La plantilla ahora se detiene antes de enviar, y RollupView.hasVerificationKey lee un campo pensado para la cadena v3.2.7 (testnet desde el 6 de noviembre, mainnet desde el 12 de noviembre de 2026); no se pudo comprobar con un rollup en vivo porque no existe ninguno.
  • Dependencias. @qorechain/sdk ^0.10.0 (antes ^0.9.0), así que una aplicación con el SDK 0.10.0 ahora comparte una sola copia del SDK con el kit; las plantillas fijan @qorechain/rdk ^0.7.0 (^0.8.0 desde la 0.8.0).

Qué cambió en la 0.6.2 (solo la CLI y el generador de plantillas; los paquetes de biblioteca no cambian):

  • qorollup se ejecuta al instalarse desde npm. La CLI solo arrancaba cuando process.argv[1] era igual a la ruta de su propio archivo, pero npm inicia el bin de un paquete mediante un enlace simbólico en node_modules/.bin, así que la 0.6.1 y anteriores, instaladas localmente, globalmente o ejecutadas con npx, terminaban con código 0 sin imprimir nada; solo funcionaba node .../dist/index.js. La 0.6.2 compara rutas reales. Tras npm i -g @qorechain/rdk-cli, qorollup ... funciona.
  • Las versiones se imprimen correctamente. qorollup --version imprimía 0.4.1 y create-qorechain-rollup --version imprimía 0.2.0 en versiones anteriores; ahora ambos leen su propio package.json (comprobado el 27 de octubre de 2026: qorollup --version imprime 0.6.2).

Qué cambió en la 0.6.1 (los cinco lenguajes, salvo que una línea indique otra cosa; las notas de la versión tienen la lista completa):

  • La verificación de recibos compara todos los campos. verifySettlementReceipt ahora exige que todo campo de ancla que declara el recibo sea igual al ancla de la cadena (una discrepancia nombra el campo), exige que batchStateRoot sea igual a la raíz del lote de la cadena, y rechaza un recibo con una version desconocida o un algorithm distinto de ML-DSA-87 antes de leer nada de la cadena. El resultado incluye el anchor coincidente de la cadena y, cuando es válido, un verifiedReceipt reconstruido a partir del estado de la cadena; qorollup receipt verify --json devuelve ese recibo leído de la cadena como receipt. Consulta Recibos de liquidación.
  • Disponibilidad de datos nativa: deja dataHash vacío. Todos los perfiles de rollup usan disponibilidad de datos native, donde la cadena acepta un data_hash no vacío solo cuando hay un blob coincidente almacenado on-chain, y ninguna transacción puede almacenar uno (consulta Disponibilidad de datos). Las seis plantillas iniciales ponían un hash de datos en sus lotes en la 0.6.0 y anteriores, así que la cadena rechazaba todos los lotes de las plantillas después de pagar la comisión. Ahora lo dejan vacío; SubmitBatchInput.dataHash es opcional en TypeScript (omitido significa vacío), dataHashError (data_hash_error, DataHashError, Rules.dataHashError) expone la regla, y RdkTxClient.submitBatch rechaza un lote así antes de difundirlo cuando puede leer el rollup (un cliente híbrido con un endpoint REST).
  • Las plantillas optimistas publican la raíz de estado canónica. La cadena juzga un lote optimista por su raíz de transición canónica, un compromiso SHAKE-256 de la raíz de estado previa del lote, su hash de datos y su número de transacciones (batchTransitionRoot en el RDK, con transitionRootVersionFor eligiendo el enlace que aplica la red conectada). Las plantillas custom, multivm y nft solían enviar una raíz fija de marcador de posición, que no coincide con la raíz canónica que comprueba la cadena; ahora publican la raíz canónica y ya no envían una prueba de marcador de posición. El challenge.ts de la plantilla nft lee el lote de la cadena y desafía solo un lote cuya raíz es demostrablemente errónea. No reimplementes la fórmula a mano: usa batchTransitionRoot para que el enlace coincida con la red a la que envías. La comprobación de la propia cadena es la misma para todos los clientes, así que un lote optimista cuya raíz de estado no es la raíz canónica puede ser desafiado con éxito, sea cual sea el cliente que lo envió.
  • Nuevos helpers. fraudProof, transitionRootVersionForBatch, receiptSchemaError con SUPPORTED_RECEIPT_VERSIONS, RestClient.getProtocolFeatures / isProtocolFeatureEnabled (una cadena sin la ruta se lee como «no habilitado») y getAppliedPlanHeight. @qorechain/rdk ahora depende de @noble/hashes directamente (SHAKE-256 para la raíz de transición; ya estaba instalado a través de @qorechain/sdk). Las plantillas fijan @qorechain/rdk ^0.6.1.

Qué cambió en la 0.6.0 (TypeScript, salvo que una línea indique otra cosa):

  • Firma. RdkClient.connectTx(signer, { pqcKeypair, rest }) firma en modo híbrido (secp256k1 + ML-DSA-87) cuando le pasas un par de claves; sin él firma solo en modo clásico y las redes rechazan la transacción. signer debe ser un OfflineDirectSigner, y la comisión debe ser explícita (una fee, o un gasPrice al conectar). Los nuevos helpers resolvePqcKeypair y pqcKeypairFromEnv derivan a partir de un mnemónico tanto la clave ML-DSA-87 canónica como la heredada y usan la que la cuenta tenga registrada on-chain; se niegan, en lugar de adivinar, cuando la cuenta tiene una clave distinta. QORE_PQC_SEED_HEX aporta una semilla para un operador que firma con una clave privada en bruto. El kit ahora depende de @qorechain/sdk ^0.9.0, así que una instalación nueva contiene una sola copia del SDK (0.9.0); con la 0.5.0, npm instalaba el SDK 0.8.3 anidado bajo el kit.
  • Lotes anclados. MsgSubmitBatch lleva anchor_signature y validator_set_hash. RdkTxClient.submitBatch firma el ancla por sí mismo solo cuando el cliente firma en modo híbrido, tiene un endpoint REST y es el creador del rollup (la cadena comprueba el ancla contra la clave registrada del creador); en cualquier otro caso envía sin anclar, como antes. Pasa anchor: "require" para negarte en lugar de enviar sin anclar, anchor: "off" para no firmar nunca, o anchorSignature para enviar una firma que hayas obtenido tú mismo. anchorSignBytesForBatch construye los bytes v2 para un creador que firma fuera de banda, algo que necesita un rollup con un secuenciador distinto. No probado en vivo.
  • Recibos de liquidación. La consulta de cuenta PQC usa la ruta en singular /qorechain/pqc/v1/account/{address} (la 0.5.0 usaba una ruta en plural que las redes no sirven). La verificación admite ambas formas de sign-bytes del ancla y elige una según la altura del ancla, nunca probando las dos: v1 por debajo del cambio de la v3.2.2, v2 a partir de él. El esquema de recibo v2 registra chainId; la verificación rechaza un recibo comprobado contra un nodo de otra cadena, e informa de signBytesVersion y de una comprobación chainBinding. Los recibos de versión 1 siguen verificándose. Consulta Recibos de liquidación.
  • Lecturas. getLatestBatch llama a /qorechain/rdk/v1/latest_batch/{rollup_id} (la 0.5.0 llamaba a una forma que la cadena no sirve), y listBatches recorre todas las páginas (listBatchesPage lee una). RollupView incluye escrowBalance y, cuando el nodo los informa, challengeWindowSec, challengeBond y proofSystem; BatchView incluye submittedTime.
  • Ventanas de desafío. batchChallengeWindow calcula la ventana de un lote como lo hace la cadena y la juzga contra la punta de la cadena (getChainTip), no contra el reloj local: segundos de tiempo de bloque para un lote que tiene un tiempo de envío registrado (la regla de la v3.2.4: la testnet desde la altura 8,337,253, la mainnet desde la altura 3,742,566), y window / 6 bloques contados desde la altura de envío en caso contrario (la regla para los lotes enviados antes de la altura de la actualización). La comprobación de salud que hay detrás de qorollup status y el watchtower la usan (consulta Watchtower).
  • Cross-VM. encodeCrossVmCalldata ahora codifica executeCrossVMCall(uint8,string,bytes), el formato que decodifica el nodo, y recibe un targetVm. isCrossVmPrecompileActive lee la lista en vivo de precompiles activos (consulta Multi-VM).
  • Reglas comprobadas antes de pagar una comisión. rollupIdError comprueba la gramática del ID al validar una configuración y antes de que createRollup difunda; withdrawalErrors comprueba un retiro antes de que executeWithdrawal difunda.
  • Plantillas. Las plantillas generadas se conectan mediante pqcKeypairFromEnv, así que sus scripts create y submit-batch firman en modo híbrido, y dependían de @qorechain/rdk ^0.6.0 (^0.6.1 desde el generador 0.6.1). La plantilla multivm-rollup comprueba que el precompile esté activo y exige una respuesta no vacía del destino.
  • Python, Go, Rust y Java. Las correcciones del lado de lectura anteriores (ruta PQC en singular, latest_batch, sign-bytes v2 del ancla, reglas de la ventana de desafío, comprobaciones de ID y de retiro) también están en los paquetes publicados de los otros cuatro lenguajes.
  • Cambios incompatibles. encodeCrossVmCalldata recibe targetVm, y CROSS_VM_DEFAULT_SIGNATURE cambió. RollupHealth y BatchDeadline incluyen un challengeWindow en lugar del antiguo plazo basado en segundos.

Límites que se mantienen en la 0.8.0:

  • La liquidación ZK no se ha probado en ninguna de las dos redes. Afecta al perfil defi, a la plantilla defi-rollup y a todo rollup creado con liquidación zk: los mensajes de verification key están habilitados en la mainnet desde la cadena v3.2.7 (12 de noviembre de 2026) y en la testnet desde el 6 de noviembre de 2026, pero no se ha creado ningún rollup ZK y RDK 0.8.0 no tiene un constructor para los mensajes. Usa la liquidación optimistic por ahora (consulta ZK / STARK y retiros).

  • El circuito de demostración de la plantilla defi no puede verificarse. Es un circuito multiplicador de snarkjs, mientras que la cadena comprueba Groth16 sobre BLS12-381 con tres entradas públicas (la raíz de estado previa, la nueva raíz de estado y el hash de datos). Incluso cuando exista el registro de claves, una prueba del circuito de demostración no pasaría; sustituye el circuito por tu propio circuito de transición de estado.

  • Corregido en la 0.7.0: helpers de Merkle de retiros. En la 0.6.2 y anteriores los helpers usaban SHA-256 por defecto y una prueba construida con los valores por defecto nunca se verificaba on-chain; usa withdrawalsTree / assembleWithdrawalProof desde la 0.7.0 (consulta Codificación de hojas y nodos).

  • La firma híbrida necesita tu clave post-cuántica. Todos los clientes (TypeScript, la CLI qorollup desde la 0.7.1, y Python, Go, Rust y Java desde la 0.8.0) firman en modo híbrido solo cuando tienen un par de claves post-cuántico; sin uno, una transacción es solo clásica y ambas redes la rechazan. Las versiones anteriores a esas firman solo en modo clásico, así que la CLI anterior a la 0.7.1 y los clientes de Python, Go, Rust y Java anteriores a la 0.8.0 no pueden enviar una transacción que las redes acepten. Los constructores de mensajes de Python no tienen ningún campo anchor_signature ni validator_set_hash (comprobado en el código fuente de la 0.8.0; no comprobado en los otros tres), así que para un lote anclado desde Python construye y firma con la CLI de la cadena (--generate-only, y después qorechaind tx pqc cosign) o usa el cliente de TypeScript con un pqcKeypair.

  • No se ha ejercitado en vivo ninguna creación híbrida de un rollup, porque no existe ningún rollup en ninguna de las dos redes. Lo mismo vale para los lotes anclados, los retiros y todo el flujo de recibos.

  • El anclaje necesita al creador. Un lote se ancla en la misma transacción solo si la firma del creador va en ella. Si el secuenciador es otra dirección, el creador tiene que firmar los bytes v2 fuera de banda y el secuenciador envía el resultado.

  • El precompile cross-VM en 0x…0901 no está activo en la mainnet, así que una llamada desde un contrato no hace nada allí. En la testnet está activo con una lista de permitidos, y se probó una llamada con eth_call el 7 de noviembre de 2026 (consulta Multi-VM).

  • Duración de la ventana de desafío. El kit lee la ventana propia de un rollup solo cuando el nodo la informa (el paquete lo documenta como v3.2.4 y posteriores, que ejecutan ambas redes). En caso contrario usa la ventana por defecto del módulo; pasa challengeWindowSecs para un rollup que configuró la suya. Los helpers antiguos challengeWindowDeadline e isChallengeWindowClosed siguen exportándose y siguen recibiendo segundos, así que no les pases una altura de bloque.

  • Disponibilidad de datos. Ninguna transacción publica un blob, así que un lote en un rollup native o both debe dejar dataHash vacío (consulta Disponibilidad de datos). buildDaBlob calculaba el hash con SHA-256 en la 0.6.2 y anteriores; desde la 0.7.0 su compromiso es el SHAKE-256 de la cadena.

Versiones anteriores a la 0.8.0. La 0.7.0 y anteriores no pueden enviar transacciones de qorollup que las redes acepten (corregido en la 0.7.1), y antes de la 0.8.0 los clientes de Python, Go, Rust y Java no podían enviar ninguna transacción. La 0.6.2 y anteriores construyen pruebas de retiro que nunca se verifican on-chain y calculan el hash de buildDaBlob con SHA-256; usa la 0.8.0. La 0.6.1 y anteriores instalaban la CLI qorollup desde npm en un estado en el que no imprimía nada y terminaba con código 0 (corregido en la 0.6.2). La 0.6.0 compara menos campos que la 0.6.1 en la verificación de recibos y distribuye plantillas que envían lotes que la cadena rechaza (un hash de datos en un rollup con DA nativa, una raíz de estado de marcador de posición en los optimistas). La 0.5.0 y las anteriores no deben usarse para recibos de liquidación, el watchtower ni el calldata cross-VM: la 0.5.0 buscaba la clave del creador en una ruta que las redes no sirven (así que la verificación de recibos fallaba en modo cerrado con todos los recibos genuinos), reconstruía solo el mensaje de ancla v1, leía una altura de bloque como una marca de tiempo (toda edad de lote y todo plazo de desafío eran erróneos, y el watchtower lanzaba de inmediato su alerta de plazo para cada lote), llamaba a una ruta de último lote que la cadena no sirve, leía solo los primeros 50 lotes, codificaba una función que el precompile no decodifica y distribuía plantillas que firmaban solo en modo clásico. La 0.4.x no tenía firma híbrida en el cliente de transacciones.

Clientes de Python, Go, Rust y Java​

Junto al paquete de TypeScript, el RDK ofrece clientes completos de Python, Go, Rust y Java que reflejan la superficie de TypeScript: el constructor de configuración con validación, los cinco perfiles preset, utilidades de denominación/economía/bech32, helpers de Merkle binario y de pruebas de retiro, manifiestos de rollup, clientes de lectura REST y JSON-RPC qor_, comprobaciones de preflight/salud, cuentas (mnemónico → dirección qor) y, desde la 0.8.0, firma híbrida de transacciones + difusión (ML-DSA-87 + secp256k1, como exigen ambas redes; antes de la 0.8.0 firmaban solo en modo clásico y solo funcionaban sus lecturas — consulta RDK 0.8.0: cambios y límites). Todos están verificados contra vectores dorados compartidos entre lenguajes y están publicados en sus registros:

# Python — installs as qorechain-rdk, imports as qorrdk
pip install qorechain-rdk

# Rust
cargo add qorechain-rdk

# Go (pin the version)
go get github.com/qorechain/qorechain-rdk/packages/go@v0.9.0

# Java (Maven / Gradle)
# io.github.qorechain:qorechain-rdk:0.9.0 (requiere Java 21)
import qorrdk

Versiones publicadas actuales, todas 0.9.0 (comprobadas el 12 de noviembre de 2026): Python qorechain-rdk (PyPI, se importa como qorrdk), el módulo de Go github.com/qorechain/qorechain-rdk/packages/go (v0.9.0), Rust qorechain-rdk (crates.io) y Java io.github.qorechain:qorechain-rdk (Maven Central; Java 21 o posterior desde la 0.8.0). Estos clientes leen el estado de la cadena y, desde la 0.8.0, envían transacciones firmadas en modo híbrido cuando les das un par de claves post-cuántico (consulta RDK 0.8.0: cambios y límites).

nota

El RDK de TypeScript y sus plantillas apuntan por defecto a la testnet qorechain-diana, y los presets alcanzan los endpoints públicos en vivo sin configuración adicional. Fija las versiones y valida en la testnet antes de mainnet.

Genera un proyecto con create-qorechain-rollup​

Cada perfil tiene una plantilla inicial correspondiente (defi-rollup, gaming-rollup, nft-rollup, enterprise-rollup, custom-rollup). Genera una con cualquiera de estas dos formas:

npm create qorechain-rollup my-rollup
# or
npx create-qorechain-rollup my-rollup

Para uso no interactivo / CI, pasa la plantilla y la red de forma explícita:

npx create-qorechain-rollup my-rollup --template defi-rollup --network testnet --yes

El generador imprime el coste documentado de stake y quema de creación, y los siguientes pasos para crear tu rollup y leer su estado.

Qué pueden hacer los scripts generados

Las plantillas de create-qorechain-rollup 0.9.0 dependen de @qorechain/rdk ^0.9.0. Sus scripts create y submit-batch se conectan mediante connectOperator() en src/signer.ts, que resuelve tu clave post-cuántica a partir de QORE_MNEMONIC (o de QORE_PQC_SEED_HEX cuando firmas con QORE_OPERATOR_PRIVATE_KEY_HEX), la comprueba contra la cadena y firma en modo híbrido; si no se define ninguna de las dos, el script avisa y firma solo en modo clásico, que ambas redes rechazan. No se ha creado ningún rollup a través de una plantilla en una red en vivo, así que esta vía no está probada en vivo. El script submit-batch de la plantilla es solo un flujo de referencia: desde la 0.6.1 deja dataHash vacío (la cadena rechaza un hash de datos en un rollup con DA nativa) y las plantillas optimistas publican la raíz de estado canónica en lugar de un marcador de posición; sigue usando valores ilustrativos para el resto, y no se espera que finalice un lote en una red en vivo. La plantilla defi-rollup (ZK) se detiene antes de enviar un lote desde la 0.7.0, porque la cadena lo rechazaría (consulta ZK / STARK y retiros).

Construye una configuración de rollup desde código​

Construye una configuración a partir de un preset, lee de la cadena el stake y la tasa de quema en vivo y produce el mensaje de creación. El constructor de configuración impone la matriz de compatibilidad liquidación → prueba en validate() / build(). Envía los valores resultantes con la CLI de arriba, o con el cliente de TypeScript al que se le pasa un pqcKeypair — consulta RDK 0.8.0: cambios y límites.

import { createRdkClient, presets, estimateCreationCost, uqorToQor } from "@qorechain/rdk";

// A config builder pre-filled with the defi preset's defaults; override via .set({ ... }).
const config = presets.defi({ rollupId: "my-defi-rollup" }).validate();

// The public qore.host endpoints are baked into the presets (RDK ≥ 0.4.2).
// `params()` is a REST read of /qorechain/rdk/v1/params, served on both networks.
const rdk = createRdkClient({ network: "testnet" });

// Read the live module parameters — never hardcode the stake or burn rate.
const params = await rdk.params();
const cost = estimateCreationCost({
stakeUqor: params.minStakeForRollup,
burnRate: params.rollupCreationBurnRate,
});
console.log(`Stake: ${uqorToQor(cost.stakeUqor)} QOR — burned: ${uqorToQor(cost.burnUqor)} QOR`);

// The values to pass to `qorechaind tx rdk create-rollup`.
const msg = config.toCreateMsg("<your qor address>", { stakeAmount: params.minStakeForRollup });
console.log(msg.rollupId, msg.profile, msg.vmType, msg.stakeAmount);

¿No sabes qué perfil encaja? rdk.suggestProfile(...) está pensado para devolver una recomendación asistida por QCAI; en los endpoints públicos actuales siempre devuelve el respaldo defi (source: "fallback"), así que elige a partir de la tabla de perfiles.

Lee el estado desde código​

El cliente REST tipado no requiere firmante y lee ambas redes:

const rollup = await rdk.rest.getRollup("my-defi-rollup");
console.log(rollup.status, rollup.settlementMode, rollup.daBackend, rollup.vmType);

Para los lotes, usa rdk.rest.getBatch(rollupId, index) o qorechaind query rdk batch [rollup-id] (más abajo); desde la 0.6.0, getLatestBatch y listBatches leen la ruta latest_batch de la cadena y todas las páginas de la lista de lotes (consulta RDK 0.8.0: cambios y límites).


Gestión del ciclo de vida​

Un rollup pasa por los estados pending, active, paused y stopped; un rollup nuevo empieza active de inmediato. Solo el creador puede pausarlo, reanudarlo o detenerlo (se impone desde la versión de cadena v3.2.0). Cada comando de abajo sigue el mismo patrón de dos pasos que la creación: genera la transacción sin firmar y luego cofírmala.

Pausar​

Detén temporalmente el rollup. El estado se conserva y el rollup puede reanudarse. Se requiere una cadena de texto con el motivo.

qorechaind tx rdk pause-rollup [rollup-id] [reason] \
--from mykey \
--chain-id qorechain-diana \
--gas 400000 --fees 40000uqor \
--generate-only > pause.json
qorechaind tx pqc cosign pause.json --from mykey --pqc-key mypqckey --chain-id qorechain-diana

Reanudar​

Reanuda un rollup pausado previamente.

qorechaind tx rdk resume-rollup [rollup-id] \
--from mykey \
--chain-id qorechain-diana \
--gas 400000 --fees 40000uqor \
--generate-only > resume.json
qorechaind tx pqc cosign resume.json --from mykey --pqc-key mypqckey --chain-id qorechain-diana

Detener​

Desmantela permanentemente el rollup y libera su stake. El QOR en stake — menos la quema única de creación y menos cualquier cantidad ya pagada desde la garantía del rollup por retiros o recompensas de pruebas de fraude — se devuelve al creador: desde la v3.2.3, un libro de garantía por rollup registra lo que cada rollup conserva todavía, stop-rollup reembolsa exactamente ese saldo, y un rollup detenido no paga más retiros. El stake de registro de capa de 1,000 QOR se devuelve por separado cuando se desmantela la capa del rollup.

Desde la cadena v3.2.5 (ambas redes): un rollup no puede detenerse mientras su último lote esté en submitted o challenged, así que primero hay que liquidarlo o finalizarlo; un rollup detenido libera su plaza dentro del límite de rollups del módulo. Antes de la v3.2.5 no se aplicaba ninguna de las dos reglas. Desde TypeScript, stopRollupError y la comprobación previa de stopRollup te avisan antes de que pagues la comisión.

qorechaind tx rdk stop-rollup [rollup-id] \
--from mykey \
--chain-id qorechain-diana \
--gas 400000 --fees 40000uqor \
--generate-only > stop.json
qorechaind tx pqc cosign stop.json --from mykey --pqc-key mypqckey --chain-id qorechain-diana
peligro

Detener un rollup es permanente. El rollup no puede reiniciarse una vez detenido.


Comandos del operador: lotes y desafíos​

Los operadores de rollups envían lotes de liquidación, y los desafiantes pueden disputar los lotes optimistas. Estos comandos sustentan la capa de liquidación descrita en Visión general de rollups y ZK / STARK y retiros.

Quién puede enviar y en qué orden​

  • Solo la dirección de secuenciador configurada del rollup — o, cuando no hay ninguna configurada (todos los presets), su creador — puede enviar lotes. La secuenciación based y la compartida todavía no admiten conjuntos de proponentes ni listas: hoy son etiquetas, y envía el creador.
  • Los lotes forman una cadena: el primer lote tiene el índice 0; cada lote posterior debe usar el siguiente índice y llevar la raíz de estado del lote anterior como prev_state_root.
  • Un lote que lleva un hash de datos en un rollup native o both es rechazado a menos que ya esté almacenado un blob coincidente (consulta Disponibilidad de datos). Un lote sin hash de datos no se comprueba.
  • Un rollup zk debe adjuntar una prueba, y la prueba debe verificarse; todavía no se puede aceptar ningún lote ZK (consulta ZK / STARK y retiros).
  • Desde la cadena v3.2.5 (ambas redes): el withdrawals_root de un lote debe estar vacío o tener exactamente 32 bytes, y un rollup mantiene como máximo 4,096 lotes optimistas pendientes (MAX_PENDING_OPTIMISTIC_BATCHES en el RDK); además, los lotes finalizan por orden de índice, así que un lote posterior espera a uno anterior que sigue en submitted o challenged. El RDK comprueba la longitud de la raíz antes de cada envío. Antes de la v3.2.5 no se aplicaba ninguna de estas tres reglas.

Enviar un lote​

Envía un lote de liquidación para un rollup. Toma el ID del rollup, un índice de lote y una raíz de estado codificada en hexadecimal. Para cada lote posterior al primero, pasa la raíz de estado del lote anterior como --prev-state-root.

qorechaind tx rdk submit-batch [rollup-id] [batch-index] [state-root-hex] \
--prev-state-root <previous-state-root-hex> --tx-count 120 \
--from mykey \
--chain-id qorechain-diana \
--gas 400000 --fees 40000uqor \
--generate-only > batch.json
qorechaind tx pqc cosign batch.json --from mykey --pqc-key mypqckey --chain-id qorechain-diana
FlagDescripción
--prev-state-rootRaíz de estado hexadecimal desde la que parte el lote (obligatoria para todo lote posterior al índice 0)
--tx-countNúmero de transacciones del rollup en el lote
--data-hashHash hexadecimal de los datos del lote publicados como blob de DA (déjalo vacío hoy: no hay forma de publicar un blob, consulta Disponibilidad de datos)
--withdrawals-rootRaíz de Merkle hexadecimal de los retiros L2 → L1 del lote (consulta ZK / STARK y retiros)
--anchor-signatureFirma ML-DSA-87 hexadecimal del creador del rollup sobre los bytes de firma de ancla v2 (desde la v3.2.2); el lote se ancla entonces en x/multilayer en la misma transacción, y un ancla rechazada rechaza el lote
--validator-set-hashCompromiso hexadecimal del conjunto de validadores que lleva el ancla y que cubre la firma

Sin --anchor-signature el lote se liquida sin anclar. Para anclar un lote, imprime los bytes a firmar, fírmalos con la clave post-cuántica registrada del creador y pasa la firma (los valores de --tx-count y --validator-set-hash deben coincidir con los que envíes):

qorechaind query rdk anchor-sign-bytes [layer-id] [batch-index] [state-root-hex] \
--chain-id qorechain-diana --tx-count 120

layer-id es el ID de capa del rollup (el ID del rollup en los rollups creados por el RDK). Desde TypeScript, RdkTxClient.submitBatch de @qorechain/rdk 0.6.0 y posteriores firma el ancla por ti cuando el cliente firma en modo híbrido y es el creador del rollup, y anchorSignBytesForBatch da a un creador los bytes que firmar fuera de banda (consulta RDK 0.8.0: cambios y límites). El --proof ZK de un rollup zk no tiene hoy ningún flag de CLI, y el mensaje de resolución de desafío no es un comando de CLI: usa un cliente. Consulta Recibos de liquidación para saber qué prueba y qué no prueba un ancla. Todavía no existe ningún rollup, capa ni ancla en ninguna de las dos redes.

Desafiar un lote (rollups optimistas)​

Cualquier cuenta puede desafiar un lote submitted dentro de la ventana de desafío (100,800 bloques por defecto para un lote enviado en mainnet antes de la altura 3,742,566; desde la v3.2.4, una ventana en segundos de tiempo de bloque para los lotes nuevos: en la testnet desde la altura 8,337,253, en mainnet desde la altura 3,742,566) depositando un bono (el challenge_bond del rollup; 1,000 QOR para los presets nft y custom) y una prueba de fraude. Un lote optimista se juzga según si su raíz de estado es la raíz de transición canónica, así que quien lo envía debe publicar exactamente esa raíz (las plantillas del RDK lo hacen, desde la 0.6.1; consulta RDK 0.8.0: cambios y límites). Toma el ID del rollup y el índice del lote; pasa la prueba de fraude con --proof:

qorechaind tx rdk challenge-batch [rollup-id] [batch-index] \
--proof <hex-encoded-fraud-proof> \
--from mykey \
--chain-id qorechain-diana \
--gas 400000 --fees 40000uqor \
--generate-only > challenge.json
qorechaind tx pqc cosign challenge.json --from mykey --pqc-key mypqckey --chain-id qorechain-diana
FlagDescripción
--proofPrueba de fraude codificada en hexadecimal

Un desafío congela el lote (challenged): no puede finalizarse. Antes de la v3.2.5 solo el creador del rollup podía resolverlo; desde la v3.2.5 (ambas redes) cualquier cuenta puede, como se describe más abajo. La resolución se envía con un mensaje de resolución de desafío (no expuesto como comando de CLI; usa un cliente). La cadena decide el resultado por sí misma verificando la prueba almacenada. Si se confirma el fraude, el lote pasa a rejected, el bono se devuelve y el desafiante recibe además un importe igual al bono, tomado del stake del rollup; si se desestima, el bono pasa al creador y el lote vuelve a submitted.

Desde la cadena v3.2.5 (ambas redes): cualquier cuenta puede resolver un desafío, no solo el creador. Un fraude confirmado rechaza ese lote y todos los lotes posteriores que aún no estén finalizados, y el secuenciador reenvía esos lotes desde la última raíz de estado buena bajo los mismos índices; el rollup continúa desde ahí. El Watchtower distingue esos lotes por índice y raíz de estado (consulta Watchtower).

Inspeccionar lotes​

# Latest batch for a rollup
qorechaind query rdk batch [rollup-id]

# A specific batch by index
qorechaind query rdk batch [rollup-id] --index 42

# A page of batches in index order (--limit up to 100, default 50)
qorechaind query rdk batches [rollup-id] --start 0 --limit 50

Consultas​

ComandoPropósito
qorechaind query rdk rollup [rollup-id]Detalles de un rollup específico
qorechaind query rdk list-rollupsTodos los rollups registrados
qorechaind query rdk batch [rollup-id]Último lote de liquidación (o --index)
qorechaind query rdk batches [rollup-id]Una página de lotes en orden de índice (--start, --limit)
qorechaind query rdk anchor-sign-bytes [layer-id] [batch-index] [state-root-hex]Los bytes de firma de ancla v2 de un lote (offline)
qorechaind query rdk configParámetros del módulo RDK
qorechaind query rdk suggest-profile [use-case]Imprime una referencia al RPC qor_suggestRollupProfile; los endpoints públicos no lo sirven, así que elige un perfil a partir de la tabla de Perfiles preconfigurados

Próximos pasos​