Schnellstart
Von null bis zur gesendeten Transaktion. Diese Seite verwendet das TypeScript-SDK
(@qorechain/sdk); kurze Verbinden-und-Lesen-Snippets für Python, Go und Rust
folgen am Ende.
1. Verbinden
createClient() löst ein Netzwerk auf und stellt die Lese-Clients, einen
Gebühren-Helfer und einen verzögert initialisierten Signier-Einstiegspunkt
zusammen. Standardmäßig richtet es sich an das öffentliche Testnet
(qorechain-diana), auf den öffentlichen Endpunkten (das hat sich in SDK
0.12.0 geändert: frühere Releases verwendeten standardmäßig localhost und brauchten endpoints). Übergeben Sie
endpoints, um Ihren eigenen Node zu verwenden, oder wählen Sie localnet für einen Node auf Ihrem Rechner.
Die öffentlichen Endpunkte sind in der Netzwerk-Referenz
aufgeführt.
import { createClient } from "@qorechain/sdk";
// Testnet (chain id "qorechain-diana"), public testnet endpoints (SDK 0.12.0+).
const client = createClient();
// A node on this machine (chain id "qorechain-devnet", localhost ports).
const local = createClient({ network: "localnet" });
// Your own node: override any endpoint, the rest keep the preset's values.
const remote = createClient({
endpoints: {
rest: "https://lcd.my-node.example", // Native REST (LCD)
rpc: "https://rpc.my-node.example", // consensus RPC (for signing)
},
});
Das Mainnet (Chain-ID qorechain-vladi) ist live. Wählen Sie es aus; das Preset
bringt die öffentlichen Mainnet-Endpunkte mit. Der Aufruf unten schreibt sie aus, was ein SDK vor
0.12.0 braucht:
const main = createClient({
network: "mainnet",
endpoints: {
rest: "https://api.qore.host",
rpc: "https://rpc.qore.host",
evmRpc: "https://evm.qore.host",
},
});
2. Ein Konto ableiten
Eine einzige Mnemonic leitet über unabhängige Ableitungspfade native
(qor1…)-, EVM- (0x…) und SVM- (base58) Konten ab.
import {
generateMnemonic,
deriveNativeAccount,
} from "@qorechain/sdk";
const mnemonic = generateMnemonic(); // 12 words (pass 256 for 24 words)
const native = await deriveNativeAccount(mnemonic);
console.log(native.address); // "qor1..." (Native secp256k1, coin type 118)
Seit 0.6.0 können Sie stattdessen ein unified eth-native Konto ableiten —
ein einziger eth_secp256k1-Schlüssel, der als alle drei Adressen (qor1…,
0x…, SVM base58) mit einem gemeinsamen Guthaben dargestellt wird:
import { deriveUnifiedAccount } from "@qorechain/sdk";
const unified = await deriveUnifiedAccount(mnemonic);
console.log(unified.cosmos); // "qor1..."
console.log(unified.evm); // "0x..."
console.log(unified.svm); // base58 (same 20 bytes + 12 zero bytes)
Siehe Konten & PQC-Signierung für die EVM/SVM-Ableitung, Unified Accounts und die vollständige Ableitungstabelle.
3. Ein Guthaben lesen
// Native bank balances over REST.
const balances = await client.rest.getAllBalances(native.address);
// Any REST route works through the typed escape hatch, for example the burn
// statistics.
const burn = await client.rest.getBurnStats();
client.qor (die typisierten qor_-JSON-RPC-Aufrufe) ist auf den öffentlichen
Endpunkten nicht nutzbar: Kein veröffentlichter Node-Build stellt diesen Namespace
bereit, daher liefert jeder Aufruf -32601 (Methode nicht gefunden). Lesen Sie
stattdessen über REST. Siehe
den qor_-Namespace.
4. Eine QOR-Überweisung senden
Auf Mainnet und Testnet muss jede Transaktion auf dem Native-Pfad die hybride Signatur (klassisches secp256k1 plus ML-DSA-87) tragen, und der ML-DSA-87-Schlüssel des Kontos muss zuerst on-chain registriert sein. Die Registrierung erfolgt explizit: Es gibt keine automatische Registrierung bei der ersten Transaktion. Eine Transaktion, die nur klassisch signiert ist, wird von den Live-Netzwerken abgelehnt; geben Sie dem Transaktions-Client daher das ML-DSA-87-Schlüsselpaar des Kontos, und er signiert jede Transaktion hybrid. Die beiden folgenden Schritte erfordern SDK 0.9.0 oder neuer (0.14.0 ist aktuell) und ein finanziertes Konto:
npm i @qorechain/sdk
4a. Ihren Post-Quanten-Schlüssel registrieren (einmalig)
Das Konto zahlt die Gebühr: Der 2.592 Byte große Schlüssel benötigt ein Gas-Limit von
etwa 600.000. ensurePqcRegistered liest zuerst den Schlüsselstatus über REST (rest),
überspringt also die Transaktion, wenn der Schlüssel bereits registriert ist, und wirft
PqcKeyMismatchError, ohne etwas zu senden, wenn das Konto einen anderen Schlüssel
besitzt (eine zweite Registrierung wird abgelehnt, nachdem die Gebühr abgebucht
wurde). Die Registrierung ist die eine klassisch signierte Transaktion, die die Chain
von einem Konto ohne Schlüssel akzeptiert, daher sendet der Hybrid-Client sie von selbst
klassisch. Sobald das Netzwerk v3.2.3 angewendet hat (beide Netzwerke haben es), hängt der
Helfer außerdem den optionalen Besitznachweis an. Die Chain lehnt schwache, entartete oder
wiederverwendete Schlüssel ab; ein Schlüssel aus derivePqcCanonical ist in Ordnung.
import {
createClient,
deriveNativeAccount,
directSignerFromPrivateKey,
derivePqcCanonical,
ensurePqcRegistered,
} from "@qorechain/sdk";
const REST = "https://api-testnet.qore.host";
const RPC = "https://rpc-testnet.qore.host";
const client = createClient({ endpoints: { rest: REST, rpc: RPC } });
const account = await deriveNativeAccount(mnemonic);
const signer = await directSignerFromPrivateKey(account.privateKey, "qor");
// The address-bound ML-DSA-87 key, recoverable from { address, mnemonic }.
const pqcKeypair = derivePqcCanonical(account.address, mnemonic);
// With the keypair, every transaction this client sends is signed hybrid.
const tx = await client.connectTx(signer, { pqcKeypair });
const res = await ensurePqcRegistered(tx, {
pqcKeypair,
rest: client.network.endpoints.rest, // reads the status first; never registers blind
fee: { amount: [{ denom: "uqor", amount: "60000" }], gas: "600000" },
});
console.log(res.alreadyRegistered ? "already registered" : res.txHash);
4b. Mit hybrider Signatur senden
tx.bankSend signiert nun hybrid. Die Gebühr ist standardmäßig "auto": Der Client
simuliert die hybride Transaktion selbst. Auf einem Netzwerk, das v3.2.5 angewendet hat (beide haben es), setzt SDK
0.12.0 das Gas-Limit auf ceil(simulated x 1.02) + 2000, weil die Simulation
die Post-Quanten-Verifikation bereits berechnet: Eine hybride Bank-Überweisung fordert etwa
171.600 Gas. Auf älteren Netzwerken und mit SDK 0.10.0 oder früher addiert der Client das
Gas der Post-Quanten-Verifikation selbst (etwa 289.000 für dieselbe Überweisung). Der minimale Gaspreis des Netzwerks beträgt 0,1 uqor pro
Gas-Einheit (der Client rechnet mit 0,15). Verwenden Sie toBase("1.5"), um QOR in die
Basiseinheit uqor umzurechnen.
import { toBase } from "@qorechain/sdk";
const result = await tx.bankSend("qor1recipientaddress...", [
{ denom: "uqor", amount: toBase("1.5") },
]);
console.log(result.transactionHash);
toBase("1.5") liefert "1500000" (QOR hat 10^6 Basiseinheiten in uqor). Um eine
beliebige andere Nachricht auf dieselbe Weise zu senden, übergeben Sie sie an
tx.signAndBroadcast([message], "auto"). Für explizite Kontrolle über Gebühr,
Kontonummer und Sequenz verwenden Sie signAndBroadcastHybrid (siehe
Konten & PQC-Signierung).
Verwenden Sie für ein unified eth-native Konto (deriveUnifiedAccount)
stattdessen EthNativeSigner; die Beispiele für Registrierung und Senden finden
Sie unter Konten & PQC-Signierung.
client.connectTx(signer) ohne pqcKeypair signiert nur klassisch. Die öffentlichen
Netzwerke akzeptieren das allein für die Schlüsselregistrierung (ein Konto ohne
Schlüssel); gegenüber einem Node, der die Hybrid-Erweiterung nicht verlangt (ein lokaler
Dev-Node), sendet er auch gewöhnliche Überweisungen. SDK-Versionen vor 0.9.0 haben
keinen hybriden TxClient: Senden Sie über signAndBroadcastHybrid (siehe
Versionen vor 0.9.0).
Weitere Sprachen: Verbinden & Lesen
Diese spiegeln dieselben Netzwerk-Presets und dieselbe Lese-Oberfläche wider. Sie
verwenden die öffentlichen Testnet-Endpunkte; übergeben Sie für das Mainnet
"mainnet" und die Mainnet-URLs.
Python
from qorsdk import create_client
client = create_client(
network="testnet",
endpoints={
"rest": "https://api-testnet.qore.host",
"rpc": "https://rpc-testnet.qore.host",
"evm_rpc": "https://evm-testnet.qore.host",
},
)
print(client.network.chain_id) # "qorechain-diana"
balances = client.rest.get_all_balances("qor1...")
burn = client.rest.get_burn_stats()
client.close()
Go
import (
"fmt"
"github.com/qorechain/qorechain-sdk/packages/go/qorechain/client"
)
c, err := client.CreateClient(client.Options{
Network: "testnet",
Endpoints: client.EndpointOverrides{
REST: "https://api-testnet.qore.host",
RPC: "https://rpc-testnet.qore.host",
EVMRPC: "https://evm-testnet.qore.host",
},
})
if err != nil {
panic(err)
}
fmt.Println(c.Network.ChainID) // qorechain-diana
balances, err := c.REST.GetAllBalances("qor1...")
burn, err := c.REST.GetBurnStats()
Rust
use qorechain::ClientBuilder;
#[tokio::main]
async fn main() -> qorechain::Result<()> {
let client = ClientBuilder::new()
.network("testnet")
.rest("https://api-testnet.qore.host")
.rpc("https://rpc-testnet.qore.host")
.evm_rpc("https://evm-testnet.qore.host")
.build()?;
let balances = client.rest.get_all_balances("qor1...").await?;
let burn = client.rest.get_burn_stats().await?;
let _ = (balances, burn);
Ok(())
}
Nächste Schritte
- Guides — arbeiten Sie mit jeder VM (EVM, SVM, QoreChain Native, Cross-VM).
- Konten & PQC-Signierung — HD-Ableitung, unified eth-native Konten und Post-Quanten-Signierung.
- Authenticators & delegiertes Ausgeben — lassen Sie einen verknüpften Phantom-/MetaMask-Schlüssel über einen Relayer ausgeben.
- Netzwerk- & Endpunkt-Referenz.
- Beispiele — ausführbare Snippets für jeden der obigen Abläufe.