Sari la conținutul principal

Pornire rapidă

De la zero până la o tranzacție trimisă. Această pagină folosește SDK-ul TypeScript (@qorechain/sdk); scurte fragmente de conectare și citire pentru Python, Go și Rust urmează la final.

1. Conectare​

createClient() rezolvă o rețea și compune clienții de citire, un helper pentru taxe și un punct de intrare pentru semnare inițializat leneș (lazy). Vizează implicit testnetul public (qorechain-diana), pe endpoint-urile publice (acest lucru s-a schimbat în SDK 0.12.0: versiunile anterioare foloseau implicit localhost și cereau endpoints). Transmiteți endpoints pentru a folosi propriul nod sau selectați localnet pentru un nod de pe mașina dumneavoastră. Endpoint-urile publice sunt listate în referința rețelei.

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

Mainnetul (chain id qorechain-vladi) este live. Selectați-l; presetarea poartă endpoint-urile publice de mainnet. Apelul de mai jos le scrie explicit, ceea ce un SDK anterior lui 0.12.0 are nevoie:

const main = createClient({
network: "mainnet",
endpoints: {
rest: "https://api.qore.host",
rpc: "https://rpc.qore.host",
evmRpc: "https://evm.qore.host",
},
});

2. Derivarea unui cont​

Un singur mnemonic derivă conturi native (qor1…), EVM (0x…) și SVM (base58) prin căi de derivare independente.

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)

Începând cu 0.6.0 puteți deriva în schimb un cont unificat eth-native — o singură cheie eth_secp256k1 redată ca toate cele trei adrese (qor1…, 0x…, SVM base58), cu un singur sold partajat:

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)

Consultați Conturi & semnare PQC pentru derivarea EVM/SVM, conturile unificate și tabelul complet de derivare.

3. Citirea unui sold​

// 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 (apelurile JSON-RPC qor_ tipizate) nu poate fi folosit pe endpoint-urile publice: niciun build de nod publicat nu servește acel namespace, așa că fiecare apel returnează -32601 (method not found). Citiți în schimb prin REST. Consultați namespace-ul qor_.

4. Trimiterea unui transfer QOR​

Pe mainnet și pe testnet, fiecare tranzacție pe calea Native trebuie să poarte semnătura hibridă (secp256k1 clasic plus ML-DSA-87), iar cheia ML-DSA-87 a contului trebuie să fie înregistrată mai întâi on-chain. Înregistrarea este explicită: nu există înregistrare automată la prima tranzacție. O tranzacție semnată doar clasic este refuzată de rețelele live, așa că dați clientului de tranzacții perechea de chei ML-DSA-87 a contului și acesta semnează hibrid fiecare tranzacție. Cei doi pași de mai jos necesită SDK 0.9.0 sau mai nou (0.14.0 este cea curentă) și un cont alimentat cu fonduri:

npm i @qorechain/sdk

4a. Înregistrați cheia post-cuantică (o singură dată)​

Contul plătește taxa: cheia de 2.592 de octeți necesită o limită de gas de aproximativ 600.000. ensurePqcRegistered citește mai întâi starea cheii prin REST (rest), deci sare peste tranzacție când cheia este deja înregistrată și aruncă PqcKeyMismatchError, fără să trimită nimic, când contul deține o cheie diferită (o a doua înregistrare este refuzată după ce taxa este percepută). Înregistrarea este singura tranzacție semnată clasic pe care lanțul o acceptă de la un cont fără cheie, așa că clientul hibrid o trimite singur în mod clasic. După ce rețeaua a aplicat v3.2.3 (ambele rețele au făcut-o), helperul atașează și dovada opțională de posesie. Lanțul refuză cheile slabe, degenerate sau refolosite; o cheie de la derivePqcCanonical este în regulă.

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. Trimiterea cu semnătură hibridă​

tx.bankSend semnează acum hibrid. Taxa este implicit "auto": clientul simulează chiar tranzacția hibridă. Pe o rețea care a aplicat v3.2.5 (ambele au aplicat-o), SDK 0.12.0 stabilește limita de gaz la ceil(simulated x 1.02) + 2000, deoarece simularea taxează deja verificarea post-cuantică: un transfer bancar hibrid cere aproximativ 171.600 de gaz. Pe rețelele mai vechi și cu SDK 0.10.0 sau mai vechi, clientul adaugă singur gazul verificării post-cuantice (aproximativ 289.000 pentru același transfer). Prețul minim al gazului în rețea este de 0,1 uqor per unitate de gaz (clientul calculează la 0,15). Folosiți toBase("1.5") pentru a converti QOR în uqor de bază.

import { toBase } from "@qorechain/sdk";

const result = await tx.bankSend("qor1recipientaddress...", [
{ denom: "uqor", amount: toBase("1.5") },
]);
console.log(result.transactionHash);

toBase("1.5") returnează "1500000" (QOR are 10^6 unități de bază uqor). Pentru a trimite în același mod orice alt mesaj, pasați-l către tx.signAndBroadcast([message], "auto"). Pentru control explicit asupra taxei, numărului de cont și secvenței, folosiți signAndBroadcastHybrid (consultați Conturi & semnare PQC).

Conturi unificate

Pentru un cont unificat eth-native (deriveUnifiedAccount), folosiți în schimb EthNativeSigner; exemplele de înregistrare și trimitere se găsesc în Conturi & semnare PQC.

Fără o pereche de chei, clientul semnează clasic

client.connectTx(signer) fără pqcKeypair semnează doar clasic. Rețelele publice acceptă asta doar pentru înregistrarea cheii (un cont fără cheie încă); pe un nod care nu cere extensia hibridă (un nod local de dezvoltare), trimite și transferuri obișnuite. Versiunile SDK anterioare lui 0.9.0 nu au un TxClient hibrid: trimiteți prin signAndBroadcastHybrid (consultați Versiuni anterioare lui 0.9.0).

Alte limbaje: conectare & citire​

Acestea reflectă aceleași preseturi de rețea și aceeași suprafață de citire. Folosesc endpoint-urile publice de testnet; pentru mainnet transmiteți "mainnet" și URL-urile de mainnet.

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

Pașii următori​