Zum Hauptinhalt springen

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

Quelle

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

Quelle

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

Quelle

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

Quelle

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

Quelle

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

Quelle

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

Quelle

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

Quelle

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