Aller au contenu principal

Première transaction

Ce guide explique comment envoyer des tokens QOR, interroger des transactions et interagir avec QoreChain via ses interfaces native, EVM et SVM.

remarque

Les commandes ci-dessous utilisent le testnet qorechain-diana (chain ID EVM 9800). Le mainnet (qorechain-vladi, chain ID EVM 9801) est en production depuis le 7 juin 2026 et exécute la version v3.2.7 depuis le 12 novembre 2026 (le testnet exécute la v3.2.8 depuis le 12 novembre 2026) — remplacez le chain ID et les endpoints par ceux du mainnet indiqués sur la page Connecting to Mainnet lorsque vous transactez sur le mainnet.

Vérifier votre solde​

Avant d'envoyer des tokens, vérifiez le solde de votre compte :

qorechaind query bank balances qor1youraddress... --output json

La réponse inclut toutes les dénominations de tokens détenues par le compte. Les soldes QOR sont affichés en uqor (micro-QOR), où 1 QOR = 1 000 000 uqor.

Envoyer des QOR​

Un compte QoreChain envoie sur la voie Cosmos avec une signature hybride : la signature classique secp256k1 plus une signature ML-DSA-87 (Dilithium-5). Un simple qorechaind tx bank send ... -y est rejeté ; le transfert est donc construit sans signature, puis cosigné. Vous devez avoir enregistré une fois une clé post-quantique sur votre compte (voir Enregistrer votre clé post-quantique ci-dessous), et utiliser le binaire de version officiel qorechaind depuis download.qore.host (un binaire compilé à partir de l'arborescence de sources publique ne peut ni créer ni appliquer de signature Dilithium).

# 1. Build the unsigned transaction (the fee is fixed here, because cosign signs the fee in this file)
qorechaind tx bank send mykey qor1recipient... 1000000uqor \
--chain-id qorechain-diana \
--gas 400000 --fees 60000uqor \
--generate-only > tx.json

# 2. Add the ML-DSA-87 signature and broadcast
qorechaind tx pqc cosign tx.json --from mykey --pqc-key mypqc --chain-id qorechain-diana

Cela envoie 1 QOR (1 000 000 uqor) à l'adresse destinataire et paie des frais de 60 000 uqor (0,06 QOR). Le plancher du réseau est de 0,1 uqor par unité de gas : les frais doivent donc être au moins égaux à la limite de gas multipliée par 0,1 — --gas 400000 nécessite --fees 40000uqor ou plus. Les exemples paient 0,15 uqor par unité de gas (--fees 60000uqor) : à partir de la v3.2.8, le mempool ordonne les transactions par frais par unité de gas, de sorte qu'un transfert qui ne paie que le plancher attend derrière les autres lorsque les blocs sont chargés. Un transfert signé en hybride consomme généralement entre 160 000 et 240 000 de gas, car la signature ajoute environ 4,7 Ko à la transaction. cosign demande au nœud quelle forme d'octets signés le réseau vérifie, de sorte que la même commande fonctionne sur les deux réseaux.

Enregistrer votre clé post-quantique​

Une clé post-quantique est enregistrée explicitement, une fois par compte. La chaîne ne l'enregistre pas pour vous lors de votre première transaction. La transaction d'enregistrement elle-même (ainsi que la migration de clé) peut être signée avec la seule clé classique, afin qu'un compte tout neuf puisse s'initialiser :

# generate the ML-DSA-87 key (stored under ~/.qorechaind/pqc/mypqc.dilithium, mode 0600, not encrypted)
qorechaind tx pqc gen-key mypqc

# register the printed public key for your account
qorechaind tx pqc register-key <public_key_hex> hybrid --from mykey \
--chain-id qorechain-diana --gas 600000 --fees 90000uqor

Depuis la v3.2.3, la chaîne accepte aussi une preuve de possession facultative avec l'enregistrement, et refuse les clés faibles, dégénérées ou déjà utilisées. Pour en joindre une, enregistrez avec register-key-v2 et nommez votre clé locale :

qorechaind tx pqc register-key-v2 dilithium5 <public_key_hex> hybrid --from mykey --pqc-key mypqc \
--chain-id qorechain-diana --gas 600000 --fees 90000uqor

Sauvegardez le fichier de clé PQC aussi soigneusement que votre phrase de récupération ; il peut être re-dérivé à partir de la phrase avec qorechaind tx pqc recover-key. QoreX et le SDK QoreChain effectuent l'enregistrement de la clé pour vous. Consultez Wallet Setup pour le flux hybride complet.

Les transferts Cosmos exigent une signature PQC hybride

Sur la voie Cosmos, le paramètre du réseau est hybrid_signature_mode = required (les réseaux en production exécutent la ligne v3.2). Une transaction purement classique est rejetée. Pour produire la signature hybride en dehors du CLI, la bibliothèque open source qorechain-pqc (hybridSignBytes) et le SDK QoreChain font l'équivalent en code.

Une fois la transaction cosignée acceptée, le CLI renvoie un hash de transaction.

La première transaction d'un nouveau compte​

À partir de la version v3.2.8 (testnet depuis le 12 novembre 2026 ; le mainnet ne l'a pas appliquée), la première transaction d'un compte tout neuf doit être l'enregistrement de sa clé post-quantique : MsgRegisterPQCKeyV2, accompagné de la preuve de possession et signé avec la seule clé classique. Toute autre première transaction d'un compte sans clé enregistrée est refusée. Cela concerne un nouveau compte qui a été approvisionné mais n'a encore rien envoyé ; un compte qui possède déjà une clé enregistrée n'est pas concerné.

Pourquoi c'est important. Chaque transaction suivante sur la voie Cosmos est signée en hybride (secp256k1 plus ML-DSA-87), et la chaîne ne peut vérifier la partie ML-DSA-87 que par rapport à une clé qu'elle connaît déjà. L'enregistrement est la seule transaction qui ne peut pas encore porter cette signature ; c'est donc la seule que la chaîne accepte avec une signature classique seule, et elle doit venir en premier. Si vous envoyez un transfert, une délégation ou un appel de contrat avant d'enregistrer, la transaction est refusée et vous enregistrez d'abord.

Enregistrer la clé​

Avec le CLI, utilisez register-key-v2 exactement comme dans Enregistrer votre clé post-quantique ci-dessus (la clé doit d'abord être générée avec qorechaind tx pqc gen-key mypqc) :

qorechaind tx pqc register-key-v2 dilithium5 <public_key_hex> hybrid --from mykey --pqc-key mypqc \
--chain-id qorechain-diana --gas 600000 --fees 90000uqor

Avec le SDK TypeScript (0.9.0 ou ultérieur), ensurePqcRegistered lit d'abord l'état de la clé, ignore la transaction si votre clé est déjà enregistrée, joint la preuve de possession et envoie lui-même l'enregistrement en signature classique :

import {
createClient,
deriveNativeAccount,
directSignerFromPrivateKey,
derivePqcCanonical,
ensurePqcRegistered,
} from "@qorechain/sdk";

const client = createClient({
endpoints: { rest: "https://api-testnet.qore.host", rpc: "https://rpc-testnet.qore.host" },
});
const account = await deriveNativeAccount(mnemonic);
const signer = await directSignerFromPrivateKey(account.privateKey, "qor");
const pqcKeypair = derivePqcCanonical(account.address, mnemonic);
const tx = await client.connectTx(signer, { pqcKeypair });

const res = await ensurePqcRegistered(tx, {
pqcKeypair,
rest: client.network.endpoints.rest,
fee: { amount: [{ denom: "uqor", amount: "90000" }], gas: "600000" },
});
console.log(res.alreadyRegistered ? "already registered" : res.txHash);

Si vous n'avez besoin que du message (par exemple pour l'intégrer dans votre propre corps de transaction), buildRegisterPqcKeyMsg(sender, { pqcKeypair, ecdsaPubkey, proofOfPossession }) renvoie le MsgRegisterPQCKeyV2 sans l'envoyer.

Les autres SDK offrent le même assistant idempotent ; tous lisent d'abord l'état de la clé via REST et n'enregistrent jamais à l'aveugle :

LangageAssistant
Pythonqorsdk.pqc_dx.ensure_pqc_registered(account=..., pqc_keypair=..., chain_id=..., account_number=..., sequence=..., rest_url=..., fee=...)
Gopqcdx.New(pqcdx.Signer{...}, pqcdx.Options{}).EnsurePQCRegistered(pqcdx.RegisterOptions{})
RustPqcDx::ensure_pqc_registered().await
JavaPqcDx.ensurePqcRegistered(signer, broadcaster, qor, new PqcDx.EnsureOptions())

Pour la configuration complète du signataire dans chaque langage, consultez la référence du SDK correspondant. L'enregistrement exige que le compte détienne assez de QOR pour payer les frais : approvisionnez donc le nouveau compte avant d'enregistrer.

Estimer les frais avec la signature incluse​

Une signature hybride ajoute environ 4,7 Ko à la transaction et la chaîne facture des frais de vérification pour celle-ci ; des frais estimés à partir d'une copie non signée ou signée en classique seulement sont donc trop bas. Simulez la transaction avec la signature hybride incluse, ou laissez le SDK le faire : les frais par défaut du client TypeScript sont "auto", ce qui simule la transaction hybride et fixe la limite de gas à partir du résultat.

import { toBase } from "@qorechain/sdk";

// "auto" is the default: the client simulates the hybrid transaction itself.
await tx.bankSend("qor1recipientaddress...", [{ denom: "uqor", amount: toBase("1.5") }]);
TransactionGas typiqueExemple de frais à 0.15 uqor par unité de gas
Transfert signé en hybrideenviron 160,000 à 240,00024,000 à 36,000 uqor
Enregistrement de cléenviron 600,000 (limite à fixer)90,000 uqor

Testé sur le testnet. Le 12 novembre 2026 (version v3.2.8), un compte eth-native tout neuf avec 500 QOR a envoyé l'enregistrement en premier (SDK 0.13.0, signé en classique, avec la preuve de possession) : code 0, 299,233 de gas utilisé sous une limite de 600,000 et des frais de 90,000 uqor. Son premier transfert signé en hybride a ensuite utilisé 187,494 de gas sous une limite de 400,000 (frais de 60,000 uqor). La relecture de la transaction via GET /cosmos/tx/v1beta1/txs/{hash} a montré le code 0, l'extension /qorechain.pqc.v1.PQCHybridSignature portant une signature ML-DSA-87 de 4,627 octets, et les événements pqc_verify (hybrid_mode=required) et pqc_hybrid_verify (status=verified). La règle selon laquelle l'enregistrement doit être la première transaction provient de l'équipe de la chaîne ; une première transaction d'un autre type n'a pas été essayée.

Le plancher du réseau est de 0.1 uqor par unité de gas ; à partir de la v3.2.8, le mempool ordonne les transactions par frais par unité de gas : payer un peu au-dessus du plancher évite qu'une transaction attende derrière les autres lorsque les blocs sont chargés.

Ce que vous voyez si vous sautez l'enregistrement​

Ce que vous voyezSignificationQue faire
Un refus indiquant que le compte n'a pas de clé PQC enregistrée ou doit inclure une signature hybride (module pqc, code 8 ; le SDK signale pqc_key_required)Le compte n'a pas encore de clé enregistréeEnregistrez la clé comme ci-dessus, puis renvoyez
Enregistrement refusé avec already registered (module pqc, code 7)Le compte détient déjà une cléRien à faire ; lisez l'enregistrement avec GET /qorechain/pqc/v1/account/{address} ou utilisez ensurePqcRegistered (il lève PqcKeyMismatchError pour une clé différente)

Voir aussi Démarrage rapide du SDK, Signature post-quantique et Wallet Setup.

Interroger une transaction​

Recherchez une transaction terminée à partir de son hash :

qorechaind query tx <txhash>

La sortie inclut le statut de la transaction, le gas consommé, la hauteur de bloc et tous les événements émis pendant l'exécution.

Pour une sortie au format JSON :

qorechaind query tx <txhash> --output json

Utiliser JSON-RPC (EVM)​

L'environnement d'exécution EVM de QoreChain expose une interface JSON-RPC Ethereum standard sur le port 8545.

Les transactions EVM nécessitent une fenêtre d'autorisation

La signature Ethereum standard (MetaMask, ethers.js, ...) fonctionne toujours sans modification, mais depuis la v3.2.0 la voie EVM n'admet une transaction que d'un compte disposant d'une clé post-quantique enregistrée et d'une fenêtre d'autorisation EVM ouverte. Ouvrez-en une d'abord (c'est une transaction de la voie Cosmos, signée avec votre clé ML-DSA) — voir Fenêtre d'autorisation EVM ci-dessous. Sans elle, le nœud répond no open EVM authorisation window. La lecture de l'état (eth_blockNumber, eth_getBalance, eth_call, eth_estimateGas) ne nécessite aucune fenêtre.

Obtenir le dernier numéro de bloc​

curl -s -X POST http://localhost:8545 \
-H "Content-Type: application/json" \
-d '{
"jsonrpc": "2.0",
"method": "eth_blockNumber",
"params": [],
"id": 1
}' | jq '.result'

Obtenir le solde d'un compte​

curl -s -X POST http://localhost:8545 \
-H "Content-Type: application/json" \
-d '{
"jsonrpc": "2.0",
"method": "eth_getBalance",
"params": ["0xYourEVMAddress", "latest"],
"id": 1
}' | jq '.result'

Le solde est renvoyé sous forme de valeur encodée en hexadécimal, dans la plus petite dénomination.

Fenêtre d'autorisation EVM​

Depuis la version de chaîne v3.2.0 (hauteur mainnet 2,981,742, 25 septembre 2026 ; hauteur testnet 5,920,000), la voie EVM n'admet une transaction que d'un compte qui

  1. dispose d'une clé post-quantique enregistrée (ML-DSA-87), et
  2. dispose d'une fenêtre d'autorisation EVM ouverte qui a encore de la place pour la transaction.

Tout le reste de la voie EVM est inchangé : vous continuez à signer avec MetaMask, ethers.js, Hardhat ou Foundry, et eth_estimateGas ainsi que les autres simulations fonctionnent sans fenêtre. Les déploiements de contrats comptent comme n'importe quelle autre transaction EVM : une fenêtre est donc nécessaire avant de déployer.

Pourquoi une fenêtre ? Un wallet standard produit une seule signature secp256k1 sur une transaction Ethereum et ne laisse aux applications aucun moyen d'y joindre une seconde signature post-quantique. L'autorisation post-quantique voyage donc avant la transaction : vous ouvrez une fenêtre bornée avec une transaction normale de la voie Cosmos, qui, elle, porte votre signature ML-DSA, et la voie EVM admet ensuite les transactions couvertes par cette fenêtre. Une clé classique seule ne peut jamais ouvrir de fenêtre : une clé classique volée ne peut donc agir, sur la voie EVM, que dans les limites d'une fenêtre déjà ouverte. Cela fonctionne comme une approbation : on autorise un nombre borné de transactions et un montant borné de QOR natif pour une durée bornée, puis on transige normalement. La fenêtre ne plafonne ni les montants de tokens ni les approbations qu'un contrat détient déjà.

Ce que borne une fenêtre. Trois bornes s'appliquent en même temps ; la première atteinte ferme la fenêtre.

BorneSignificationPlage autorisée
blocksDurée pendant laquelle la fenêtre reste ouverte, comptée à partir du bloc qui l'ouvre1 – 17,280
max-txsNombre de transactions EVM qu'elle admet1 – 1,000
max-valueSortie totale qu'elle admet, en uqor : valeur transférée plus les frais maximaux que chaque transaction pourrait payer (limite de gas × plafond de frais), arrondi à l'unité supérieuresupérieur à 0
  • 17,280 blocs représentent environ 15 heures sur le mainnet (environ 3,1 s par bloc) et environ 6 heures sur le testnet (environ 1,3 s par bloc).
  • Une transaction admise qui échoue consomme tout de même son emplacement et son budget de valeur.
  • L'ouverture d'une nouvelle fenêtre remplace la précédente ; la consommation repart de zéro.
  • Le CLI accepte max-value en uqor ou en qor (1000qor = 1,000,000,000 uqor).
  • La borne de valeur ne compte que le QOR natif : un transfert de token, une approbation ou tout autre appel de contrat porte une valeur nulle. La portée (ci-dessous) restreint les destinataires que la fenêtre admet ; elle ne plafonne pas les montants de tokens.

Étape 1 — enregistrez votre clé post-quantique (une seule fois) : voir Enregistrer votre clé post-quantique ci-dessus.

Étape 2 — ouvrez une fenêtre. L'ouverture d'une fenêtre est une transaction de la voie Cosmos : elle est donc produite sans signature, puis cosignée :

# at most 1000 QOR in total, at most 20 transactions, for 7,200 blocks (about 6.4 hours on mainnet)
qorechaind tx pqc open-evm-window 7200 20 1000qor --from mykey \
--chain-id qorechain-diana --gas 400000 --fees 60000uqor --generate-only > window.json

qorechaind tx pqc cosign window.json --from mykey --pqc-key mypqc --chain-id qorechain-diana

Restreindre la portée (v3.2.3 et ultérieures). Deux options facultatives restreignent ce qu'une fenêtre ouverte admet : --native-only n'admet que des transferts de QOR natif simples (pas de calldata, pas de création de contrat, pas de destinataire qui porte du code), et --allowed-targets 0xAAA...,0xBBB... n'admet que les transactions vers ces destinataires (16 au plus ; la création de contrat est alors refusée). Par exemple :

qorechaind tx pqc open-evm-window 7200 20 1000qor --native-only --from mykey \
--chain-id qorechain-diana --gas 400000 --fees 60000uqor --generate-only > window.json

--allowed-targets limite quels contrats et tokens la fenêtre peut toucher, pas combien. Un token listé admet n'importe quel montant de ce token, y compris approve, et un contrat listé peut déplacer tout ce que son code et ses approbations existantes permettent ; ne listez donc pas de contrats de transfert ou de routeur génériques. Une fenêtre ne borne que les transactions de la voie EVM (signées de façon classique) ; les messages Cosmos signés avec la signature hybride PQC, comme les appels cross-VM et authz, sont hors de son champ.

Sur le mainnet, l'ouverture d'une fenêtre a consommé environ 180 000 de gas. Dans QoreX, la même étape correspond à Réglages → Sécurité → Fenêtre d'accès EVM (application) ou au bouton Fenêtre d'accès EVM (extension). L'ouverture de la fenêtre fait avancer le nonce de votre compte : ouvrez-la donc avant de préparer la transaction EVM dans votre wallet.

Étape 3 — vérifiez ce qu'il reste :

qorechaind query pqc evm-window qor1youraddress...
curl -s https://api-testnet.qore.host/qorechain/pqc/v1/evm_window/qor1youraddress...

La réponse REST n'échoue jamais pour une adresse sans fenêtre ; elle renvoie found: false. Les champs sont found, live, opened_height, expiry_height, max_txs, used_txs, max_value, used_value, remaining_blocks, remaining_txs et remaining_value (entiers en uqor, renvoyés sous forme de chaînes). Sur le mainnet, utilisez https://api.qore.host.

Étape 4 — utilisez normalement la voie EVM. Envoyez depuis MetaMask ou vos outils comme d'habitude. Chaque transaction consomme un emplacement de transaction et (valeur + frais maximaux) de la fenêtre.

Fermer une fenêtre plus tôt. Si vous soupçonnez que votre clé classique est compromise, fermez la fenêtre ; tout ce qu'elle admettait encore est refusé à partir du bloc suivant. La fermeture révoque aussi tout consentement de délégation EIP-7702 en attente (depuis la v3.2.2 ; une transaction de type 4 qui modifie le code d'un compte n'est admise qu'après un consentement post-quantique authorize-evm-delegation) :

qorechaind tx pqc close-evm-window --from mykey --chain-id qorechain-diana \
--gas 400000 --fees 60000uqor --generate-only > close.json
qorechaind tx pqc cosign close.json --from mykey --pqc-key mypqc --chain-id qorechain-diana

Erreurs

Ce que vous voyezSignificationQue faire
no open EVM authorisation window; open one with MsgOpenEVMWindow ... (module pqc, code 26)Aucune fenêtre pour ce compteÉtape 2
... has no registered post-quantum key; the EVM lane requires one (code 26 sur la voie EVM ; code 28 si vous essayez d'ouvrir une fenêtre)Aucune clé ML-DSA enregistréeÉtape 1
the EVM authorisation window for ... does not admit this transaction (remaining: ...) (code 27)Expirée ou épuisée ; le message indique quelle borneOuvrez une nouvelle fenêtre
invalid EVM authorisation window (code 28)Bornes hors plage (blocks 1–17,280, max-txs 1–1,000, max-value > 0)Corrigez les arguments

Depuis le code, le SDK QoreChain et @qorechain/wallet-adapter peuvent composer les messages d'ouverture et de fermeture et lire l'état de la fenêtre ; voir la documentation du SDK.

La fenêtre ne s'applique qu'à la voie EVM. Les transactions de la voie Cosmos portent déjà la signature hybride à chaque transaction, et si vous n'ouvrez jamais de fenêtre, vos transactions EVM sont refusées sans que rien d'autre ne change.

Utiliser SVM RPC​

L'environnement d'exécution SVM de QoreChain expose une interface RPC compatible Solana sur le port 8899. La voie de transactions SVM est actuellement désactivée sur l'ensemble du réseau : ces méthodes de lecture sont donc la partie que vous pouvez utiliser aujourd'hui.

Obtenir le slot actuel​

curl -s -X POST http://localhost:8899 \
-H "Content-Type: application/json" \
-d '{
"jsonrpc": "2.0",
"method": "getSlot",
"id": 1
}' | jq '.result'

Obtenir le solde d'un compte​

curl -s -X POST http://localhost:8899 \
-H "Content-Type: application/json" \
-d '{
"jsonrpc": "2.0",
"method": "getBalance",
"params": ["YourSVMPublicKey"],
"id": 1
}' | jq '.result'

Motifs CLI courants​

Lorsque vous travaillez avec le CLI qorechaind, ces options sont utilisées fréquemment :

OptionDescriptionExemple
--chain-idSpécifie la chaîne cible--chain-id qorechain-diana
--feesFrais de transaction en uqor (limite de gas × au moins 0,1)--fees 40000uqor
--fromNom de clé ou adresse de signature--from mykey
--outputFormat de la réponse--output json
--nodeEndpoint RPC auquel se connecter--node tcp://localhost:26657
--gasLimite de gas pour la transaction--gas 400000 (ou --gas auto)
--gas-adjustmentMultiplicateur pour le gas estimé--gas-adjustment 1.5
--gas-pricesPrix du gas au lieu de --fees--gas-prices 0.1uqor
--generate-onlyAffiche la transaction sans signature (requis avant tx pqc cosign)--generate-only
-yIgnore la demande de confirmation-y

Exemple : commande complète avec toutes les options courantes​

qorechaind tx bank send mykey qor1recipient... 500000uqor \
--chain-id qorechain-diana \
--gas 400000 --fees 60000uqor \
--node tcp://localhost:26657 \
--output json \
--generate-only > tx.json

qorechaind tx pqc cosign tx.json --from mykey --pqc-key mypqc --chain-id qorechain-diana

Prochaines étapes​

Maintenant que vous avez envoyé votre première transaction, découvrez le reste de ce que QoreChain propose :

  • Staking et délégation — Stakez vos QOR pour contribuer à la sécurité du réseau et recevoir des récompenses de staking
  • Bridging des actifs — Déplacez des actifs entre chaînes
  • Développement EVM — Déployez des smart contracts Solidity sur QoreChain