Déployer un Rollup
Vous pouvez mettre en place un rollup spécifique à une application de trois façons : via le Dashboard (un formulaire de demande, et non une transaction on-chain), via la CLI de la chaîne (qorechaind, contrôle total sur la transaction on-chain), ou avec le RDK TypeScript (@qorechain/rdk plus le générateur create-qorechain-rollup), qui couvre la configuration, les lectures et, lorsque vous lui fournissez une clé post-quantique, des transactions signées en mode hybride (voir RDK 0.8.0 : changements et limites). Cette page couvre les trois méthodes, ainsi que le cycle de vie de l'opérateur et les commandes de batch.
Aucun rollup n'a été créé sur le mainnet (GET /qorechain/rdk/v1/rollups a renvoyé une liste vide le 12 novembre 2026) ; le testnet a été vérifié pour la dernière fois le 30 octobre 2026, date à laquelle il n'en contenait aucun. Les commandes ci-dessous utilisent le testnet qorechain-diana (chain ID EVM 9800, version de chaîne v3.2.8 : la v3.2.4 y a été appliquée le 19 octobre 2026, la v3.2.5 le 26 octobre à la hauteur 8,890,800, la v3.2.6 le 27 octobre à la hauteur 8,970,638, la v3.2.7 le 6 novembre à la hauteur 9,594,600 et la v3.2.8 le 12 novembre à la hauteur 9,929,500 ; la v3.2.8 n'est pas sur le mainnet). Le mainnet (qorechain-vladi, chain ID EVM 9801, en production depuis le 7 juin 2026) exécute la version de chaîne v3.2.7 depuis le 12 novembre 2026 (appliquée à la hauteur 4,164,600 par la proposition de gouvernance 16 ; la v3.2.6 avait été appliquée à la hauteur 4,020,000 le 4 novembre 2026 par la proposition 15 ; la v3.2.5 avait été appliquée à la hauteur 3,906,833 le 29 octobre 2026 par la proposition 14 et la v3.2.4 à la hauteur 3,742,566 le 23 octobre 2026 par la proposition 13), de sorte que ce que la v3.2.5 change pour les rollups est signalé par « à partir de la v3.2.5 » et s'applique aux deux réseaux (un tableau récapitulatif figure dans la Présentation des Rollups). Les versions antérieures diffèrent sur quelques détails, que cette page signale par « à partir de la v3.2.4 ». Le testnet est un réseau de préproduction avec ses propres paramètres de module (par exemple une fenêtre de contestation par défaut de 3,600 secondes contre 604,800 sur le mainnet, et 200 rollups au maximum contre 100) ; lisez GET /qorechain/rdk/v1/params sur le réseau que vous ciblez. Validez chaque déploiement sur testnet d'abord.
Le réseau impose un prix du gas minimum de 0.1uqor, donc un simple --fees 500uqor est refusé, et chaque transaction de la voie native nécessite la co-signature post-quantique hybride. Les exemples de CLI de cette page construisent donc la transaction avec --generate-only et la cosignent avec qorechaind tx pqc cosign, qui la signe et la diffuse (créez la clé une fois avec qorechaind tx pqc gen-key, puis enregistrez-la on-chain une fois avec qorechaind tx pqc register-key, ou via QoreX ou le SDK, qui le font pour vous). Les frais sont fixés lors de la génération du fichier non signé : définissez donc la limite de gas et les frais ensemble — les frais doivent être au moins égaux à la limite de gas × 0,1 uqor. Les limites de gas ci-dessous sont indicatives — simulez avant de vous y fier. Voir Première transaction et Signature post-quantique.
Prérequis
| Prérequis | Détails |
|---|---|
| Stake minimum | Au moins 10 000 QOR (min_stake_for_rollup) ; le stake est mis sous séquestre à la création du rollup |
| Burn de création | 1 % du stake que vous fournissez est brûlé définitivement à la création (une création qui ne peut pas appliquer le burn est refusée) ; le reste est conservé sous séquestre et restitué à l'arrêt du rollup |
| Stake d'enregistrement de la couche | La création enregistre aussi la couche du rollup dans le module multilayer, ce qui verrouille 1 000 QOR supplémentaires (min_sidechain_stake) auprès du créateur, restitués lorsque la couche est désactivée à l'arrêt. Si la couche ne peut pas être enregistrée (solde trop faible, ou limite de 10 sidechains du multilayer atteinte), le rollup est tout de même créé mais n'a pas de couche, de sorte que ses batches ne peuvent pas être ancrés |
| ID du rollup | Utilisez 3 à 64 caractères : lettres minuscules, chiffres, ., _ et -, en commençant par une lettre ou un chiffre. La chaîne impose cette règle sur les deux réseaux depuis la v3.2.2 (la CLI la vérifie avant de construire la transaction) ; un ID non conforme est donc refusé |
| Compte | Un compte QoreChain approvisionné avec une clé post-quantique enregistrée, avec un solde suffisant pour le stake, le stake de la couche et les frais de transaction |
Interrogez les paramètres du module en direct pour connaître le stake minimum et le taux de burn actuels avant de déployer :
qorechaind query rdk config
Déployer via le Dashboard (Tools → Rollups)
Le Dashboard propose un formulaire Deploy a Rollup sous Tools → Rollups. C'est un formulaire de demande : le soumettre enregistre une demande de provisionnement pour votre compte, examinée par The Qore Trust, et une nouvelle demande affiche un statut provisioning. Il ne diffuse pas de transaction create-rollup on-chain — pour enregistrer un rollup on-chain, utilisez la CLI ci-dessous.
Étapes
- Connectez-vous. Le formulaire nécessite une session authentifiée pour soumettre une demande et pour lister vos demandes existantes.
- Nommez votre rollup. Saisissez un nom de rollup (2 à 41 caractères : lettres, chiffres, espaces, tirets ou underscores).
- Choisissez une machine virtuelle. L'enregistrement on-chain stocke un libellé de VM. Votre rollup s'exécute off-chain dans son propre runtime ; ce choix ne s'exécute pas sur les voies EVM, QoreChain Native ou SVM propres à QoreChain :
- EVM — contrats Solidity / Vyper avec l'outillage Ethereum complet (Hardhat, Foundry, MetaMask)
- QoreChain Native — contrats intelligents Rust sur le runtime Cosmos SDK (le runtime CosmWasm), avec IBC natif
- SVM — la Solana Virtual Machine, pour les applications à exécution parallèle et haut débit
- Choisissez une couche de disponibilité des données. L'endroit où votre rollup publie les données de transaction afin que quiconque puisse reconstruire l'état : QoreChain DA, Celestia, ou EigenDA. Notez qu'EigenDA est une option au niveau du Dashboard, tandis que les backends DA on-chain du module
x/rdksont native, Celestia, ou les deux — voir Data Availability. - Définissez un gas token. Le token utilisé pour payer l'exécution sur votre rollup. Par défaut QOR ; saisissez un symbole personnalisé pour utiliser votre propre token natif.
- Choisissez un séquenceur. Qui ordonne les transactions avant le règlement : Shared sequencer (l'ensemble partagé de QoreChain), Dedicated (single) (exécutez votre propre séquenceur unique), ou Decentralized (un ensemble de séquenceurs sans permission).
- Choisissez une cible de règlement. Où le rollup ancre ses racines d'état et ses preuves de validité : QoreChain mainnet ou Ethereum.
- Soumettez la demande. Le provisionnement est examiné par The Qore Trust, donc une demande fraîchement soumise apparaît avec un statut provisioning jusqu'à la fin de l'examen.
Vos demandes soumises apparaissent dans la liste Your rollups avec leur VM, leur couche DA, leur gas token, leur séquenceur, leur cible de règlement et leur statut actuel.
Les options du formulaire (machine virtuelle, couche de disponibilité des données, gas token, séquenceur, cible de règlement) décrivent ce que vous demandez ; elles sont plus larges que ce que le module x/rdk on-chain prend actuellement en charge. On-chain, la disponibilité des données est native (Celestia n'est pas actif), et le séquençage est assuré par le créateur du rollup ou par une adresse de séquenceur configurée. Voir Data Availability.
Déployer via la CLI
La CLI crée le rollup directement on-chain. create-rollup prend trois arguments positionnels — l'ID du rollup, un profil, et le montant du stake (en uqor) — plus un flag optionnel --vm.
Depuis la version de chaîne v3.1.74, create-rollup applique automatiquement le preset du profil choisi — le mode de règlement, le séquenceur, la DA, le modèle de gas et la VM proviennent tous du preset. Vous n'avez plus besoin de les définir manuellement (auparavant le message codait en dur une configuration souveraine). Le flag --vm est désormais vide par défaut, de sorte que la VM du profil s'applique sauf si vous la remplacez explicitement.
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
Exemple — créez un rollup à partir du preset defi (le règlement, le séquenceur, la DA et la VM proviennent tous du preset ; defi se résout en règlement zk sur l'EVM). Construisez la transaction non signée, puis joignez la co-signature post-quantique et diffusez :
# 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
Ne créez pas encore de rollup defi (ZK) sur le mainnet. La chaîne accepte la création et met le stake sous séquestre. Les messages de clé de vérification sont activés sur le mainnet depuis la chaîne v3.2.7 (12 novembre 2026) et ont été acceptés sur le testnet, mais le RDK 0.8.0 n'a pas de constructeur pour eux et aucun rollup ZK n'a été essayé sur l'un ou l'autre réseau. Choisissez pour l'instant un profil optimistic tel que nft ou custom (voir ZK / STARK & Withdrawals).
Flags :
| Flag | Défaut | Description |
|---|---|---|
--vm | (vide — utilise la VM du profil) | Remplace le type de VM du rollup : evm, cosmwasm, svm, ou custom. Laissez non défini pour appliquer la VM du preset. (Dans les clients RDK, le runtime Wasm est le type de VM native — QoreChain Native — avec cosmwasm conservé comme alias hérité ; cosmwasm est la valeur sur le fil, celle que prend ce flag au niveau de la chaîne.) |
--vm enregistre le runtime utilisé par votre rollup. La chaîne hôte ne fait que régler le rollup ; elle n'exécute pas ses contrats. Le téléversement QoreChain Native de la chaîne hôte est actuellement fermé et sa voie de transactions SVM est désactivée sur l'ensemble du réseau, ce qui n'affecte pas le règlement d'un rollup off-chain mais signifie que vous ne pouvez pas déployer de contrats pour un rollup sur ces voies de la chaîne hôte.
L'argument [profile] sélectionne une configuration prédéfinie appliquée automatiquement — voir Preset Profiles. Le [stake-amount] est le dépôt en uqor ; le burn de création en représente 1 %.
Inspecter ce que vous avez déployé
# Query a specific rollup by ID
qorechaind query rdk rollup my-defi-rollup
# List all registered rollups
qorechaind query rdk list-rollups
Déployer avec le RDK TypeScript (@qorechain/rdk)
Le Rollup Development Kit est publié sous forme de deux packages npm publics pour le même module on-chain x/rdk que la CLI. Aucun rollup n'existant encore sur l'un ou l'autre réseau, aucun chemin de transaction du kit n'a été exercé sur un rollup réel ; lisez RDK 0.8.0 : changements et limites avant de vous y fier pour envoyer des transactions :
@qorechain/rdk(v0.9.0) — le SDK TypeScript : un constructeur de configuration avec des profils prédéfinis, des helpers de transaction pour les cycles de vie du rollup et des batches de règlement, la DA native, des clients de lecture typés, des reçus de règlement avec une signature ML-DSA-87, le QCAI Rollup Copilot, des helpers de calldata cross-VM, et le watchtower. Il dépend de@qorechain/sdk^0.10.0(à partir de la 0.7.0 ; la 0.6.x utilisait^0.9.0) et de@qorechain/evm^0.8.0.create-qorechain-rollup(v0.9.0) — un générateur qui clone un template de démarrage exécutable par profil (y compris le templatemultivm-rollup).
Ces packages sont publiés sur npm. Le dépôt fournit également une CLI opérateur publiée, @qorechain/rdk-cli (qorollup, v0.9.0), avec les commandes doctor, create, status, watch, params, suggest, le cycle de vie (pause/resume/stop), keygen, manifest, withdraw, et faucet, plus les commandes receipt, advise, et watchtower. Depuis la 0.7.1, ses commandes de transaction signent en mode hybride (voir les limites ci-dessous).
Points marquants par version :
- v0.4.2 — fonctionne avec le réseau en production dès l'installation. Les presets
mainnetettestnetintègrent désormais les endpoints publicsqore.host(REST surapi.qore.host/api-testnet.qore.host), de sorte quecreateRdkClient({ network })atteint la chaîne sansendpointsmanuel — ne la remplacez que pour cibler votre propre nœud. La même version a renommé l'identifiant de VM du rollup Wasm ennative(QoreChain Native) ;cosmwasmreste un alias hérité accepté, et les deux se mappent surcosmwasmsur le fil — la chaîne, l'explorateur et le Dashboard sont inchangés. - v0.4.3 — mise à jour de dépendance pour la correction de l'encodage de la signature hybride du SDK. Le client de transaction du RDK lui-même signait encore en mode classique uniquement.
- v0.4.4 — suit
@qorechain/sdk^0.7.0, la version du SDK pour les voies d'authentificateur de la chaîne v3.1.85. Aucun changement d'API du RDK. - v0.5.0 (18 octobre 2026) — la vérification des reçus de règlement s'appuie sur l'état de la chaîne et ne déclare jamais un reçu valide à partir de ses propres champs ; le client de transaction TypeScript signe en mode hybride lorsqu'on lui fournit un
pqcKeypair. Il dépend de@qorechain/sdk^0.8.0. - v0.6.0 (version GitHub du 20 octobre 2026) — la version de compatibilité pour les versions de chaîne v3.2.2 à v3.2.4 : batches ancrés, reçus de règlement capables de se vérifier, fenêtres de contestation mesurées comme la chaîne les mesure, un encodeur conforme à la disposition cross-VM de la chaîne, des templates qui signent en mode hybride, et
@qorechain/sdk^0.9.0. Le détail se trouve ci-dessous. - v0.6.1 (version GitHub du 25 octobre 2026) — une version de correctifs de sécurité et de templates pour la chaîne v3.2.3 et suivantes, dans les cinq langages : la vérification des reçus de règlement compare chaque champ que le reçu énonce avec l'ancrage de la chaîne, les six templates de démarrage ne soumettent plus de batches que la chaîne refuse (ils laissent
dataHashvide), et les templates optimistes publient la racine d'état canonique de la chaîne au lieu d'un espace réservé. Elle conserve les plages@qorechain/sdk^0.9.0et@qorechain/evm^0.8.0. Le détail se trouve ci-dessous. - v0.6.2 (version GitHub du 27 octobre 2026) : un correctif de la CLI sans changement de bibliothèque :
qorollupinstallé depuis npm (en local, en global ou vianpx) fonctionne de nouveau, etqorollup --versionainsi quecreate-qorechain-rollup --versionaffichent leurs vraies versions. Les autres packages ont été republiés en 0.6.2 pour que chaque registre reste sur une seule version. - v0.7.0 (version GitHub du 27 octobre 2026) : prête pour la chaîne v3.2.5 dans les cinq langages (les deux réseaux l'exécutent, ainsi que la v3.2.6 et la v3.2.7 : le mainnet a appliqué la v3.2.5 le 29 octobre 2026, la v3.2.6 le 4 novembre et la v3.2.7 le 12 novembre, le testnet la v3.2.5 le 26 octobre et la v3.2.6 le 27 octobre ; le testnet est depuis passé à la v3.2.7 puis à la v3.2.8), et elle corrige la façon dont les retraits et les blobs de disponibilité des données sont hachés : les preuves de retrait construites avec les valeurs par défaut de la 0.6.x ne se vérifiaient jamais on-chain, et la 0.7.0 construit exactement l'arbre de la chaîne. Elle passe à
@qorechain/sdk^0.10.0, et les templates épinglent@qorechain/rdk^0.7.0. Le détail se trouve ci-dessous. - v0.7.1 (version GitHub du 30 octobre 2026) : un correctif urgent pour la CLI opérateur
qorollup, dont les commandes de transaction signent désormais en mode hybride, comme l'exigent les deux réseaux. - v0.8.0 (version GitHub du 30 octobre 2026) : les clients Python, Go, Rust et Java signent eux aussi en mode hybride, de sorte que chaque client RDK peut envoyer des transactions sur le mainnet et le testnet. Java 21 est requis.
- v0.9.0 (version GitHub du 12 novembre 2026 ; actuelle) : prend en charge la chaîne v3.2.8 (le testnet l'exécute depuis le 12 novembre 2026) : publication de données de rollup, séquencement basé, rollups optimistic qledger-v1 avec preuves de fraude, rollups privés, entrées ZK canoniques ; le règlement STARK est suspendu. Voir les notes de version sur GitHub. Un nouveau compte doit enregistrer sa clé post-quantique dans une transaction à part avant toute autre chose ; les clients RDK 0.9.0 font cet enregistrement pour vous.
Versions publiées (vérifiées sur chaque registre le 12 novembre 2026). npm @qorechain/rdk, @qorechain/rdk-cli et 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 (les versions antérieures restent disponibles) ; module Go github.com/qorechain/qorechain-rdk/packages/go : v0.9.0 (le @latest du proxy de modules peut accuser du retard sur un nouveau tag, épinglez donc explicitement @v0.9.0). La version GitHub est v0.9.0.
RDK 0.8.0 : changements et limites
Cette section énonce ce que font les packages 0.8.0 publiés (et ce que la 0.7.1, la 0.7.0, la 0.6.2, la 0.6.1 et la 0.6.0 ont changé avant eux), vérifiés par rapport au contenu des packages et aux notes de version GitHub, et ce qu'ils ne peuvent toujours pas faire. Aucun de ces points n'est un comportement de la chaîne. Lorsqu'une phrase dit « non testé en conditions réelles », aucun rollup n'existe sur l'un ou l'autre réseau : le chemin n'a donc été vérifié que par rapport au code et hors ligne.
Ce qui a changé dans la 0.8.0 et la 0.7.1 (les notes de version 0.8.0 et 0.7.1 donnent la liste complète). Les deux réseaux exigent une signature hybride (ML-DSA-87 + secp256k1) sur les transactions de la voie native.
- 0.7.1 : les transactions
qorollupsont acceptées.create,pause,resume,stopetwithdrawsignaient en mode classique uniquement dans la 0.7.0 et les versions antérieures ; les réseaux les refusaient donc toutes. La CLI signe désormais en mode hybride. Elle résout la clé post-quantique comme le font les templates : dérivée de--mnemonicou deQORE_MNEMONICet confrontée à la clé que la chaîne a enregistrée, ou prise dans--pqc-seedouQORE_PQC_SEED_HEXavec--key. Sans clé, elle refuse d'envoyer plutôt que de payer pour une transaction refusée. - 0.7.1 : correction de parité Python.
transition_root_version_for_batch,RestClient.get_applied_plan_heightetBatchView.withdrawals_boundfigurent désormais aussi dans le client Python (les notes de la 0.6.1 avaient compté la première dans les cinq langages ; elle n'existait que dans quatre). - 0.8.0 : Python, Go, Rust et Java signent en mode hybride. Auparavant, seules leurs lectures fonctionnaient sur le mainnet et le testnet. Chacun signe désormais en mode hybride lorsqu'on lui fournit une paire de clés post-quantique, via son propre SDK QoreChain publié (0.10.x), la forme des octets à signer (v1 ou v2) étant résolue à partir de la chaîne. Les notes de version indiquent que chaque client produit des transactions identiques octet pour octet à celles du client TypeScript pour une même entrée (une fixture partagée contient quatre transactions hybrides que chaque langage reproduit exactement).
- 0.8.0 : résolution de la clé dans chaque langage, comme en TypeScript : à partir d'une mnémonique, avec la dérivation canonique ou l'ancienne, selon celle que la chaîne a enregistrée ; ou à partir d'une graine de 32 octets issue de
QORE_PQC_SEED_HEX, confrontée à la clé enregistrée. Pythonresolve_pqc_keypair/pqc_keypair_from_env, GoResolvePqcKeypair/PqcKeypairFromEnv, Rustresolve_pqc_keypair/pqc_keypair_from_env, JavaAccounts.resolvePqcKeypair/pqcKeypairFromEnv. - 0.8.0 : Java 21 est requis (c'était 17), car le SDK Java de QoreChain dont il dépend l'exige.
- 0.8.0 : nouvelles dépendances.
qorechain-sdk0.10.x sur PyPI, le module Gogithub.com/qorechain/qorechain-sdk/packages/gov0.10.0,qorechain-sdk0.10 sur crates.io (Rust passe àcosmrs0.22) etio.github.qorechain:qorechain-sdk[0.10.0,0.11)sur Maven. Les templates épinglent@qorechain/rdk^0.8.0. - 0.8.0 : le
RdkTxClient.Signde Go renvoie([]byte, error), car la signature hybride peut échouer. Cela casse le code Go qui utilisait l'ancienne valeur de retour unique. - Non testé en conditions réelles. Aucun rollup n'existe sur l'un ou l'autre réseau : aucune transaction hybride d'aucun client n'a donc été envoyée à travers un rollup en service.
Ce qui a changé dans la 0.7.0 (dans les cinq langages, sauf indication contraire d'une ligne ; les notes de version donnent la liste complète). Le comportement qui relève de la chaîne v3.2.5 est signalé avec son réseau : les deux réseaux exécutent la v3.2.5 ou une version ultérieure (le mainnet exécute la v3.2.7 depuis le 12 novembre 2026, le testnet la v3.2.8 depuis le 12 novembre).
- Les preuves de retrait se vérifient on-chain. Les helpers de Merkle et de retrait utilisaient SHA-256 par défaut et re-hachaient chaque feuille, alors que la chaîne hache les nœuds avec SHAKE-256 et construit ses feuilles à partir du retrait lui-même : une preuve construite avec les valeurs par défaut de la 0.6.x ne se vérifiait donc jamais.
withdrawalsTreeconstruit désormais la racine des retraits d'un batch et chaque preuve exactement comme le fait la chaîne (la position de la feuille est l'index du retrait) : avec des feuilles de première forme, ou avec des feuilles de seconde forme qui nomment aussi l'ID de chaîne, que la chaîne utilise pour les batches à partir de la v3.2.5 (les deux réseaux).withdrawalLeafV1etwithdrawalLeafV2construisent une feuille,assembleWithdrawalProofconstruit par défaut l'arbre de la chaîne, et les helpers de Merkle génériques utilisent SHAKE-256 par défaut. C'est un changement incompatible pour le code qui s'appuyait sur les valeurs par défaut SHA-256 (passezhashexplicitement pour les conserver). Les nouveaux formats d'octets ont été testés avec des vecteurs produits par le code même de la chaîne, et chaque preuve de retrait de ces vecteurs est acceptée par le vérificateur de la chaîne. Voir Leaf and node encoding. qorollup withdrawvérifie avant de payer. Il prend les retraits du batch (qorollup withdraw --file withdrawal.json [--dry-run]), construit la preuve sous la liaison propre au batch, et refuse avant de payer des frais lorsque le résultat n'est pas lewithdrawals_rooton-chain du batch.buildDaBlobs'engage comme le fait la chaîne. Son engagement est en SHAKE-256, et non en SHA-256 (aucune transaction ne publie de blob, doncdataHashreste vide).- Watchtower. Le Watchtower distinguait les batches par leur seul index, et manquait donc un batch resoumis à un index rejeté. À partir de la chaîne v3.2.5 (les deux réseaux), une fraude confirmée rejette le batch et chaque batch non finalisé qui le suit, et le séquenceur les resoumet sous les mêmes index ; le Watchtower distingue désormais les batches par index et racine d'état et ne valide jamais un batch rejeté. Nouveaux helpers
transitionRootValidator(un prédicatvalidatequi applique la règle de fraude de la chaîne) etfraudProofForBatch(la preuve qui l'emporte, ou aucune pour un batch honnête), ainsi queqorollup watchtower --canonical, qui signale les batches qu'une contestation gagnerait. - Helpers de règlement de la chaîne v3.2.5 (les deux réseaux) :
getRollupHealthindiqueheldBackBylorsque le dernier batch pourrait se finaliser sur sa propre fenêtre mais qu'un batch antérieur est encore soumis ou contesté (les batches se finalisent dans l'ordre), etqorollup statusl'affiche ;stopRollupErroret une vérification préalable dansstopRollup(TypeScript et Rust), car un rollup dont le dernier batch est soumis ou contesté ne peut pas être arrêté ;MAX_PENDING_OPTIMISTIC_BATCHES(4 096) ;withdrawalsRootError(une racine de retraits est vide ou fait exactement 32 octets), vérifié avant chaque soumission de batch dans les cinq langages. - Helpers cross-VM pour la chaîne v3.2.5 (les deux réseaux) :
getCrossVmParams(la liste d'autorisation, sur/qorechain/crossvm/v1/params),crossVmTargetReady(precompile actif, bridge activé et cible autorisée, avec la raison du blocage),decodeCrossVmResult(la réponse estabi.encode(bytes)) etdecodeRevertReason(un refus estError(string)), vérifiés par rapport à des encodages produits par Solidity. Voir Multi-VM. - Décodage des erreurs et petits ajouts.
decodeRdkTxErroretRDK_ERRORSnomment les codes d'erreur du modulerdk(2 à 36) et ce qu'il faut faire pour ceux que rencontre un opérateur ;qorehash(SHAKE-256, 32 octets) est exporté dans les cinq langages ;FEATURE_RDK_CHALLENGE_SETTLEMENTnomme le drapeau de fonctionnalité de la chaîne. - Le template
defis'arrête avant de gaspiller des frais. Aucune version de la chaîne jusqu'à la v3.2.6 ne peut enregistrer une clé de vérification ZK : chaque batch ZK y était donc refusé. Le template s'arrête désormais avant l'envoi, etRollupView.hasVerificationKeylit un champ prévu pour la chaîne v3.2.7 (testnet depuis le 6 novembre, mainnet depuis le 12 novembre 2026) ; il n'a pas pu être vérifié sur un rollup réel, car il n'en existe aucun. - Dépendances.
@qorechain/sdk^0.10.0(c'était^0.9.0), de sorte qu'une application sur le SDK 0.10.0 partage désormais une seule copie du SDK avec le kit ; les templates épinglent@qorechain/rdk^0.7.0(^0.8.0depuis la 0.8.0).
Ce qui a changé dans la 0.6.2 (la CLI et le générateur uniquement ; les packages de bibliothèque sont inchangés) :
qorollupfonctionne lorsqu'il est installé depuis npm. La CLI ne démarrait que lorsqueprocess.argv[1]était égal au chemin de son propre fichier, mais npm lance le bin d'un package via un lien symbolique dansnode_modules/.bin: la 0.6.1 et les versions antérieures, installées en local, en global ou lancées avecnpx, se terminaient avec le code 0 sans rien afficher ; seulnode .../dist/index.jsfonctionnait. La 0.6.2 compare les chemins réels. Aprèsnpm i -g @qorechain/rdk-cli,qorollup ...fonctionne.- Les versions s'affichent correctement.
qorollup --versionaffichait0.4.1etcreate-qorechain-rollup --versionaffichait0.2.0dans les versions précédentes ; les deux lisent désormais leur proprepackage.json(vérifié le 27 octobre 2026 :qorollup --versionaffiche0.6.2).
Ce qui a changé dans la 0.6.1 (dans les cinq langages, sauf indication contraire d'une ligne ; les notes de version donnent la liste complète) :
- La vérification des reçus compare chaque champ.
verifySettlementReceiptexige désormais que chaque champ d'ancrage énoncé par le reçu soit égal à l'ancrage de la chaîne (une divergence nomme le champ), exige quebatchStateRootsoit égal à la racine du batch de la chaîne, et refuse un reçu dont laversionest inconnue ou dont l'algorithmest autre queML-DSA-87avant de lire quoi que ce soit sur la chaîne. Le résultat porte l'anchorde la chaîne qui correspond et, lorsqu'il est valide, unverifiedReceiptreconstruit à partir de l'état de la chaîne ;qorollup receipt verify --jsonrenvoie ce reçu lu sur la chaîne commereceipt. Voir Settlement receipts. - Disponibilité des données native : laissez
dataHashvide. Chaque profil de rollup utilise la disponibilité des donnéesnative, où la chaîne n'accepte undata_hashnon vide que si un blob correspondant est stocké on-chain, et aucune transaction ne peut en stocker un (voir Data Availability). Les six templates de démarrage mettaient un hash de données sur leurs batches en 0.6.0 et avant, de sorte que la chaîne refusait chaque batch de template après le paiement des frais. Ils le laissent désormais vide ;SubmitBatchInput.dataHashest facultatif en TypeScript (omis signifie vide),dataHashError(data_hash_error,DataHashError,Rules.dataHashError) expose la règle, etRdkTxClient.submitBatchrefuse un tel batch avant de le diffuser lorsqu'il peut lire le rollup (un client hybride avec un point de terminaison REST). - Les templates optimistes publient la racine d'état canonique. La chaîne juge un batch optimiste d'après sa racine de transition canonique, un engagement SHAKE-256 de la racine d'état précédente du batch, de son hash de données et de son nombre de transactions (
batchTransitionRootdans le RDK,transitionRootVersionForchoisissant la liaison que le réseau connecté applique). Les templatescustom,multivmetnftsoumettaient une racine fixe servant d'espace réservé, qui ne correspond pas à la racine canonique que la chaîne vérifie ; ils publient désormais la racine canonique et n'envoient plus de preuve servant d'espace réservé. Lechallenge.tsdu templatenftlit le batch sur la chaîne et ne conteste qu'un batch dont la racine est manifestement fausse. Ne réécrivez pas la formule à la main : utilisezbatchTransitionRootpour que la liaison corresponde au réseau auquel vous soumettez. La vérification de la chaîne est la même pour tous les clients : un batch optimiste dont la racine d'état n'est pas la racine canonique peut donc être contesté avec succès, quel que soit le client qui l'a envoyé. - Nouveaux helpers.
fraudProof,transitionRootVersionForBatch,receiptSchemaErroravecSUPPORTED_RECEIPT_VERSIONS,RestClient.getProtocolFeatures/isProtocolFeatureEnabled(une chaîne sans la route se lit comme « non activé ») etgetAppliedPlanHeight.@qorechain/rdkdépend désormais directement de@noble/hashes(SHAKE-256 pour la racine de transition ; il était déjà installé via@qorechain/sdk). Les templates épinglent@qorechain/rdk^0.6.1.
Ce qui a changé dans la 0.6.0 (TypeScript, sauf indication contraire d'une ligne) :
- Signature.
RdkClient.connectTx(signer, { pqcKeypair, rest })signe en mode hybride (secp256k1 + ML-DSA-87) lorsque vous passez une paire de clés ; sans elle, il signe en mode classique uniquement et les réseaux refusent la transaction.signerdoit être unOfflineDirectSigner, et les frais doivent être explicites (unfee, ou ungasPriceà la connexion). De nouveaux helpersresolvePqcKeypairetpqcKeypairFromEnvdérivent à la fois la clé ML-DSA-87 canonique et la clé héritée à partir d'une mnémonique, et utilisent celle que le compte a enregistrée on-chain ; ils refusent, plutôt que de deviner, lorsque le compte détient une autre clé.QORE_PQC_SEED_HEXfournit une graine à un opérateur qui signe avec une clé privée brute. Le kit dépend désormais de@qorechain/sdk^0.9.0, de sorte qu'une installation neuve contient une seule copie du SDK (0.9.0) ; avec la 0.5.0, npm installait le SDK 0.8.3 imbriqué sous le kit. - Batches ancrés.
MsgSubmitBatchporteanchor_signatureetvalidator_set_hash.RdkTxClient.submitBatchne signe lui-même l'ancrage que lorsque le client signe en mode hybride, dispose d'un endpoint REST, et est le créateur du rollup (la chaîne vérifie l'ancrage par rapport à la clé enregistrée du créateur) ; dans tous les autres cas, il soumet sans ancrage, comme auparavant. Passezanchor: "require"pour refuser au lieu de soumettre sans ancrage,anchor: "off"pour ne jamais signer, ouanchorSignaturepour envoyer une signature que vous avez obtenue vous-même.anchorSignBytesForBatchconstruit les octets v2 pour un créateur qui signe hors bande, ce dont a besoin un rollup avec un séquenceur distinct. Non testé en conditions réelles. - Reçus de règlement. La recherche de compte PQC utilise la route au singulier
/qorechain/pqc/v1/account/{address}(la 0.5.0 utilisait un chemin au pluriel que les réseaux ne servent pas). La vérification prend en charge les deux formes d'octets de signature d'ancrage et en choisit une d'après la hauteur de l'ancrage, sans jamais essayer les deux : v1 en dessous du basculement de la v3.2.2, v2 à partir de celui-ci. Le schéma de reçu v2 enregistrechainId; la vérification refuse un reçu contrôlé auprès d'un nœud d'une autre chaîne, et rapportesignBytesVersionainsi qu'un contrôlechainBinding. Les reçus de version 1 se vérifient toujours. Voir Settlement receipts. - Lectures.
getLatestBatchappelle/qorechain/rdk/v1/latest_batch/{rollup_id}(la 0.5.0 appelait une forme que la chaîne ne sert pas), etlistBatchesparcourt toutes les pages (listBatchesPageen lit une).RollupViewporteescrowBalanceet, lorsque le nœud les rapporte,challengeWindowSec,challengeBondetproofSystem;BatchViewportesubmittedTime. - Fenêtres de contestation.
batchChallengeWindowcalcule la fenêtre d'un batch comme le fait la chaîne et la juge par rapport à la tête de chaîne (getChainTip), et non à l'horloge locale : des secondes de temps de bloc pour un batch dont l'heure de soumission est enregistrée (la règle de la v3.2.4 : le testnet depuis la hauteur 8,337,253, le mainnet depuis la hauteur 3,742,566),window / 6blocs comptés depuis la hauteur de soumission dans le cas contraire (la règle des batches soumis avant la hauteur de mise à niveau). Le contrôle de santé derrièreqorollup statuset le watchtower l'utilisent (voir Watchtower). - Cross-VM.
encodeCrossVmCalldataencode désormaisexecuteCrossVMCall(uint8,string,bytes), la disposition que le nœud décode, et prend untargetVm.isCrossVmPrecompileActivelit la liste en direct des precompiles actifs (voir Multi-VM). - Règles vérifiées avant le paiement des frais.
rollupIdErrorvérifie la grammaire de l'id lorsque vous validez une configuration et avant quecreateRollupne diffuse ;withdrawalErrorsvérifie un retrait avant queexecuteWithdrawalne diffuse. - Templates. Les templates générés se connectent via
pqcKeypairFromEnv, de sorte que leurs scriptscreateetsubmit-batchsignent en mode hybride, et ils dépendaient de@qorechain/rdk^0.6.0(^0.6.1depuis le générateur 0.6.1). Le templatemultivm-rollupvérifie que le precompile est actif et exige une réponse non vide de la cible. - Python, Go, Rust et Java. Les corrections côté lecture ci-dessus (route PQC au singulier,
latest_batch, octets de signature d'ancrage v2, règles de fenêtre de contestation, vérifications d'id et de retrait) figurent aussi dans les packages publiés des quatre autres langages. - Changements incompatibles.
encodeCrossVmCalldataprendtargetVm, etCROSS_VM_DEFAULT_SIGNATUREa changé.RollupHealthetBatchDeadlineportent unchallengeWindowà la place de l'ancienne échéance en secondes.
Limites qui subsistent dans la 0.8.0 :
-
Le règlement ZK n'a été essayé sur aucun des deux réseaux. Le profil
defi, le templatedefi-rollupet tout rollup créé avec un règlementzksont concernés : les messages de clé de vérification sont activés sur le mainnet depuis la chaîne v3.2.7 (12 novembre 2026) et sur le testnet depuis le 6 novembre 2026, mais aucun rollup ZK n'a été créé et le RDK 0.8.0 n'a pas de constructeur pour ces messages. Utilisez pour l'instant le règlementoptimistic(voir ZK / STARK & Withdrawals). -
Le circuit de démonstration du template
define peut pas être vérifié. C'est un circuit multiplicateursnarkjs, alors que la chaîne vérifie du Groth16 sur BLS12-381 avec trois entrées publiques (la racine d'état précédente, la nouvelle racine d'état et le hash de données). Même lorsque l'enregistrement des clés existera, une preuve issue du circuit de démonstration ne passerait pas ; remplacez le circuit par votre propre circuit de transition d'état. -
Corrigé dans la 0.7.0 : les helpers de Merkle pour les retraits. Dans la 0.6.2 et les versions antérieures, les helpers utilisaient SHA-256 par défaut et une preuve construite avec les valeurs par défaut ne se vérifiait jamais on-chain ; utilisez
withdrawalsTree/assembleWithdrawalProofà partir de la 0.7.0 (voir Leaf and node encoding). -
La signature hybride exige votre clé post-quantique. Chaque client (TypeScript, la CLI
qorollupà partir de la 0.7.1, et Python, Go, Rust et Java à partir de la 0.8.0) ne signe en mode hybride que s'il dispose d'une paire de clés post-quantique ; sans elle, une transaction est signée en mode classique uniquement et les deux réseaux la refusent. Les versions antérieures signent en mode classique uniquement : la CLI avant la 0.7.1 et les clients Python, Go, Rust et Java avant la 0.8.0 ne peuvent donc envoyer aucune transaction que les réseaux acceptent. Les constructeurs de messages Python n'ont pas de champanchor_signaturenivalidator_set_hash(vérifié dans le source de la 0.8.0 ; non vérifié pour les trois autres) : pour un batch ancré depuis Python, construisez et signez avec la CLI de la chaîne (--generate-only, puisqorechaind tx pqc cosign) ou utilisez le client TypeScript avec unpqcKeypair. -
Aucune création hybride d'un rollup n'a été exercée en conditions réelles, car aucun rollup n'existe sur l'un ou l'autre réseau. Il en va de même pour les batches ancrés, les retraits et l'ensemble du flux de reçus.
-
L'ancrage nécessite le créateur. Un batch n'est ancré dans la même transaction que si la signature du créateur y figure. Si le séquenceur est une autre adresse, le créateur doit signer les octets v2 hors bande et le séquenceur envoie le résultat.
-
Le precompile cross-VM à l'adresse
0x…0901n'est pas actif sur le mainnet ; un appel depuis un contrat n'y fait donc rien. Sur le testnet, il est actif avec une liste d'autorisation, et un appel a été testé aveceth_callle 7 novembre 2026 (voir Multi-VM). -
Durée de la fenêtre de contestation. Le kit ne lit la fenêtre propre à un rollup que lorsque le nœud la rapporte (le package documente cela à partir de la v3.2.4, que les deux réseaux exécutent). Sinon, il utilise la fenêtre par défaut du module ; passez
challengeWindowSecspour un rollup qui a configuré la sienne. Les anciens helperschallengeWindowDeadlineetisChallengeWindowClosedsont toujours exportés et prennent toujours des secondes ; ne leur donnez donc pas une hauteur de bloc. -
Disponibilité des données. Aucune transaction ne publie de blob : un batch sur un rollup
nativeoubothdoit donc laisserdataHashvide (voir Data Availability).buildDaBlobhachait avec SHA-256 dans la 0.6.2 et les versions antérieures ; à partir de la 0.7.0, son engagement est le SHAKE-256 de la chaîne.
Versions antérieures à la 0.8.0. La 0.7.0 et les versions antérieures ne peuvent pas envoyer de transactions qorollup que les réseaux acceptent (corrigé dans la 0.7.1), et avant la 0.8.0 les clients Python, Go, Rust et Java ne pouvaient envoyer aucune transaction. La 0.6.2 et les versions antérieures construisent des preuves de retrait qui ne se vérifient jamais on-chain et hachent buildDaBlob avec SHA-256 ; utilisez la 0.8.0. La 0.6.1 et les versions antérieures installaient la CLI qorollup depuis npm dans un état où elle n'affichait rien et se terminait avec le code 0 (corrigé dans la 0.6.2). La 0.6.0 compare moins de champs que la 0.6.1 lors de la vérification des reçus et livre des templates qui soumettent des batches que la chaîne refuse (un hash de données sur un rollup à DA native, une racine d'état servant d'espace réservé sur les rollups optimistes). Il ne faut pas utiliser la 0.5.0 et les versions antérieures pour les reçus de règlement, le watchtower ou les calldata cross-VM : la 0.5.0 cherchait la clé du créateur sur une route que les réseaux ne servent pas (de sorte que la vérification des reçus échouait de façon fermée sur chaque reçu authentique), ne reconstruisait que le message d'ancrage v1, lisait une hauteur de bloc comme un horodatage (chaque âge de batch et chaque échéance de contestation étaient faux, et le watchtower déclenchait aussitôt son alerte d'échéance pour chaque batch), appelait une route de dernier batch que la chaîne ne sert pas, ne lisait que les 50 premiers batches, encodait une fonction que le precompile ne décode pas, et livrait des templates qui signaient en mode classique uniquement. La 0.4.x n'avait pas de signature hybride dans le client de transaction.
Clients Python, Go, Rust et Java
Aux côtés du package TypeScript, le RDK fournit des clients Python, Go, Rust et Java complets qui reflètent la surface TypeScript : le constructeur de configuration avec validation, les cinq profils prédéfinis, les utilitaires denom/economics/bech32, les helpers de Merkle binaire et de preuve de retrait, les manifestes de rollup, les clients de lecture REST et JSON-RPC qor_, les vérifications préalables/de santé, les comptes (mnémonique → adresse qor), et, à partir de la 0.8.0, la signature de transaction hybride + diffusion (ML-DSA-87 + secp256k1, comme l'exigent les deux réseaux ; avant la 0.8.0, ils signaient en mode classique uniquement et seules leurs lectures fonctionnaient — voir RDK 0.8.0 : changements et limites). Tous sont vérifiés par rapport à des vecteurs de référence partagés inter-langages et sont publiés sur leurs registres respectifs :
# 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 (nécessite Java 21)
import qorrdk
Versions actuellement publiées, toutes en 0.9.0 (vérifiées le 12 novembre 2026) : Python qorechain-rdk (PyPI, import qorrdk), module Go github.com/qorechain/qorechain-rdk/packages/go (v0.9.0), Rust qorechain-rdk (crates.io) et Java io.github.qorechain:qorechain-rdk (Maven Central ; Java 21 ou ultérieur à partir de la 0.8.0). Ces clients lisent l'état de la chaîne et, à partir de la 0.8.0, envoient des transactions signées en mode hybride lorsque vous leur fournissez une paire de clés post-quantique (voir RDK 0.8.0 : changements et limites).
Le RDK TypeScript et ses templates ciblent par défaut le testnet qorechain-diana, et les presets atteignent les endpoints publics en production dès l'installation. Épinglez les versions et validez sur testnet avant le mainnet.
Générer un projet avec create-qorechain-rollup
Chaque profil possède un template de démarrage correspondant (defi-rollup, gaming-rollup, nft-rollup, enterprise-rollup, custom-rollup). Générez-en un avec l'une des deux formes :
npm create qorechain-rollup my-rollup
# or
npx create-qorechain-rollup my-rollup
Pour une utilisation non interactive / CI, passez le template et le réseau explicitement :
npx create-qorechain-rollup my-rollup --template defi-rollup --network testnet --yes
Le générateur affiche le coût documenté du stake et du burn de création, ainsi que les prochaines étapes pour créer votre rollup et consulter son statut.
Les templates de create-qorechain-rollup 0.9.0 dépendent de @qorechain/rdk ^0.9.0. Leurs scripts create et submit-batch se connectent via connectOperator() dans src/signer.ts, qui résout votre clé post-quantique à partir de QORE_MNEMONIC (ou de QORE_PQC_SEED_HEX lorsque vous signez avec QORE_OPERATOR_PRIVATE_KEY_HEX), la vérifie auprès de la chaîne et signe en mode hybride ; si aucune des deux n'est définie, le script émet un avertissement et signe en mode classique uniquement, ce que les deux réseaux refusent. Aucun rollup n'a été créé via un template sur un réseau en production ; ce chemin n'est donc pas testé en conditions réelles. Le script submit-batch du projet de démarrage n'est qu'un flux de référence : depuis la 0.6.1, il laisse dataHash vide (la chaîne refuse un hash de données sur un rollup à DA native), et les templates optimistes publient la racine d'état canonique au lieu d'un espace réservé ; il utilise encore des valeurs illustratives pour le reste, et il n'est pas censé finaliser un batch sur un réseau en production. Le template defi-rollup (ZK) s'arrête avant d'envoyer un batch à partir de la 0.7.0, car la chaîne le refuserait (voir ZK / STARK & Withdrawals).
Construire une configuration de rollup depuis du code
Construisez une configuration à partir d'un preset, lisez le stake et le taux de burn en direct depuis la chaîne, puis produisez le message de création. Le constructeur de configuration applique la matrice de compatibilité règlement → preuve lors de validate() / build(). Soumettez les valeurs obtenues avec la CLI ci-dessus, ou avec le client TypeScript muni d'un pqcKeypair — voir RDK 0.8.0 : changements et limites.
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);
Vous ne savez pas quel profil convient ? rdk.suggestProfile(...) est censé renvoyer une recommandation assistée par le QCAI ; sur les endpoints publics actuels, il renvoie toujours le repli defi (source: "fallback"), choisissez donc à partir du tableau des profils.
Lire l'état depuis le code
Le client REST typé ne nécessite aucun signataire et lit les deux réseaux :
const rollup = await rdk.rest.getRollup("my-defi-rollup");
console.log(rollup.status, rollup.settlementMode, rollup.daBackend, rollup.vmType);
Pour les batches, utilisez rdk.rest.getBatch(rollupId, index) ou qorechaind query rdk batch [rollup-id] (ci-dessous) ; getLatestBatch et listBatches lisent la route latest_batch de la chaîne et toutes les pages de la liste des batches depuis la 0.6.0 (voir RDK 0.8.0 : changements et limites).
Gestion du cycle de vie
Un rollup passe par les états pending, active, paused, et stopped ; un nouveau rollup démarre immédiatement à l'état active. Seul le créateur peut le mettre en pause, le reprendre ou l'arrêter (appliqué depuis la version de chaîne v3.2.0). Chaque commande ci-dessous suit le même schéma en deux étapes que la création : générer la transaction non signée, puis la cosigner.
Pause
Suspendre temporairement le rollup. L'état est préservé et le rollup peut être repris. Une chaîne de caractères indiquant la raison est requise.
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
Reprise
Reprendre un rollup précédemment mis en pause.
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
Arrêt
Décommissionner définitivement le rollup et libérer son stake. Le QOR staké — moins le burn de création unique, et moins tout ce qui a déjà été versé depuis le séquestre du rollup par des retraits ou des récompenses de preuve de fraude — est restitué au créateur : depuis la v3.2.3, un registre de séquestre par rollup enregistre ce que chaque rollup détient encore, stop-rollup rembourse exactement ce solde, et un rollup arrêté ne paie plus aucun retrait. Le stake d'enregistrement de la couche de 1 000 QOR est restitué séparément lorsque la couche du rollup est désactivée.
À partir de la chaîne v3.2.5 (les deux réseaux) : un rollup ne peut pas être arrêté tant que son dernier batch est submitted ou challenged ; réglez-le ou finalisez-le d'abord ; un rollup arrêté libère son emplacement sous la limite de rollups du module. Avant la v3.2.5, aucune de ces deux règles ne s'appliquait. Depuis TypeScript, stopRollupError et la vérification préalable de stopRollup vous préviennent avant que vous ne payiez les frais.
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
Arrêter un rollup est définitif. Le rollup ne peut pas être redémarré une fois arrêté.
Commandes opérateur : batches et challenges
Les opérateurs de rollup soumettent des batches de règlement, et les challengers peuvent contester des batches optimistes. Ces commandes sous-tendent la couche de règlement décrite dans Rollups Overview et ZK / STARK & Withdrawals.
Qui peut soumettre, et dans quel ordre
- Seule l'adresse de séquenceur configurée du rollup — ou, lorsqu'aucune n'est configurée (c'est le cas de tous les presets), son créateur — peut soumettre des batches. Le séquençage basé (based) et partagé n'admet pas encore d'ensembles de proposeurs ni de listes : ce ne sont aujourd'hui que des libellés, et c'est le créateur qui soumet.
- Les batches forment une chaîne : le premier batch a l'index
0; chaque batch suivant doit utiliser l'index suivant et porter la racine d'état du batch précédent commeprev_state_root. - Un batch qui porte un hash de données sur un rollup
nativeoubothest refusé tant qu'un blob correspondant n'est pas déjà stocké (voir Data Availability). Un batch sans hash de données n'est pas vérifié. - Un rollup
zkdoit joindre une preuve, et cette preuve doit être vérifiée ; aucun batch ZK ne peut encore être accepté (voir ZK / STARK & Withdrawals). - À partir de la chaîne v3.2.5 (les deux réseaux) : le
withdrawals_rootd'un batch doit être vide ou faire exactement 32 octets, et un rollup détient au plus 4 096 batches optimistes en attente (MAX_PENDING_OPTIMISTIC_BATCHESdans le RDK) ; les batches se finalisent aussi dans l'ordre des index : un batch ultérieur attend donc un batch antérieur encoresubmittedouchallenged. Le RDK vérifie la longueur de la racine avant chaque soumission. Avant la v3.2.5, aucune de ces trois règles ne s'appliquait.
Soumettre un batch
Soumettre un batch de règlement pour un rollup. Prend l'ID du rollup, un index de batch, et une racine d'état encodée en hexadécimal. Pour chaque batch après le premier, passez la racine d'état du batch précédent avec --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
| Flag | Description |
|---|---|
--prev-state-root | Racine d'état hexadécimale dont part le batch (obligatoire pour chaque batch après l'index 0) |
--tx-count | Nombre de transactions du rollup dans le batch |
--data-hash | Hash hexadécimal des données du batch publiées sous forme de blob DA (laissez vide aujourd'hui : il n'existe aucun moyen de publier un blob, voir Data Availability) |
--withdrawals-root | Racine de Merkle hexadécimale des retraits L2 → L1 du batch (voir ZK / STARK & Withdrawals) |
--anchor-signature | Signature ML-DSA-87 hexadécimale du créateur du rollup sur les octets de signature d'ancrage v2 (depuis la v3.2.2) ; le batch est alors ancré dans x/multilayer dans la même transaction, et un ancrage refusé refuse le batch |
--validator-set-hash | Engagement hexadécimal de l'ensemble de validateurs, porté dans l'ancrage et couvert par la signature |
Sans --anchor-signature, le batch est réglé sans ancrage. Pour ancrer un batch, affichez les octets à signer, signez-les avec la clé post-quantique enregistrée du créateur, et passez la signature (les valeurs --tx-count et --validator-set-hash doivent correspondre à celles que vous soumettez) :
qorechaind query rdk anchor-sign-bytes [layer-id] [batch-index] [state-root-hex] \
--chain-id qorechain-diana --tx-count 120
layer-id est l'ID de couche du rollup (l'ID du rollup pour les rollups créés par le RDK). Depuis TypeScript, RdkTxClient.submitBatch dans @qorechain/rdk 0.6.0 et versions ultérieures signe l'ancrage pour vous lorsque le client signe en mode hybride et est le créateur du rollup, et anchorSignBytesForBatch fournit à un créateur les octets à signer hors bande (voir RDK 0.8.0 : changements et limites). Le --proof ZK d'un rollup zk n'a aujourd'hui aucun flag CLI, et le message resolve-challenge n'est pas une commande CLI : utilisez un client. Voir Settlement receipts pour ce qu'un ancrage prouve et ne prouve pas. Aucun rollup, couche ou ancrage n'existe encore sur l'un ou l'autre réseau.
Contester un batch (rollups optimistes)
Tout compte peut contester un batch submitted pendant la fenêtre de contestation (100 800 blocs par défaut pour un batch soumis sur le mainnet avant la hauteur 3,742,566 ; à partir de la v3.2.4, une fenêtre en secondes de temps de bloc pour les nouveaux batches : sur le testnet depuis la hauteur 8,337,253, sur le mainnet depuis la hauteur 3,742,566) en déposant une caution (le challenge_bond du rollup ; 1 000 QOR pour les presets nft et custom) et une preuve de fraude. Un batch optimiste est jugé selon que sa racine d'état est ou non la racine de transition canonique : un soumetteur doit donc publier exactement cette racine (les templates du RDK le font, à partir de la 0.6.1 ; voir RDK 0.8.0 : changements et limites). Prend l'ID du rollup et l'index du batch ; passez la preuve de fraude avec --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
| Flag | Description |
|---|---|
--proof | Preuve de fraude encodée en hexadécimal |
Une contestation gèle le batch (challenged) : il ne peut pas être finalisé. Avant la v3.2.5, seul le créateur du rollup pouvait le résoudre ; à partir de la v3.2.5 (les deux réseaux), n'importe quel compte le peut, comme décrit ci-dessous. La résolution est soumise avec un message resolve-challenge (non exposé comme commande CLI ; utilisez un client). La chaîne décide elle-même du résultat en vérifiant la preuve stockée. Si la fraude est confirmée, le batch est rejected, la caution est restituée et le challenger reçoit un montant supplémentaire égal à la caution, prélevé sur le stake du rollup ; si la contestation est rejetée, la caution revient au créateur et le batch repasse à l'état submitted.
À partir de la chaîne v3.2.5 (les deux réseaux) : n'importe quel compte peut résoudre une contestation, pas seulement le créateur. Une fraude confirmée rejette ce batch et chaque batch ultérieur qui n'est pas encore finalisé, et le séquenceur resoumet ces batches à partir de la dernière bonne racine d'état sous les mêmes index ; le rollup continue à partir de là. Le Watchtower distingue ces batches par index et racine d'état (voir Watchtower).
Inspecter les batches
# 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
Requêtes
| Commande | Objectif |
|---|---|
qorechaind query rdk rollup [rollup-id] | Détails d'un rollup spécifique |
qorechaind query rdk list-rollups | Tous les rollups enregistrés |
qorechaind query rdk batch [rollup-id] | Dernier batch de règlement (ou --index) |
qorechaind query rdk batches [rollup-id] | Une page de batches dans l'ordre des index (--start, --limit) |
qorechaind query rdk anchor-sign-bytes [layer-id] [batch-index] [state-root-hex] | Les octets de signature d'ancrage v2 d'un batch (hors ligne) |
qorechaind query rdk config | Paramètres du module RDK |
qorechaind query rdk suggest-profile [use-case] | Affiche un renvoi vers le RPC qor_suggestRollupProfile ; les endpoints publics ne le servent pas, choisissez donc un profil dans le tableau des Preset Profiles |
Prochaines étapes
- Data Availability — backends DA native, Celestia, et redondant.
- ZK / STARK & Withdrawals — vérification de preuves et flux de retrait L2 → L1 via
execute-withdrawal.