Aller au contenu principal

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

Source

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);

Source

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])

Source

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);

Source

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)
});

Source

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: {} });

Source

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

Source

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 });

Source

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