Aller au contenu principal

Architecture multicouche

QoreChain met en œuvre une architecture de chaînes hiérarchique à 4 niveaux via le module x/multilayer. La chaîne principale sert de racine de règlement et de confiance, tandis que les couches subsidiaires (sidechains, paychains et rollups) prennent en charge des charges de travail spécialisées avec différents compromis de performance et de sécurité.

Capacité à un stade précoce

Le module est déployé sur le mainnet (version de chaîne v3.2.7 depuis le 12 novembre 2026) et sur le testnet (v3.2.8 depuis le 12 novembre 2026), mais aucune couche et aucune ancre n'existe encore sur l'un ou l'autre réseau (vérifié le 30 octobre 2026 sur les deux, puis de nouveau sur le mainnet le 4 novembre 2026, en v3.2.6 : GET /qorechain/multilayer/v1/layers renvoie une liste vide). Tout ce qui suit décrit le module tel qu'il est construit ; les paramètres sont les valeurs en vigueur. Sur le mainnet, le message MsgUpdateLayerStatus est actuellement désactivé par le disjoncteur (voir Paramètres de la chaîne) ; sur le testnet, il ne l'est pas.


Vue d'ensemble du système​

La hiérarchie à 4 niveaux ci-dessous présente la chaîne principale comme racine de règlement et de confiance, avec trois types de couches subsidiaires ancrant leurs racines d'état vers celle-ci via des schémas d'engagement hiérarchiques (HCS).

+---------------------------+
| MAIN CHAIN |
| (Settlement + Routing) |
| Full CPoS consensus |
| PQC-secured (Dilithium-5)|
| QCAI routing engine |
+------+------+------+------+
| | |
+------------+ | +------------+
| | |
+---------v--------+ +-------v--------+ +---------v---------+
| SIDECHAINS | | PAYCHAINS | | ROLLUPS |
| (Compute) | | (MicroTX) | | (App-Specific) |
| 3-10 validators | | 500ms blocks | | 4 settlement |
| 1,000 QOR min | | 100 QOR min | | modes |
| Max: 10 | | Max: 50 | | 10,000 QOR min |
+------------------+ +----------------+ | Max: 100 (x/rdk) |
+-------------------+

Types de couches​

Chaîne principale​

La chaîne principale est la racine de confiance de l'ensemble de l'écosystème QoreChain.

PropriétéValeur
ConsensusConsensus QoreChain (voir Mécanisme de consensus pour ce qui est branché aujourd'hui)
SécuritéSécurisé par PQC avec signatures Dilithium-5
RôleCouche de règlement, stockage des ancres d'état, moteur de routage QCAI, racine de confiance
Temps de blocVariable selon le réseau : environ 3,1 secondes sur le mainnet, environ 1,3 seconde sur le testnet (mesuré le 27 octobre 2026)

Toutes les couches subsidiaires ancrent périodiquement leurs racines d'état à la chaîne principale via des schémas d'engagement hiérarchiques (HCS).

Sidechains​

Les sidechains prennent en charge les opérations à forte intensité de calcul telles que les protocoles DeFi, les moteurs de jeu et le traitement de données IoT.

ParamètreValeur
Validateurs minimum3
Validateurs maximum10
Mise minimale du créateur1,000 QOR
Sidechains actives maximum10
Domaines ciblesDeFi, Gaming, IoT

Paychains​

Les paychains sont optimisées pour les microtransactions à haute fréquence avec une latence minimale.

ParamètreValeur
Temps de bloc cible500 ms
Paychains actives maximum50
Mise minimale du créateur100 QOR
Domaines ciblesPaiements, streaming, micro-transactions

Rollups​

Les rollups sont des chaînes spécifiques à une application déployées via le Rollup Development Kit (x/rdk). Lorsqu'un rollup est créé, le RDK enregistre une couche pour lui dans le module multilayer (comme couche de type sidechain, voir ci-dessous).

ParamètreValeur
Modes de règlement4 (optimistic, zk, based, sovereign)
Rollups enregistrés maximum100 (max_rollups) ; mais seules 10 couches de type sidechain peuvent exister à la fois (max_sidechains), si bien qu'au plus 10 rollups peuvent avoir une couche ancrable
Mise minimale du créateur10,000 QOR pour le rollup, plus 1,000 QOR de mise d'enregistrement de la couche (min_sidechain_stake)
Type de coucheLes rollups enregistrés via le RDK utilisent le type de couche sidechain (le type de couche rollup est défini mais n'est pas encore utilisé par x/rdk)
Domaines ciblesDeFi, Gaming, NFT, Enterprise

Le déploiement et la configuration des rollups sont traités en détail dans le Rollup Development Kit.


Routage des transactions QCAI​

Le routeur QCAI évalue toutes les couches actives pour chaque transaction entrante et sélectionne la destination optimale à l'aide d'un modèle de notation pondérée à 4 facteurs.

Formule de notation​

Chaque couche candidate reçoit un score composite (plus élevé est meilleur) :

Score = w_congestion * (1 - Congestion) + w_capability * Capability + w_cost * (1 - Cost) + w_latency * (1 - Latency)
FacteurPoidsDescription
Congestion0.30Niveau de charge actuel (inversé : moins de congestion = score plus élevé)
Capacité0.40Adéquation de la couche aux exigences de la transaction
Coût0.20Multiplicateur de frais par rapport à la chaîne principale (inversé : coût plus faible = score plus élevé)
Latence0.10Temps de finalité attendu (inversé : latence plus faible = score plus élevé)

Seuil de confiance​

Le routeur exige un score de confiance minimum de 0.6 avant de router une transaction vers une couche subsidiaire. Si aucune couche n'atteint ce seuil, la transaction est par défaut dirigée vers la chaîne principale.

Une indication de couche préférée peut être fournie par l'expéditeur de la transaction. Si la couche préférée obtient un score d'au moins 80 % du seuil de confiance (soit 0.48), elle est acceptée comme cible de routage.

Heuristiques de charge utile​

Lorsque les métadonnées détaillées de la transaction ne sont pas disponibles, le routeur utilise la taille de la charge utile comme signal de classification :

Taille de charge utileCouche préféréeJustification
< 256 bytesPaychainProbablement un transfert simple ou une microtransaction
256 - 1,024 bytesChaîne principaleComplexité de transaction standard
> 1,024 bytesSidechainProbablement une interaction de contrat complexe

Schémas d'engagement hiérarchiques (HCS)​

Les couches subsidiaires engagent périodiquement leur état sur la chaîne principale via des ancres d'état. Chaque ancre contient une preuve cryptographique de l'état de la chaîne subsidiaire à une hauteur donnée.

Contenu d'une ancre​

ChampDescription
layer_idIdentifiant de la couche subsidiaire
layer_heightHauteur de bloc sur la chaîne subsidiaire
state_rootRacine de Merkle de l'arbre d'état de la chaîne subsidiaire
validator_set_hashHachage de l'ensemble des validateurs ayant signé l'engagement
pqc_aggregate_signatureSignature agrégée Dilithium-5 sur les données de l'ancre
transaction_countNombre de transactions depuis la dernière ancre
compressed_state_proofPreuve compressée de transition d'état

Identifiants de couche et de rollup​

Depuis la v3.2.2, un nouvel identifiant de couche (et un identifiant de rollup, qu'un rollup partage avec sa couche) doit respecter ^[a-z0-9][a-z0-9._-]{2,63}$ : de 3 à 64 caractères, lettres minuscules, chiffres, ., _ et -, commençant par une lettre ou un chiffre. Le keeper le vérifie lors de la création de la couche, et une transaction qui échoue à cette vérification paie tout de même ses frais ; validez donc les identifiants côté client d'abord. Les identifiants créés avant la v3.2.2 ne sont pas affectés.

Soumission d'une ancre​

Les ancres sont soumises à la chaîne principale via MsgAnchorState. Le keeper valide l'ancre selon les étapes suivantes :

  1. La couche existe et est active — Le keeper vérifie que la couche existe dans l'état et possède actuellement le statut active.
  2. Intervalle minimal d'ancrage écoulé — Le keeper vérifie qu'au moins min_anchor_interval blocs (par défaut : 100) se sont écoulés depuis la dernière ancre de cette couche.
  3. Signature agrégée PQC — Le keeper s'assure que la signature agrégée PQC est présente et valide pour les données de l'ancre. La signature est vérifiée par rapport à la clé ML-DSA-87 enregistrée du créateur de la couche ; une ancre est refusée lorsque le créateur n'a enregistré aucune clé.

Une ancre de règlement écrite via x/rdk (un lot soumis avec une anchor_signature, depuis la v3.2.2) est un cas particulier : elle saute la vérification de l'intervalle minimal parce que les lots arrivent dans l'ordre, elle peut ancrer une couche encore à l'état proposed (rien sur la chaîne ne promeut une couche enregistrée par un rollup RDK), et elle n'est acceptée que si l'émetteur est le créateur de la couche lui-même. La vérification de la signature est la même.

Période de contestation​

Chaque ancre entre dans une période de contestation de 24 heures (86,400 secondes, configurable par couche). Pendant cette période, toute partie peut contester l'ancre en soumettant une preuve de fraude via MsgChallengeAnchor. Si la preuve de fraude est valide, l'ancre est invalidée et l'état de la chaîne subsidiaire est ramené à l'ancre précédente.

Une fois la période de contestation expirée sans contestation aboutie, l'ancre est considérée comme finalisée.

Lecture des ancres​

Les ancres sont lisibles via le service de requête multilayer. Deux requêtes exposent l'état des ancres à la fois via gRPC et REST :

  • Anchor (/qorechain/multilayer/v1/anchor/{layer_id}) — renvoie la dernière ancre d'état d'une couche.
  • Anchors (/qorechain/multilayer/v1/anchors/{layer_id}) — renvoie l'historique des ancres d'une couche.

Chaque ancre porte une signature Dilithium-5 (ML-DSA-87) du créateur de la couche. Le message signé dépend de la hauteur à laquelle l'ancre est soumise :

  • À partir de la v3.2.2 (hauteur mainnet 3,556,788, hauteur testnet 6,905,034) : v2. Chaque champ de longueur variable est précédé d'une longueur sur 8 octets en big-endian, l'identifiant de chaîne fait partie du message, et le nombre de transactions ainsi que la preuve d'état compressée sont couverts :
"qorechain-multilayer-anchor-v2"
‖ BE64(len(chain_id)) ‖ chain_id
‖ BE64(len(layer_id)) ‖ layer_id
‖ BE64(layer_height)
‖ BE64(len(state_root)) ‖ state_root
‖ BE64(len(validator_set_hash)) ‖ validator_set_hash
‖ BE64(transaction_count)
‖ BE64(len(compressed_state_proof)) ‖ compressed_state_proof
  • Avant la v3.2.2 : v1 (layer_id ‖ layer_height (8-byte big-endian) ‖ state_root ‖ validator_set_hash, sans préfixe de longueur et sans identifiant de chaîne, de sorte qu'une signature v1 est valide sur toutes les chaînes). La chaîne n'accepte plus d'ancre v1 à partir de la hauteur de la v3.2.2.

Le message pouvant changer d'une version à l'autre, un client doit choisir la forme d'après la hauteur du plan appliqué (GET /cosmos/upgrade/v1beta1/applied_plan/v3.2.2 ; "height":"0" signifie non appliqué) plutôt que de la coder en dur. Pour un lot RDK, la correspondance est la suivante : layer_id = l'identifiant de couche du rollup, layer_height = l'indice du lot, state_root = la racine d'état du lot, transaction_count = le nombre de transactions du lot et une compressed_state_proof vide. qorechaind query rdk anchor-sign-bytes <layer-id> <batch-index> <state-root-hex> --chain-id <id> affiche ces octets hors ligne. Une signature prouve que la clé enregistrée du créateur a signé ces octets ; l'existence de l'ancre est une question qui relève de la chaîne, de sorte qu'un vérificateur doit lire l'ancre auprès d'un nœud de confiance. Aucune couche ni aucune ancre n'existe encore sur l'un ou l'autre réseau. Il s'agit de la primitive on-chain qui sous-tend les reçus de règlement du Rollup Development Kit.


Regroupement de frais inter-couches (CLFB)​

Le CLFB permet à un paiement de frais unique sur la couche source de couvrir l'exécution sur plusieurs couches dans un chemin de transaction inter-couches.

Calcul des frais​

avgMultiplier = sum(layer_multiplier_i) / num_layers
bundledFee = (totalGas / 1000) * avgMultiplier

Où :

  • layer_multiplier_i est le multiplicateur de frais de base pour chaque couche du chemin de transaction (chaîne principale = 1.0).
  • totalGas est la consommation totale de gaz estimée sur l'ensemble des couches.
  • Le résultat est libellé en uqor avec un frais minimum de 1 uqor.

Exemple​

Une transaction inter-couches touche trois couches : la chaîne principale (multiplicateur 1.0), une sidechain (multiplicateur 0.5) et une paychain (multiplicateur 0.1).

avgMultiplier = (1.0 + 0.5 + 0.1) / 3 = 0.533
bundledFee = (150,000 / 1000) * 0.533 = 80 uqor

Le CLFB peut être activé ou désactivé globalement via le paramètre cross_layer_fee_bundling, et chaque couche peut s'en exclure via son indicateur de configuration cross_layer_fee_bundling_enabled.


Cycle de vie d'une couche​

Chaque couche subsidiaire évolue à travers un cycle de vie bien défini :

Proposed --> Active --> Suspended --> Decommissioned
\ /
+-- Active <--+
StatutDescriptionTransitions autorisées
ProposedLa couche a été enregistrée mais n'est pas encore activéeActive, Decommissioned
ActiveLa couche est opérationnelle et accepte les transactionsSuspended, Decommissioned
SuspendedLa couche est temporairement suspendue (par ex. pour maintenance ou pour des raisons de sécurité)Active, Decommissioned
DecommissionedLa couche est définitivement arrêtée (état terminal)Aucune

Les transitions de statut sont imposées par le keeper. Les transitions invalides (par ex. de Decommissioned à Active) sont rejetées.


Paramètres​

ParamètreTypeDéfautDescription
max_sidechainsuint6410Nombre maximum de sidechains actives
max_paychainsuint6450Nombre maximum de paychains actives
min_anchor_intervaluint64100Nombre minimum de blocs entre les ancres d'état
max_anchor_intervaluint641,000Nombre maximum de blocs entre les ancres d'état (ancre forcée)
default_challenge_perioduint6486,400Période de contestation par défaut en secondes (24 heures)
min_sidechain_stakestring1,000,000,000Mise minimale pour créer une sidechain (1,000 QOR en uqor)
min_paychain_stakestring100,000,000Mise minimale pour créer une paychain (100 QOR en uqor)
routing_enabledbooltrueActiver le routage des transactions basé sur QCAI
routing_confidence_thresholdstring0.6Confiance minimale pour les décisions de routage QCAI
cross_layer_fee_bundlingbooltrueActiver le regroupement de frais inter-couches global

Ce sont les valeurs renvoyées par qorechaind query multilayer params (REST : /qorechain/multilayer/v1/params) sur le mainnet et le testnet le 23 octobre 2026. Depuis la v3.2.2, le MsgUpdateParams du module peut être routé, de sorte qu'une proposition de gouvernance peut les modifier.