Zum Hauptinhalt springen

Erste Transaktion

Diese Anleitung führt durch das Senden von QOR-Token, das Abfragen von Transaktionen und die Interaktion mit QoreChain über seine nativen, EVM- und SVM-Schnittstellen.

hinweis

Die folgenden Befehle verwenden das qorechain-diana-Testnet (EVM-Chain-ID 9800). Das Mainnet (qorechain-vladi, EVM-Chain-ID 9801) ist seit dem 7. Juni 2026 aktiv und läuft seit dem 12. November 2026 auf Release v3.2.7 (das Testnet läuft seit dem 12. November 2026 auf v3.2.8) — ersetzen Sie beim Durchführen von Transaktionen auf dem Mainnet die Chain-ID und die Endpunkte durch die des Mainnets von der Seite Verbindung zum Mainnet.

Ihr Guthaben prüfen​

Überprüfen Sie vor dem Senden von Token Ihr Kontoguthaben:

qorechaind query bank balances qor1youraddress... --output json

Die Antwort enthält alle vom Konto gehaltenen Token-Denominationen. QOR-Guthaben werden in uqor (Mikro-QOR) angezeigt, wobei 1 QOR = 1.000.000 uqor entspricht.

QOR senden​

Ein QoreChain-Konto sendet auf dem Cosmos-Pfad mit einer hybriden Signatur: der klassischen secp256k1-Signatur plus einer ML-DSA-87-Signatur (Dilithium-5). Ein einfaches qorechaind tx bank send ... -y wird abgelehnt, daher wird die Überweisung unsigniert erstellt und anschließend co-signiert. Sie benötigen einmalig einen auf Ihrem Konto registrierten Post-Quanten-Schlüssel (siehe Registrieren Sie Ihren Post-Quanten-Schlüssel weiter unten) sowie die offizielle qorechaind-Release-Binärdatei von download.qore.host (eine aus dem öffentlichen Quellbaum gebaute Binärdatei kann keine Dilithium-Signatur erzeugen oder anwenden).

# 1. Build the unsigned transaction (the fee is fixed here, because cosign signs the fee in this file)
qorechaind tx bank send mykey qor1recipient... 1000000uqor \
--chain-id qorechain-diana \
--gas 400000 --fees 60000uqor \
--generate-only > tx.json

# 2. Add the ML-DSA-87 signature and broadcast
qorechaind tx pqc cosign tx.json --from mykey --pqc-key mypqc --chain-id qorechain-diana

Dies sendet 1 QOR (1.000.000 uqor) an die Empfängeradresse und zahlt dabei eine Gebühr von 60.000 uqor (0,06 QOR). Die Netzwerk-Untergrenze beträgt 0,1 uqor pro Gas-Einheit, die Gebühr muss also mindestens dem Gas-Limit multipliziert mit 0,1 entsprechen: --gas 400000 erfordert --fees 40000uqor oder mehr. Die Beispiele zahlen 0,15 uqor pro Gas-Einheit (--fees 60000uqor): Ab v3.2.8 ordnet der Mempool Transaktionen nach Gebühr pro Gas, sodass eine Überweisung, die genau die Untergrenze zahlt, bei hoher Auslastung der Blöcke hinter anderen warten muss. Eine hybrid signierte Überweisung verbraucht typischerweise 160.000 bis 240.000 Gas, weil die Signatur der Transaktion etwa 4,7 KB hinzufügt. cosign fragt den Node, welche Form der signierten Bytes das Netzwerk prüft, sodass derselbe Befehl auf beiden Netzwerken funktioniert.

Registrieren Sie Ihren Post-Quanten-Schlüssel​

Ein Post-Quanten-Schlüssel wird explizit registriert, einmal pro Konto. Die Chain registriert ihn bei Ihrer ersten Transaktion nicht für Sie. Die Registrierungstransaktion selbst (und die Schlüsselmigration) darf allein mit dem klassischen Schlüssel signiert werden, damit ein brandneues Konto starten kann:

# generate the ML-DSA-87 key (stored under ~/.qorechaind/pqc/mypqc.dilithium, mode 0600, not encrypted)
qorechaind tx pqc gen-key mypqc

# register the printed public key for your account
qorechaind tx pqc register-key <public_key_hex> hybrid --from mykey \
--chain-id qorechain-diana --gas 600000 --fees 90000uqor

Seit v3.2.3 akzeptiert die Chain bei der Registrierung außerdem einen optionalen Besitznachweis und lehnt schwache, degenerierte oder bereits verwendete Schlüssel ab. Um einen anzuhängen, registrieren Sie mit register-key-v2 und benennen Ihren lokalen Schlüssel:

qorechaind tx pqc register-key-v2 dilithium5 <public_key_hex> hybrid --from mykey --pqc-key mypqc \
--chain-id qorechain-diana --gas 600000 --fees 90000uqor

Sichern Sie die PQC-Schlüsseldatei so sorgfältig wie Ihre Wiederherstellungsphrase; sie lässt sich mit qorechaind tx pqc recover-key aus der Phrase neu ableiten. QoreX und das QoreChain-SDK übernehmen die Schlüsselregistrierung für Sie. Den vollständigen hybriden Ablauf finden Sie unter Wallet-Einrichtung.

Cosmos-Transfers erfordern eine hybride PQC-Signatur

Auf dem Cosmos-Pfad lautet die Netzwerkeinstellung hybrid_signature_mode = required (die Live-Netzwerke laufen auf der v3.2-Linie). Eine rein klassische Transaktion wird abgelehnt. Um die hybride Signatur außerhalb der CLI zu erzeugen, leisten die quelloffene Bibliothek qorechain-pqc (hybridSignBytes) und das QoreChain-SDK im Code das Gleiche.

Nachdem die co-signierte Transaktion akzeptiert wurde, gibt die CLI einen Transaktions-Hash zurück.

Die erste Transaktion eines neuen Kontos​

Ab dem Release v3.2.8 (Testnet seit dem 12. November 2026; das Mainnet hat es nicht angewendet) muss die erste Transaktion eines frischen Kontos die Registrierung seines Post-Quanten-Schlüssels sein: MsgRegisterPQCKeyV2 mit dem Besitznachweis, signiert allein mit dem klassischen Schlüssel. Jede andere erste Transaktion eines Kontos ohne registrierten Schlüssel wird abgelehnt. Das gilt für ein neues Konto, das finanziert wurde, aber noch nie etwas gesendet hat; ein Konto, das bereits einen registrierten Schlüssel hat, ist nicht betroffen.

Warum das wichtig ist. Jede spätere Transaktion auf der Cosmos-Lane wird hybrid signiert (secp256k1 plus ML-DSA-87), und die Chain kann den ML-DSA-87-Teil nur gegen einen Schlüssel prüfen, den sie bereits kennt. Die Registrierung ist die eine Transaktion, die diese Signatur noch nicht tragen kann; deshalb ist sie die eine Transaktion, die die Chain allein mit einer klassischen Signatur akzeptiert, und sie muss zuerst kommen. Senden Sie vor der Registrierung eine Überweisung, eine Delegation oder einen Contract-Aufruf, wird die Transaktion abgelehnt, und Sie registrieren zuerst.

Den Schlüssel registrieren​

Verwenden Sie mit der CLI register-key-v2 genau wie oben unter Registrieren Sie Ihren Post-Quanten-Schlüssel (der Schlüssel muss zuvor mit qorechaind tx pqc gen-key mypqc erzeugt werden):

qorechaind tx pqc register-key-v2 dilithium5 <public_key_hex> hybrid --from mykey --pqc-key mypqc \
--chain-id qorechain-diana --gas 600000 --fees 90000uqor

Mit dem TypeScript-SDK (0.9.0 oder neuer) liest ensurePqcRegistered zuerst den Schlüsselstatus, überspringt die Transaktion, wenn Ihr Schlüssel bereits registriert ist, hängt den Besitznachweis an und sendet die Registrierung von selbst klassisch:

import {
createClient,
deriveNativeAccount,
directSignerFromPrivateKey,
derivePqcCanonical,
ensurePqcRegistered,
} from "@qorechain/sdk";

const client = createClient({
endpoints: { rest: "https://api-testnet.qore.host", rpc: "https://rpc-testnet.qore.host" },
});
const account = await deriveNativeAccount(mnemonic);
const signer = await directSignerFromPrivateKey(account.privateKey, "qor");
const pqcKeypair = derivePqcCanonical(account.address, mnemonic);
const tx = await client.connectTx(signer, { pqcKeypair });

const res = await ensurePqcRegistered(tx, {
pqcKeypair,
rest: client.network.endpoints.rest,
fee: { amount: [{ denom: "uqor", amount: "90000" }], gas: "600000" },
});
console.log(res.alreadyRegistered ? "already registered" : res.txHash);

Wenn Sie nur die Nachricht brauchen (zum Beispiel, um sie in Ihren eigenen Transaktionskörper zu packen), liefert buildRegisterPqcKeyMsg(sender, { pqcKeypair, ecdsaPubkey, proofOfPossession }) die MsgRegisterPQCKeyV2, ohne sie zu senden.

Die anderen SDKs haben denselben idempotenten Helfer; alle lesen zuerst den Schlüsselstatus über REST und registrieren nie blind:

SpracheHelfer
Pythonqorsdk.pqc_dx.ensure_pqc_registered(account=..., pqc_keypair=..., chain_id=..., account_number=..., sequence=..., rest_url=..., fee=...)
Gopqcdx.New(pqcdx.Signer{...}, pqcdx.Options{}).EnsurePQCRegistered(pqcdx.RegisterOptions{})
RustPqcDx::ensure_pqc_registered().await
JavaPqcDx.ensurePqcRegistered(signer, broadcaster, qor, new PqcDx.EnsureOptions())

Die vollständige Signer-Einrichtung in jeder Sprache steht in der SDK-Referenz der jeweiligen Sprache. Die Registrierung setzt voraus, dass das Konto genug QOR hält, um die Gebühr zu zahlen; finanzieren Sie das neue Konto also vor der Registrierung.

Die Gebühr mit eingerechneter Signatur schätzen​

Eine hybride Signatur fügt der Transaktion etwa 4,7 KB hinzu, und die Chain berechnet dafür eine Verifikationsgebühr; eine aus einer unsignierten oder klassisch signierten Kopie der Transaktion geschätzte Gebühr ist daher zu niedrig. Simulieren Sie die Transaktion mit eingerechneter hybrider Signatur oder überlassen Sie das dem SDK: Die Standardgebühr des TypeScript-Clients ist "auto", was die hybride Transaktion simuliert und das Gaslimit aus dem Ergebnis setzt.

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

// "auto" is the default: the client simulates the hybrid transaction itself.
await tx.bankSend("qor1recipientaddress...", [{ denom: "uqor", amount: toBase("1.5") }]);
TransaktionTypisches GasBeispielgebühr bei 0,15 uqor pro Gas
Hybrid signierte Überweisungetwa 160,000 bis 240,00024,000 bis 36,000 uqor
Schlüsselregistrierungetwa 600,000 (zu setzendes Limit)90,000 uqor

Im Testnet getestet. Am 12. November 2026 (Release v3.2.8) sendete ein frisches eth-natives Konto mit 500 QOR zuerst die Registrierung (SDK 0.13.0, klassisch signiert, mit dem Besitznachweis): Code 0, 299,233 Gas verbraucht bei einem Limit von 600,000 und einer Gebühr von 90,000 uqor. Seine erste hybrid signierte Überweisung verbrauchte dann 187,494 Gas bei einem Limit von 400,000 (Gebühr 60,000 uqor). Das Zurücklesen der Transaktion über GET /cosmos/tx/v1beta1/txs/{hash} zeigte Code 0, die Erweiterung /qorechain.pqc.v1.PQCHybridSignature mit einer 4,627 Byte großen ML-DSA-87-Signatur sowie die Ereignisse pqc_verify (hybrid_mode=required) und pqc_hybrid_verify (status=verified). Die Regel, dass die Registrierung die erste Transaktion sein muss, stammt vom Chain-Team; eine erste Transaktion anderer Art wurde nicht ausprobiert.

Die Netzwerk-Untergrenze beträgt 0,1 uqor pro Gas-Einheit; ab v3.2.8 ordnet der Mempool Transaktionen nach Gebühr pro Gas, sodass eine Zahlung knapp über der Untergrenze verhindert, dass eine Transaktion bei hoher Blockauslastung hinter anderen wartet.

Was Sie sehen, wenn Sie die Registrierung überspringen​

Was Sie sehenBedeutungWas zu tun ist
Eine Ablehnung mit dem Hinweis, dass das Konto keinen registrierten PQC-Schlüssel hat oder eine hybride Signatur enthalten muss (Modul pqc, Code 8; das SDK meldet pqc_key_required)Das Konto hat noch keinen registrierten SchlüsselDen Schlüssel wie oben registrieren, dann erneut senden
Registrierung abgelehnt als already registered (Modul pqc, Code 7)Das Konto hält bereits einen SchlüsselNichts zu tun; die Registrierung mit GET /qorechain/pqc/v1/account/{address} lesen oder ensurePqcRegistered verwenden (es wirft PqcKeyMismatchError bei einem anderen Schlüssel)

Siehe auch SDK-Schnellstart, Post-Quanten-Signierung und Wallet-Einrichtung.

Transaktion abfragen​

Schlagen Sie eine abgeschlossene Transaktion anhand ihres Hashs nach:

qorechaind query tx <txhash>

Die Ausgabe enthält den Transaktionsstatus, das verbrauchte Gas, die Blockhöhe und alle während der Ausführung ausgegebenen Ereignisse.

Für JSON-Ausgabe:

qorechaind query tx <txhash> --output json

Verwendung von JSON-RPC (EVM)​

Die EVM-Ausführungsumgebung von QoreChain stellt an Port 8545 eine standardmäßige Ethereum-JSON-RPC-Schnittstelle bereit.

EVM-Transaktionen benötigen ein Autorisierungsfenster

Standardmäßiges Ethereum-Signieren (MetaMask, ethers.js, ...) funktioniert weiterhin unverändert, doch seit v3.2.0 lässt der EVM-Pfad eine Transaktion nur von einem Konto zu, das einen registrierten Post-Quanten-Schlüssel und ein offenes EVM-Autorisierungsfenster hat. Öffnen Sie zuerst eines (das ist eine Transaktion auf dem Cosmos-Pfad, signiert mit Ihrem ML-DSA-Schlüssel) — siehe EVM-Autorisierungsfenster weiter unten. Ohne Fenster antwortet der Node mit no open EVM authorisation window. Das Lesen von Zustand (eth_blockNumber, eth_getBalance, eth_call, eth_estimateGas) braucht kein Fenster.

Die neueste Blocknummer abrufen​

curl -s -X POST http://localhost:8545 \
-H "Content-Type: application/json" \
-d '{
"jsonrpc": "2.0",
"method": "eth_blockNumber",
"params": [],
"id": 1
}' | jq '.result'

Ein Kontoguthaben abrufen​

curl -s -X POST http://localhost:8545 \
-H "Content-Type: application/json" \
-d '{
"jsonrpc": "2.0",
"method": "eth_getBalance",
"params": ["0xYourEVMAddress", "latest"],
"id": 1
}' | jq '.result'

Das Guthaben wird als hex-kodierter Wert in der kleinsten Denomination zurückgegeben.

EVM-Autorisierungsfenster​

Seit dem Chain-Release v3.2.0 (Mainnet-Höhe 2.981.742, 25. September 2026; Testnet-Höhe 5.920.000) lässt der EVM-Pfad eine Transaktion nur von einem Konto zu, das

  1. einen registrierten Post-Quanten-Schlüssel (ML-DSA-87) hat und
  2. ein offenes EVM-Autorisierungsfenster hat, das noch Platz für die Transaktion bietet.

Alles andere am EVM-Pfad bleibt unverändert: Sie signieren weiterhin mit MetaMask, ethers.js, Hardhat oder Foundry, und eth_estimateGas sowie andere Simulationen funktionieren ohne Fenster. Contract-Deployments zählen wie jede andere EVM-Transaktion, daher wird vor einem Deployment ein Fenster benötigt.

Warum ein Fenster? Ein Standard-Wallet erzeugt eine einzelne secp256k1-Signatur über eine Ethereum-Transaktion und bietet Anwendungen keine Möglichkeit, eine zweite, Post-Quanten-Signatur anzuhängen. Deshalb reist die Post-Quanten-Autorisierung der Transaktion voraus: Sie öffnen mit einer normalen Cosmos-Pfad-Transaktion, die Ihre ML-DSA-Signatur trägt, ein begrenztes Fenster, und der EVM-Pfad lässt dann Transaktionen zu, die davon abgedeckt sind. Ein klassischer Schlüssel allein kann nie ein Fenster öffnen, sodass ein gestohlener klassischer Schlüssel auf der EVM-Lane nur innerhalb dessen handeln kann, was ein bereits geöffnetes Fenster erlaubt. Es funktioniert wie eine Freigabe: Sie autorisieren eine begrenzte Anzahl von Transaktionen und einen begrenzten Betrag an nativem QOR für eine begrenzte Zeit und führen dann normal Transaktionen durch. Das Fenster begrenzt weder Token-Beträge noch Freigaben, die ein Contract bereits hält.

Was ein Fenster begrenzt. Drei Grenzen gelten gleichzeitig; welche zuerst erschöpft ist, schließt das Fenster.

GrenzeBedeutungZulässiger Bereich
blocksWie lange das Fenster offen bleibt, gezählt ab dem Block, der es öffnet1 – 17.280
max-txsWie viele EVM-Transaktionen es zulässt1 – 1.000
max-valueGesamter Abfluss, den es zulässt, in uqor: übertragener Wert plus die maximale Gebühr, die jede Transaktion zahlen könnte (Gas-Limit × Gebührenobergrenze), aufgerundetgrößer als 0
  • 17.280 Blöcke entsprechen etwa 15 Stunden im Mainnet (etwa 3,1 s pro Block) und etwa 6 Stunden im Testnet (etwa 1,3 s pro Block).
  • Eine Transaktion, die zugelassen wird und dann fehlschlägt, verbraucht dennoch ihren Platz und ihr Wertbudget.
  • Das Öffnen eines neuen Fensters ersetzt das vorherige; der Verbrauch beginnt wieder bei null.
  • Die CLI akzeptiert max-value in uqor oder qor (1000qor = 1.000.000.000 uqor).
  • Die Wertgrenze zählt nur natives QOR: Eine Token-Überweisung, eine Freigabe oder ein anderer Contract-Aufruf trägt den Wert null. Der Geltungsbereich (siehe unten) schränkt ein, welche Empfänger das Fenster zulässt; er begrenzt keine Token-Beträge.

Schritt 1 — Registrieren Sie Ihren Post-Quanten-Schlüssel (einmalig): siehe Registrieren Sie Ihren Post-Quanten-Schlüssel oben.

Schritt 2 — Öffnen Sie ein Fenster. Das Öffnen eines Fensters ist eine Cosmos-Pfad-Transaktion, daher wird sie unsigniert erzeugt und anschließend co-signiert:

# at most 1000 QOR in total, at most 20 transactions, for 7,200 blocks (about 6.4 hours on mainnet)
qorechaind tx pqc open-evm-window 7200 20 1000qor --from mykey \
--chain-id qorechain-diana --gas 400000 --fees 60000uqor --generate-only > window.json

qorechaind tx pqc cosign window.json --from mykey --pqc-key mypqc --chain-id qorechain-diana

Den Geltungsbereich einschränken (v3.2.3 und später). Zwei optionale Flags beschränken, was ein offenes Fenster zulässt: --native-only lässt nur einfache native QOR-Überweisungen zu (keine Calldata, keine Contract-Erstellung, keinen Empfänger, der Code trägt), und --allowed-targets 0xAAA...,0xBBB... lässt nur Transaktionen an diese Empfänger zu (höchstens 16; die Contract-Erstellung wird dann abgelehnt). Zum Beispiel:

qorechaind tx pqc open-evm-window 7200 20 1000qor --native-only --from mykey \
--chain-id qorechain-diana --gas 400000 --fees 60000uqor --generate-only > window.json

--allowed-targets begrenzt, welche Contracts und Token das Fenster berühren darf, nicht wie viel. Ein aufgelisteter Token lässt jeden Betrag dieses Tokens zu, einschließlich approve, und ein aufgelisteter Contract kann alles bewegen, was sein Code und bestehende Freigaben erlauben; listen Sie daher keine generischen Forwarder- oder Router-Contracts auf. Ein Fenster begrenzt nur Transaktionen auf der EVM-Lane (klassisch signiert); Cosmos-Nachrichten, die mit der hybriden PQC-Signatur signiert sind, etwa VM-übergreifende Aufrufe und authz, liegen außerhalb davon.

Im Mainnet hat das Öffnen eines Fensters etwa 180.000 Gas verbraucht. In QoreX ist derselbe Schritt Einstellungen → Sicherheit → EVM-Zugriffsfenster (App) bzw. die Schaltfläche EVM-Zugriffsfenster (Erweiterung). Das Öffnen des Fensters erhöht die Nonce Ihres Kontos, öffnen Sie es daher bevor Sie die EVM-Transaktion in Ihrem Wallet vorbereiten.

Schritt 3 — Prüfen Sie, was übrig ist:

qorechaind query pqc evm-window qor1youraddress...
curl -s https://api-testnet.qore.host/qorechain/pqc/v1/evm_window/qor1youraddress...

Die REST-Antwort schlägt für eine Adresse ohne Fenster nie fehl; sie liefert found: false. Die Felder sind found, live, opened_height, expiry_height, max_txs, used_txs, max_value, used_value, remaining_blocks, remaining_txs und remaining_value (uqor-Ganzzahlen, als Strings zurückgegeben). Im Mainnet verwenden Sie https://api.qore.host.

Schritt 4 — Nutzen Sie den EVM-Pfad ganz normal. Senden Sie wie gewohnt aus MetaMask oder Ihrem Tooling. Jede Transaktion verbraucht einen Transaktionsplatz und (Wert + maximale Gebühr) aus dem Fenster.

Ein Fenster vorzeitig schließen. Wenn Sie vermuten, dass Ihr klassischer Schlüssel kompromittiert ist, schließen Sie das Fenster; was es noch zugelassen hätte, wird ab dem nächsten Block abgelehnt. Das Schließen widerruft außerdem jede ausstehende EIP-7702-Delegationszustimmung (seit v3.2.2; eine Transaktion vom Typ 4, die den Code eines Kontos ändert, wird nur nach einer Post-Quanten-Zustimmung per authorize-evm-delegation zugelassen):

qorechaind tx pqc close-evm-window --from mykey --chain-id qorechain-diana \
--gas 400000 --fees 60000uqor --generate-only > close.json
qorechaind tx pqc cosign close.json --from mykey --pqc-key mypqc --chain-id qorechain-diana

Fehler

Was Sie sehenBedeutungWas zu tun ist
no open EVM authorisation window; open one with MsgOpenEVMWindow ... (Modul pqc, Code 26)Kein Fenster für dieses KontoSchritt 2
... has no registered post-quantum key; the EVM lane requires one (Code 26 auf dem EVM-Pfad; Code 28, wenn Sie versuchen, ein Fenster zu öffnen)Kein ML-DSA-Schlüssel registriertSchritt 1
the EVM authorisation window for ... does not admit this transaction (remaining: ...) (Code 27)Abgelaufen oder erschöpft; die Meldung zeigt, welche GrenzeNeues Fenster öffnen
invalid EVM authorisation window (Code 28)Grenzen außerhalb des Bereichs (blocks 1–17.280, max-txs 1–1.000, max-value > 0)Argumente korrigieren

Aus dem Code heraus können das QoreChain-SDK und @qorechain/wallet-adapter die Öffnen- und Schließen-Nachrichten zusammenstellen und den Fensterstatus lesen; siehe die SDK-Dokumentation.

Das Fenster gilt nur für den EVM-Pfad. Transaktionen auf dem Cosmos-Pfad tragen die hybride Signatur ohnehin bei jeder Transaktion, und wenn Sie nie ein Fenster öffnen, werden Ihre EVM-Transaktionen abgelehnt, während sich sonst nichts ändert.

Verwendung von SVM RPC​

Die SVM-Ausführungsumgebung von QoreChain stellt an Port 8899 eine Solana-kompatible RPC-Schnittstelle bereit. Die SVM-Transaktionsspur ist derzeit netzwerkweit deaktiviert, daher sind diese Lesemethoden der Teil, den Sie heute nutzen können.

Den aktuellen Slot abrufen​

curl -s -X POST http://localhost:8899 \
-H "Content-Type: application/json" \
-d '{
"jsonrpc": "2.0",
"method": "getSlot",
"id": 1
}' | jq '.result'

Ein Kontoguthaben abrufen​

curl -s -X POST http://localhost:8899 \
-H "Content-Type: application/json" \
-d '{
"jsonrpc": "2.0",
"method": "getBalance",
"params": ["YourSVMPublicKey"],
"id": 1
}' | jq '.result'

Gängige CLI-Muster​

Bei der Arbeit mit der qorechaind-CLI werden diese Flags häufig verwendet:

FlagBeschreibungBeispiel
--chain-idGibt die Ziel-Chain an--chain-id qorechain-diana
--feesTransaktionsgebühr in uqor (Gas-Limit × mindestens 0,1)--fees 40000uqor
--fromName oder Adresse des Signierschlüssels--from mykey
--outputAntwortformat--output json
--nodeRPC-Endpunkt, zu dem verbunden wird--node tcp://localhost:26657
--gasGas-Limit für die Transaktion--gas 400000 (oder --gas auto)
--gas-adjustmentMultiplikator für geschätztes Gas--gas-adjustment 1.5
--gas-pricesGaspreis anstelle von --fees--gas-prices 0.1uqor
--generate-onlyGibt die unsignierte Transaktion aus (vor tx pqc cosign erforderlich)--generate-only
-yBestätigungsabfrage überspringen-y

Beispiel: Vollständiger Befehl mit allen gängigen Flags​

qorechaind tx bank send mykey qor1recipient... 500000uqor \
--chain-id qorechain-diana \
--gas 400000 --fees 60000uqor \
--node tcp://localhost:26657 \
--output json \
--generate-only > tx.json

qorechaind tx pqc cosign tx.json --from mykey --pqc-key mypqc --chain-id qorechain-diana

Nächste Schritte​

Nachdem Sie nun Ihre erste Transaktion gesendet haben, erkunden Sie mehr von dem, was QoreChain bietet:

  • Staking und Delegation — Setzen Sie QOR ein, um das Netzwerk zu sichern, und erhalten Sie Staking-Belohnungen
  • Assets überbrücken — Verschieben Sie Assets über Chains hinweg
  • EVM-Entwicklung — Stellen Sie Solidity-Smart-Contracts auf QoreChain bereit