Exemples
Les exemples TypeScript exécutables se trouvent dans le répertoire
examples/
du monorepo du SDK — ceux ci-dessous ainsi que ai-preflight,
cross-vm-call, react-dapp, register-sidechain, rollup-lifecycle,
amm-swap, connect-keplr, evm-nft et subscribe-blocks. Chaque dossier est
un paquet de workspace autonome
avec son propre README.md, son .env.example et un unique index.ts. Ils lisent
les points de terminaison et les phrases mnémoniques depuis des variables
d'environnement avec des valeurs par défaut localhost raisonnables, et ceux qui
dépendent du réseau échouent proprement avec un indice lorsqu'aucun nœud n'est
accessible. Depuis le SDK 0.12.0, les préréglages pointent déjà vers les points de terminaison
publics ; dans votre propre code, vous pouvez donc supprimer les valeurs de repli
?? "http://localhost:..." qui figurent dans les extraits ci-dessous et choisir
network: "testnet" ou "mainnet" ; conservez-les (ou choisissez localnet) lorsque vous développez
contre un nœud sur votre machine.
Depuis la racine du dépôt, installez une fois, puis exécutez n'importe quel exemple :
pnpm install
pnpm --filter @qorechain/example-pqc-hybrid-sign start
Utilisez uniquement des phrases mnémoniques de test ou des clés générées. Ne committez jamais de véritables secrets.
Les extraits ci-dessous sont condensés à partir de l'index.ts de chaque exemple. Voir la
source liée pour le programme complet et exécutable.
connect-and-query
Créez un client et lisez l'état public de la chaîne — un solde bancaire natif et
un instantané de la tokenomics. Nécessite un nœud accessible. L'exemple du dépôt
lit cet instantané via client.qor, un appel JSON-RPC qor_ que les points de
terminaison publics ne servent pas ; l'extrait ci-dessous utilise l'équivalent
REST (les statistiques de burn), qui fonctionne sur le mainnet et le testnet.
import { createClient } from "@qorechain/sdk";
const client = createClient({
network: "testnet",
endpoints: {
rest: process.env.QORE_REST_URL ?? "http://localhost:1317",
evmRpc: process.env.QORE_EVM_RPC_URL ?? "http://localhost:8545",
},
});
const balances = await client.rest.getAllBalances(address);
const burn = await client.rest.getBurnStats(); // GET /qorechain/burn/v1/stats
send-qor
Dérivez un compte natif (qor1...) à partir d'une phrase mnémonique et diffusez
un transfert de QOR : dériver → signer → simuler → estimer les frais → bankSend.
Nécessite un RPC de consensus accessible ainsi que le REST et un compte approvisionné.
Cet exemple signe uniquement avec la signature classique ; il fonctionne donc
contre un nœud local ou de développement, mais est refusé par le mainnet et le
testnet, qui exigent la signature hybride sur chaque transaction de la voie
Native. Pour les réseaux publics, connectez-vous avec la paire de clés du compte,
client.connectTx(signer, { pqcKeypair }) (SDK 0.9.0 ou ultérieur), comme dans le
Démarrage rapide.
import {
createClient,
deriveNativeAccount,
directSignerFromPrivateKey,
toBase,
} from "@qorechain/sdk";
const account = await deriveNativeAccount(mnemonic);
const signer = await directSignerFromPrivateKey(account.privateKey, prefix);
const amount = [{ denom: baseDenom, amount: toBase("1.5") }]; // "1500000" uqor
const tx = await client.connectTx(signer);
const gasEstimate = await tx.simulate(messages);
const fee = await client.fees.estimate("normal");
const result = await tx.bankSend(recipient, amount, { fee });
console.log(result.transactionHash);
svm-transfer
Construisez un transfert de SOL avec une instruction memo sur l'environnement
d'exécution compatible Solana (SVM) de QoreChain, en utilisant @qorechain/svm.
Construit et affiche la transaction hors ligne. L'envoi nécessite un JSON-RPC
SVM accessible et un compte approvisionné, et ne peut pas aboutir sur les réseaux
publics : la soumission de transactions SVM est désactivée sur l'ensemble du
réseau et les points de terminaison SVM publics sont en lecture seule (voir
Développement SVM).
import { deriveSvmAccount } from "@qorechain/sdk";
import {
createSvmClient,
svmKeypairFromSecretKey,
createMemoInstruction,
} from "@qorechain/svm";
import { LAMPORTS_PER_SOL, PublicKey } from "@solana/web3.js";
const account = await deriveSvmAccount(mnemonic);
const keypair = svmKeypairFromSecretKey(account.secretKey);
const client = createSvmClient({ endpoints: { svmRpc } });
const lamports = Math.round(0.01 * LAMPORTS_PER_SOL);
const to = new PublicKey(recipient); // `to` is a PublicKey, not a string
const tx = client.buildTransferSol({ from: keypair, to, lamports });
tx.add(createMemoInstruction("hello from @qorechain/svm", [keypair.publicKey]));
// To broadcast: client.sendTransaction(tx, [keypair])
evm-precompile
Utilisez @qorechain/evm (une fine couche au-dessus de viem) pour appeler des
précompilés QoreChain en lecture seule et lire un solde ERC-20. L'identifiant de
chaîne EVM est détecté automatiquement via eth_chainId. Les précompilés ne
sont pas actifs sur le mainnet, et sur le testnet seuls ceux de vérification PQC,
d'état des clés PQC et des paramètres de consensus le sont (voir
État du réseau) ; là où un
précompilé est inactif, et sur un nœud qui en est dépourvu, ces appels lèvent une erreur
« feature not present », signalée appel par appel.
import { createEvmClient, precompiles, erc20 } from "@qorechain/evm";
const client = await createEvmClient({ endpoints: { evmRpc } });
console.log(`evm chain id: ${await client.getChainId()}`);
const params = await precompiles.rlConsensusParams(client.publicClient);
const status = await precompiles.pqcKeyStatus(client.publicClient, account);
const bal = await erc20.balanceOf(client.publicClient, token, account);
pqc-hybrid-sign
Signature post-quantique avec ML-DSA-87 (Dilithium-5, FIPS 204). S'exécute
entièrement hors ligne — aucun nœud requis. La partie 1 signe et vérifie un
message (avec un contrôle d'altération) ; la partie 2 construit une transaction
hybride portant à la fois une signature classique secp256k1 et une signature
ML-DSA-87 en tant qu'extension PQCHybridSignature, puis vérifie localement la
moitié PQC.
import {
generatePqcKeypair,
pqcSign,
pqcVerify,
buildHybridTx,
} from "@qorechain/sdk";
const keypair = generatePqcKeypair();
const message = new TextEncoder().encode("QoreChain signs hybrid");
const signature = pqcSign(keypair.secretKey, message);
const valid = pqcVerify(keypair.publicKey, message, signature);
const built = await buildHybridTx({
registry,
signer,
pqcKeypair,
messages,
fee: { amount: [{ denom: "uqor", amount: "40000" }], gas: "400000" }, // network floor: 0.1 uqor per gas
chainId: "qorechain-diana",
accountNumber: 0,
sequence: 0,
signBytesVersion: "v2", // explicit, so this offline example needs no node
includePqcPublicKey: true, // embeds the key in the extension (registration is a separate, explicit step)
});
cosmwasm-query
Exécutez une smart query en lecture seule sur un contrat QoreChain Native déployé. Nécessite un RPC de consensus accessible et l'adresse d'un contrat déployé.
import {
createClient,
queryContractSmart,
getContractInfo,
} from "@qorechain/sdk";
const client = createClient({
network: "testnet",
endpoints: { rpc: process.env.QORE_RPC_URL ?? "http://localhost:26657" },
});
const cw = await client.cosmwasm(); // read-only, memoized on the client
const info = await getContractInfo(cw, contract);
const result = await queryContractSmart(cw, contract, { token_info: {} });
read-tokenomics
Lisez l'état de la tokenomics via l'espace de noms JSON-RPC typé qor_*
(client.qor) sur le point de terminaison JSON-RPC EVM. Les trois lectures sont
indépendantes, chacune est donc rapportée même si les autres sont indisponibles.
Aucune version publiée du nœud ne sert encore l'espace de noms qor_ ; aujourd'hui,
chaque lecture échoue donc avec -32601 (voir
l'espace de noms qor_).
import { createClient } from "@qorechain/sdk";
const client = createClient({
network: "testnet",
endpoints: {
evmRpc: process.env.QORE_EVM_RPC_URL ?? "http://localhost:8545",
},
});
const burn = await client.qor.getBurnStats(); // qor_getBurnStats
const xqore = await client.qor.getXqorePosition(address); // qor_getXQOREPosition (xQORE has no query service yet)
const inflation = await client.qor.getInflationRate(); // qor_getInflationRate
unified-wallet
Dérivez un compte unifié eth-native (SDK 0.6.0) : une seule clé
eth_secp256k1 rendue sous les trois adresses QoreChain avec un solde partagé
unique, plus la paire de clés ML-DSA-87 liée à l'adresse. S'exécute entièrement
hors ligne.
import {
deriveUnifiedAccount,
generatePqcRecoveryCode,
qoreAddresses,
unifiedAccountFromSeed,
} from "@qorechain/sdk";
const account = await deriveUnifiedAccount(mnemonic);
console.log(account.cosmos); // "qor1…" — Native lane
console.log(account.evm); // "0x…" — EVM lane
console.log(account.svm); // base58 — SVM lane (same 20 bytes)
// Decode any one encoding into all three.
const all = qoreAddresses({ evm: account.evm });
// Or derive from a raw 32-byte seed instead of a mnemonic. Since SDK 0.13.0 the
// seed path also needs a QRC1 recovery code (or an independent 32-byte PQC secret).
// Create the code once and keep it apart from the seed: a different code gives a
// different ML-DSA-87 key.
const recoveryCode = generatePqcRecoveryCode();
const fromSeed = unifiedAccountFromSeed(seed32, { recoveryCode });
authenticator-spend
Construisez un MsgExecuteCosmos soumis par un relayer sur la voie
d'authentificateur Native (SDK 0.7.0, chaîne v3.1.85 ; le module
abstractaccount est désactivé sur le mainnet et activé sur le testnet, cette voie
ne peut donc pas encore être utilisée sur le mainnet) : une clé ed25519 de type
Phantom signe le digest d'authentification à séparation de domaine, et le
message résultant est prêt à être diffusé par un relayer (le relayer paie les
frais ; la clé externe ne produit jamais de co-signature ML-DSA). Exécution à
blanc — aucun nœud requis.
import {
buildPhantomExecuteCosmos,
cosmosAuthSignBytes,
qorechainRegistry,
} from "@qorechain/sdk";
// Show the exact 32-byte digest the wallet signs (byte-exact vs the chain).
const digest = cosmosAuthSignBytes({ chainId, account, pubkey, to, amount, nonce });
// Build the relayer-ready message: the Phantom wallet signs the digest.
const msg = await buildPhantomExecuteCosmos({
wallet, // window.solana in a browser
relayer, // submits + pays fees (a DIFFERENT account)
chainId,
account, // the canonical PQC-required owner
to,
amount: "100uqor",
nonce, // the per-authenticator sequence
});
// Prove it encodes via the default registry (what the relayer broadcasts).
const bytes = qorechainRegistry().encode(msg);
Source · Guide complet : Authentificateurs et dépenses déléguées