Exemple
Exemplele TypeScript rulabile se află în directorul
examples/
al monorepo-ului SDK — cele de mai jos, plus ai-preflight,
cross-vm-call, react-dapp, register-sidechain, rollup-lifecycle,
amm-swap, connect-keplr, evm-nft și subscribe-blocks. Fiecare folder este
un pachet workspace de sine stătător,
cu propriul README.md, .env.example și un singur index.ts. Ele citesc
endpoint-urile și mnemonicele din variabile de mediu, cu valori implicite rezonabile pe localhost,
iar cele care depind de rețea eșuează elegant, cu un indiciu, atunci când niciun nod nu este
accesibil. Începând cu SDK 0.12.0, presetările indică deja endpoint-urile publice, așa că în codul dvs. puteți elimina valorile de rezervă ?? "http://localhost:..." care apar în fragmentele de mai jos și puteți selecta network: "testnet" sau "mainnet"; păstrați-le (sau selectați localnet) când dezvoltați împotriva unui nod de pe mașina dvs.
Din rădăcina repo-ului, instalați o singură dată, apoi rulați orice exemplu:
pnpm install
pnpm --filter @qorechain/example-pqc-hybrid-sign start
Folosiți doar mnemonice de test sau chei generate. Nu comiteți niciodată secrete reale.
Fragmentele de mai jos sunt versiuni condensate ale fișierului index.ts din fiecare exemplu. Consultați
sursa din link pentru programul complet, rulabil.
connect-and-query
Creați un client și citiți starea publică a lanțului — un sold bancar nativ și
un instantaneu de tokenomics. Necesită un nod accesibil. Exemplul din repository citește
instantaneul prin client.qor, un apel JSON-RPC qor_ pe care endpoint-urile publice nu
îl servesc; fragmentul de mai jos folosește echivalentul REST (statisticile de ardere), care
funcționează pe mainnet și pe 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
Derivați un cont nativ (qor1...) dintr-un mnemonic și difuzați un transfer
QOR: derivare → semnare → simulare → estimare comision → bankSend. Necesită un
RPC de consens accesibil, plus REST și un cont finanțat. Acest exemplu semnează doar cu
semnătura clasică, deci funcționează pe un nod local sau de dezvoltare, dar este
refuzat de mainnet și de testnet, care cer semnătura hibridă pentru fiecare
tranzacție pe calea Native. Pentru rețelele publice conectați-vă cu perechea de chei
a contului, client.connectTx(signer, { pqcKeypair }) (SDK 0.9.0 sau mai nou), ca în
Quickstart.
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
Construiți un transfer SOL cu o instrucțiune memo pe runtime-ul QoreChain
compatibil Solana (SVM), folosind @qorechain/svm. Construiește și afișează tranzacția
offline. Trimiterea necesită un JSON-RPC SVM accesibil și un cont finanțat și nu poate
reuși pe rețelele publice: trimiterea tranzacțiilor SVM este dezactivată
la nivelul întregii rețele, iar endpoint-urile SVM publice sunt doar pentru citire (consultați
Dezvoltare 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
Folosiți @qorechain/evm (un strat subțire peste viem) pentru a apela precompile-urile
QoreChain în mod read-only și pentru a citi un sold ERC-20. ID-ul de lanț EVM este detectat automat prin
eth_chainId. Precompile-urile nu sunt active pe mainnet, iar pe testnet sunt active doar
cele de verificare PQC, de stare a cheii PQC și de parametri de consens (consultați
Starea rețelei); acolo unde un
precompile este inactiv, și pe un nod fără ele, acele apeluri aruncă eroarea "feature not present",
raportată per apel.
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
Semnare post-cuantică cu ML-DSA-87 (Dilithium-5, FIPS 204). Rulează complet
offline — nu necesită niciun nod. Partea 1 semnează și verifică un mesaj (cu o verificare
anti-falsificare); partea 2 construiește o tranzacție hibridă care poartă atât o semnătură clasică
secp256k1, cât și o semnătură ML-DSA-87, ca extensie PQCHybridSignature, apoi
verifică local jumătatea 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
Rulați o interogare smart read-only pe un contract QoreChain Native implementat. Necesită un RPC de consens accesibil și o adresă de contract implementat.
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
Citiți starea tokenomics prin namespace-ul JSON-RPC tipizat qor_*
(client.qor), servit prin endpoint-ul EVM JSON-RPC. Cele trei citiri sunt
independente, astfel încât fiecare este raportată chiar dacă celelalte nu sunt disponibile.
Nicio versiune de nod lansată nu servește încă namespace-ul qor_, așa că astăzi fiecare
citire eșuează cu -32601 (consultați
namespace-ul 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
Derivați un cont unificat eth-nativ (SDK 0.6.0): o singură cheie eth_secp256k1
redată ca toate cele trei adrese QoreChain, cu un singur sold partajat, plus
perechea de chei ML-DSA-87 legată de adresă. Rulează complet offline.
import {
deriveUnifiedAccount,
qoreAddresses,
generatePqcRecoveryCode,
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
Construiți un MsgExecuteCosmos trimis prin relayer pe culoarul de autentificatori Native
(SDK 0.7.0, chain v3.1.85; modulul abstractaccount este dezactivat pe mainnet și
activat pe testnet, deci acest culoar nu poate fi folosit încă pe mainnet): o cheie ed25519 în stil Phantom semnează
digestul de autentificare cu separare de domeniu, iar mesajul rezultat este gata pentru ca un relayer
să îl difuzeze (relayer-ul plătește comisioanele; cheia externă nu produce niciodată o
co-semnătură ML-DSA). Rulare de probă — nu necesită niciun nod.
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);
Sursa · Ghid complet: Autentificatori și cheltuieli delegate