Beispiele
Die lauffähigen TypeScript-Beispiele befinden sich im Verzeichnis
examples/
des SDK-Monorepos — die unten aufgeführten sowie ai-preflight,
cross-vm-call, react-dapp, register-sidechain, rollup-lifecycle,
amm-swap, connect-keplr, evm-nft und subscribe-blocks. Jeder Ordner ist
ein eigenständiges Workspace-Paket mit eigener README.md, .env.example und
einer einzigen index.ts. Die Beispiele lesen Endpunkte und Mnemonics aus
Umgebungsvariablen mit sinnvollen localhost-Standardwerten, und die
netzwerkabhängigen Beispiele schlagen mit einem Hinweis kontrolliert fehl, wenn
kein Node erreichbar ist. Seit SDK 0.12.0 zeigen die Presets bereits auf die öffentlichen Endpoints; in Ihrem eigenen Code können Sie daher die Fallbacks ?? "http://localhost:..." aus den Snippets unten weglassen und network: "testnet" oder "mainnet" wählen; behalten Sie sie bei (oder wählen Sie localnet), wenn Sie gegen einen Node auf Ihrem Rechner entwickeln.
Vom Repo-Root aus einmal installieren, dann kann jedes Beispiel gestartet werden:
pnpm install
pnpm --filter @qorechain/example-pqc-hybrid-sign start
Verwenden Sie ausschließlich Test-Mnemonics oder generierte Schlüssel. Committen Sie niemals echte Geheimnisse.
Die folgenden Snippets sind aus der index.ts des jeweiligen Beispiels gekürzt.
Das vollständige, lauffähige Programm finden Sie in der verlinkten Quelle.
connect-and-query
Einen Client erstellen und öffentlichen Chain-State lesen — ein natives
Bank-Guthaben und einen Tokenomics-Snapshot. Benötigt einen erreichbaren Node.
Das Beispiel im Repository liest den Snapshot über client.qor, einen
qor_-JSON-RPC-Aufruf, den die öffentlichen Endpunkte nicht bereitstellen; das
Snippet unten verwendet das REST-Äquivalent (die Burn-Statistiken), das auf
Mainnet und Testnet funktioniert.
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
Ein natives Konto (qor1...) aus einer Mnemonic ableiten und einen
QOR-Transfer broadcasten: ableiten → signieren → simulieren → Gebühr schätzen →
bankSend. Benötigt einen erreichbaren Konsens-RPC sowie REST und ein Konto
mit Guthaben. Dieses Beispiel signiert nur mit der klassischen Signatur,
funktioniert daher gegen einen lokalen oder Dev-Node, wird aber von Mainnet und
Testnet abgelehnt, die für jede Transaktion auf dem Native-Pfad die hybride
Signatur verlangen. Für die öffentlichen Netzwerke verbinden Sie sich mit dem
Schlüsselpaar des Kontos, client.connectTx(signer, { pqcKeypair }) (SDK 0.9.0 oder neuer),
wie im 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
Einen SOL-Transfer mit einer Memo-Instruktion auf der Solana-kompatiblen
(SVM-)Laufzeitumgebung von QoreChain erstellen, mit @qorechain/svm. Baut die
Transaktion offline und gibt sie aus. Zum Senden werden ein erreichbarer
SVM-JSON-RPC und ein Konto mit Guthaben benötigt, und es kann auf den
öffentlichen Netzwerken nicht gelingen: Das Einreichen von SVM-Transaktionen ist
netzwerkweit deaktiviert, und die öffentlichen SVM-Endpunkte sind schreibgeschützt
(siehe SVM-Entwicklung).
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
@qorechain/evm (eine dünne Schicht über viem) verwenden, um schreibgeschützte
QoreChain-Precompiles aufzurufen und ein ERC-20-Guthaben zu lesen. Die
EVM-Chain-ID wird automatisch über eth_chainId erkannt. Die Precompiles sind
im Mainnet nicht aktiv, und im Testnet sind es nur die für PQC-Verifizierung,
PQC-Schlüsselstatus und Konsensparameter (siehe
Netzwerkstatus); wo ein
Precompile inaktiv ist, und auf einem Node ohne sie, werfen diese Aufrufe "feature not present",
was pro Aufruf gemeldet wird.
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
Post-Quanten-Signieren mit ML-DSA-87 (Dilithium-5, FIPS 204). Läuft
vollständig offline — kein Node erforderlich. Teil 1 signiert und verifiziert
eine Nachricht (mit einem Manipulationstest); Teil 2 baut eine hybride
Transaktion, die sowohl eine klassische secp256k1-Signatur als auch eine
ML-DSA-87-Signatur als PQCHybridSignature-Extension trägt, und verifiziert
anschließend die PQC-Hälfte lokal.
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
Eine schreibgeschützte Smart Query gegen einen deployten QoreChain Native-Contract ausführen. Benötigt einen erreichbaren Konsens-RPC und eine deployte Contract-Adresse.
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
Tokenomics-State über den typisierten qor_*-JSON-RPC-Namespace
(client.qor) lesen, über den EVM-JSON-RPC-Endpunkt. Die drei Lesevorgänge
sind unabhängig, daher wird jeder gemeldet, auch wenn die anderen nicht
verfügbar sind. Bisher stellt kein veröffentlichter Node-Build den
qor_-Namespace bereit, daher schlägt heute jeder Lesevorgang mit -32601
fehl (siehe den qor_-Namespace).
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
Ein vereinheitlichtes eth-natives Konto ableiten (SDK 0.6.0): ein
eth_secp256k1-Schlüssel, dargestellt als alle drei QoreChain-Adressen mit
einem gemeinsamen Guthaben, plus das adressgebundene ML-DSA-87-Schlüsselpaar.
Läuft vollständig 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
Eine relayer-eingereichte MsgExecuteCosmos auf der nativen
Authenticator-Lane bauen (SDK 0.7.0, Chain v3.1.85; das Modul abstractaccount
ist im Mainnet abgeschaltet und im Testnet aktiviert, diese Lane kann im Mainnet also noch
nicht genutzt werden): ein Phantom-artiger
ed25519-Schlüssel signiert den domänenseparierten Auth-Digest, und die
resultierende Nachricht ist bereit, von einem Relayer gebroadcastet zu werden
(der Relayer zahlt die Gebühren; der externe Schlüssel erzeugt niemals eine
ML-DSA-Co-Signatur). Trockenlauf — kein Node erforderlich.
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);
Quelle · Vollständige Anleitung: Authenticators & delegiertes Spending