Zum Hauptinhalt springen

SX-Edition — Server-Daemon

Die SX-Edition (Server eXperience) ist der headless Light Node: ein Daemon plus eine vollständige Management-CLI, gebaut für Server und Automatisierung. Die Binärdatei ist lightnode-sx. Die Light-Node-Versionen haben eine eigene Linie, getrennt von der Chain-Version: Die Kanäle beider Netzwerke führen 3.1.14 (13. November 2026). Diese Seite weist darauf hin, wo eine Funktion 3.1.11 oder neuer erfordert.

Installation​

Vorgefertigte Binärdateien sind der einfachste Weg. Der Light-Node-Client ist eine einzelne statische Binärdatei von etwa 13 MB, ohne native Bibliotheken zu installieren: Builds für Linux (amd64, arm64), macOS (Intel, Apple Silicon) und Windows (amd64, arm64) gibt es für beide Editionen, insgesamt 12 Binärdateien pro Release. Der Node signiert seine eigenen Transaktionen, sodass nichts weiter (insbesondere kein qorechaind) nötig ist, um einen Node zu registrieren und zu betreiben.

Prüfe die Prüfsumme, bevor du sie ausführst. Das Release-Manifest unter https://download.qore.host/<net>/lightnode/latest.json enthält einen sha256-Wert für jede Binärdatei, ein checksums.url, das auf eine SHA256SUMS-Datei über das gesamte Release verweist, sowie das eigene checksums.sha256 dieser Datei. Verifiziere, was du heruntergeladen hast: Das ist der Unterschied zwischen dem Ausführen der tatsächlich gebauten Binärdatei und dem Ausführen von irgendetwas, das an dieser URL gelandet ist. Nimm die Version aus dem Manifest und nimm die Binärdatei und ihre SHA256SUMS vom selben versionierten Pfad:

NET=mainnet # or testnet
V=$(curl -fsS https://download.qore.host/$NET/lightnode/latest.json | jq -r .version) # 3.1.14 on both networks today
F=lightnode-sx-linux-amd64 # see the artifact list in latest.json
curl -fsSLO https://download.qore.host/$NET/lightnode/v$V/$F
curl -fsSLO https://download.qore.host/$NET/lightnode/v$V/SHA256SUMS
grep " $F\$" SHA256SUMS | sha256sum -c - # macOS: shasum -a 256 -c -
chmod +x $F

Verwende die versionierte SHA256SUMS (.../v$V/SHA256SUMS) zusammen mit der versionierten Binärdatei. Die unversionierte .../lightnode/SHA256SUMS gehört zum Manifest und kann einem neuen Release einige Stunden hinterherhinken, sodass eine dagegen geprüfte versionierte Binärdatei durchfallen kann.

Vergleiche unter Windows die Ausgabe von certutil -hashfile lightnode-sx-<platform>.exe SHA256 mit dem Manifestwert. Beide Manifeste akzeptieren 3.1.9 und neuer (minCompatible: 3.1.9). Der Quellcode ist öffentlich unter github.com/qorechain/qorechain-lightnode (Apache 2.0). Ein Android-Build ist dem GitHub-Release als Vorschau beigefügt; er registriert sich nicht und verdient nichts.

Du kannst die Binärdatei auch aus dem Quellcode bauen oder sie mit Docker ausführen.

Aus dem Quellcode bauen​

Der Light Node benötigt Go 1.26.1. Seine Post-Quantum-Kryptografie ist eine reine Go-Implementierung (kein CGO, keine native Bibliothek), sodass das Cross-Compiling für jede der sechs unterstützten Plattformen genauso funktioniert wie bei jeder anderen Go-Binärdatei:

go build -o build/lightnode-sx ./cmd/lightnode-sx/

Baue aus dem Release-Tag, den das Manifest nennt (heute git checkout v3.1.14). Dies erzeugt build/lightnode-sx. Führe es direkt aus oder kopiere es in deinen PATH. Prüfe vor der Registrierung den Post-Quantum-Signatur-Stack mit selftest.

Docker​

Die veröffentlichten Images sind öffentlich und lassen sich anonym ziehen: ghcr.io/qorechain/qorechain-lightnode-sx und ghcr.io/qorechain/qorechain-lightnode-ux, jeweils mit den Tags latest und v<version> (zum Beispiel v3.1.14). Die docker-compose.yml auf dem Branch main des Quell-Repositorys verwendet sie und baut aus dem Quellcode (Dockerfile.sx, Dockerfile.ux), wenn die Registry nicht erreichbar ist. Um ein Release festzulegen, ändere den image:-Tag in der Compose-Datei; um stattdessen aus einem Release-Tag zu bauen, führe git checkout v<version> aus und starte docker compose build. Schlüssel, Konfiguration und das Daten-Volume bleiben bei einem Update erhalten.

git clone https://github.com/qorechain/qorechain-lightnode
cd qorechain-lightnode

export QORE_LIGHTNODE_KEYRING_PASSPHRASE='...' # node keyring (node key + operator key)
export QORECHAIN_RPC_ADDR=https://rpc.qore.host # testnet: https://rpc-testnet.qore.host

docker compose pull # fetches the released image

# Once: the same setup as outside Docker, written into the data volume.
docker compose run --rm lightnode-sx onboard
docker compose run --rm lightnode-sx keys add-operator --recover
docker compose run --rm lightnode-sx register --delegate-to qorvaloper1...

docker compose up -d lightnode-sx
docker compose run --rm lightnode-sx status

Halte QORECHAIN_RPC_ADDR bei jedem docker compose-Befehl exportiert: Es überschreibt rpc_addr aus der Konfiguration. Seit 3.1.10 setzt die Compose-Datei als Standard den Mainnet-RPC https://rpc.qore.host, ein Testnet-Node muss daher https://rpc-testnet.qore.host exportieren, sonst folgt er dem Mainnet. Der SX-Container speichert seine Daten, einschließlich des Keyrings, dauerhaft in einem benannten Volume, das unter /root/.qorechain-lightnode eingehängt ist.

Der Node signiert nativ im Container, daher wird nichts weiter benötigt. Das SX-Image enthält weiterhin ein veröffentlichtes qorechaind (v3.2.0, nur linux/amd64, gegen einen fest hinterlegten Digest geprüft) für den qorechaind-Fallback: docker-compose.yml bindet ~/.qorechaind (oder QORECHAIND_HOME) unter /root/.qorechaind ein und übergibt QORE_LIGHTNODE_QORECHAIND_PASSPHRASE für diesen Weg. Ein Node, dessen Operator-Schlüssel in seinem eigenen Keyring liegt, verwendet keines von beiden.

Aktualisieren​

  • Light Node 3.1.11 und neuer, außerhalb von Docker. Alle 6 Stunden liest der Node https://download.qore.host/<net>/lightnode/latest.json für sein eigenes Netzwerk (Mainnet für qorechain-vladi, Testnet für qorechain-diana, nichts für andere Chains). Das Manifest ist nur ein Hinweis. Der Node installiert ein Release nur, wenn alles Folgende zutrifft:

    1. v<version>/SHA256SUMS.sig ist eine gültige Ed25519-Signatur, mit dem in die Binärdatei eingebauten Release-Schlüssel, über das Netzwerk, die Version und den Inhalt von SHA256SUMS;
    2. die Binärdatei, vom eigenen versionierten Pfad des Kanals abgerufen (Manifest-URLs werden nicht verfolgt), stimmt mit ihrer signierten Prüfsumme überein;
    3. die neue Binärdatei läuft und meldet genau v<version>.

    Danach behält er die vorherige Binärdatei als <name>.old und startet an Ort und Stelle neu: derselbe Prozess unter Linux und macOS (ein systemd-Dienst bleibt also aktiv), während unter Windows die neue Binärdatei startet und die alte sich beendet (konfiguriere einen Dienst so, dass er sich beim Beenden neu startet).

  • Einstellungen. [update] mode = "auto" (Standard, auch bei einer Konfiguration ohne diesen Abschnitt) kündigt an und installiert; "notify" kündigt nur an; "off" prüft nicht. Von Hand: lightnode-sx update --check, dann lightnode-sx update, dann den Node neu starten.

  • Eine Ankündigung sehen. Der Node protokolliert ein neueres Release und stellt es in der lokalen Dashboard-API unter GET /api/update bereit (Felder network, mode, current, latest, min_compatible, notes, update_available, mandatory, can_install, blocked, last_check, last_error); das UX-Dashboard zeigt ein Banner.

  • Container oder nicht beschreibbarer Ordner. Der Node kündigt nur an: Aktualisiere das Image oder die Datei selbst.

  • Light Node 3.1.11 und neuer installieren neue Releases innerhalb von 6 Stunden nach der Veröffentlichung selbst (am Test-Node im Testnet geprüft).

  • Light Node 3.1.10 und früher aktualisieren sich nicht selbst. Installiere 3.1.14 einmal von Hand: Lade die versionierte Binärdatei vom Manifestpfad herunter (siehe Installation), verifiziere sie, ersetze die Datei und starte neu. Danach folgt der Node seinem Kanal.

  • Docker. Ein Docker-Node wird über ein neues Release benachrichtigt (Log und GET /api/update), ersetzt sich aber nie selbst; das Pullen ist das Update: docker compose pull && docker compose up -d (lass QORECHAIN_RPC_ADDR exportiert). Alternativ kannst du aus dem neuen Quell-Tag bauen.

Konfiguration​

Der Light Node liest eine TOML-Konfigurationsdatei. Standardmäßig sucht er nach config.toml im Home-Verzeichnis (~/.qorechain-lightnode/config.toml). Normalerweise schreibst du diese Datei nicht von Hand — der onboard-Assistent erstellt sie für dich — aber es ist nützlich, die Optionen zu verstehen.

Zwei persistente Flags gelten für jeden Befehl:

  • --config <path> — auf eine Konfigurationsdatei an einem nicht standardmäßigen Ort zeigen.
  • --home <dir> — das für Daten und Schlüssel verwendete Home-Verzeichnis überschreiben (Standard ist ~/.qorechain-lightnode).

Die relevantesten Konfigurationsoptionen auf Nutzungsebene:

OptionWas sie steuert
chain_idDer Netzwerk-Identifikator (qorechain-vladi im Mainnet, qorechain-diana im Testnet). onboard liest ihn vom RPC-Endpunkt; war der Endpunkt während onboard nicht erreichbar, bleibt der Standard qorechain-diana stehen, und du musst ihn selbst setzen. Transaktionen werden für diese Chain signiert.
rpc_addrDer Chain-RPC-Endpunkt, mit dem sich der Daemon verbindet. Leer lassen, um im Local-only-Modus zu laufen.
primary_addr / witness_addrsDer primäre RPC-Endpunkt und die Witness-Endpunkte, gegen die sein gemeldeter Header abgeglichen wird — siehe Warum einen Light Node betreiben. Mindestens ein eigenständiger, erreichbarer Witness bewirkt, dass der Wert assurance (auf Debug-Level protokolliert) von trusted-single-source zu corroborated-across-sources wechselt.
trust_period / max_clock_driftAus Kompatibilitätsgründen akzeptiert, aber derzeit ungenutzt. Das Header-Vertrauen stammt aus dem oben beschriebenen Abgleich von Primary und Witnesses.
data_dirWo der Node seine Datenbank und Header speichert.
keyring_backend / key_nameKeyring-Backend (file, os oder test, nur für lokale Devnets) und der Name des Post-Quantum-Schlüssels, mit dem der Node signiert. onboard setzt key_name auf den Schlüssel, den es erstellt (validator); keys add-operator ändert ihn auf operator-pqc, wenn es den Schlüssel aus den Wörtern des Kontos ableitet oder wiederherstellt. Das file-Backend erfordert QORE_LIGHTNODE_KEYRING_PASSPHRASE in der Umgebung.
operator_addressDas Konto, zu dem dieser Node gehört (qor1...); wird beim Laden validiert. keys add-operator trägt es ein. Erforderlich für register, status und Heartbeats. Siehe Die Operator-Wallet.
api_addrDer REST-Endpunkt. onboard schreibt ihn in config.toml (Mainnet https://api.qore.host, Testnet https://api-testnet.qore.host). Bei leerem Wert wird er aus rpc_addr abgeleitet (Port 26657 wird zu 1317; rpc.- und rpc-testnet.-Hosts werden zu api. bzw. api-testnet.; zum Beispiel ergibt https://rpc-testnet.qore.host den Wert https://api-testnet.qore.host), ist also nur für Endpunkte nötig, die keiner dieser Konventionen folgen. Bis 3.1.12 gab es nur die Zuordnung rpc. zu api., daher konnte ein Testnet-Node mit leerem api_addr bei Lizenz, Registrierung und Status „404 page not found“ melden; setze api_addr bei diesen Versionen von Hand oder aktualisiere.
[heartbeat]Standardmäßig aktiv (enabled). interval_blocks (an das heartbeat_interval der Chain angleichen, 1000), check_interval (Standard 60s) und gas (Standard 300000, die Obergrenze für das Gaslimit eines Heartbeats; beim nativen Signieren beträgt die Gebühr 0,25 uqor pro Gas-Einheit). Ab 3.1.13 setzt der Node das Gaslimit jedes Heartbeats auf den Verbrauch des vorherigen Heartbeats plus 25 %, aufgerundet auf 1.000 Gas und nie über gas; der erste Heartbeat nach einem Start und der erste nach einer Out-of-Gas-Ablehnung nutzen die Obergrenze. Gemessen im Testnet: Limit 216.000, verbraucht 165.774, Gebühr 54.000 uqor (0,054 QOR) pro Heartbeat statt 75.000 uqor. Das Operator-Konto muss zusätzlich zum Stake von 1.000 QOR frei verfügbares QOR halten, um diese Gebühren zu zahlen. Nur vom qorechaind-Fallback verwendet: fees (Standard 50000uqor), qorechaind_path (leer bedeutet qorechaind im PATH), qorechaind_home (leer bedeutet ~/.qorechaind), keyring_backend und key_name (der qorechaind-Schlüssel, der das Operator-Konto hält; Standard ist der key_name der obersten Ebene).
[delegation]auto_claim (standardmäßig aus: fordert aufgelaufene Light-Node-Belohnungen über den Signierer auf das Operator-Konto ein; der Node delegiert vom Server aus nie neu), das Prüfintervall, die Mindestbelohnung für das Einfordern, rebalance_enabled (standardmäßig an) und min_reputation (nur Warnungen; der Node verschiebt nie Stake). Ab 3.1.11 schaltet rebalance_enabled Warnungen ein für einen delegierten Validator, der gejailt oder nicht im aktiven Set ist, und für gebundenen Stake unter min_delegated_stake (1.000 QOR); min_reputation (Standard 0.5) gilt dort, wo das Netzwerk Reputationswerte pro Validator bereitstellt, was heute das Testnet ist. validators und split_weights werden akzeptiert, derzeit aber nicht ausgewertet.
[update]mode: auto (Standard, auch wenn der Abschnitt fehlt), notify (nur ankündigen) oder off. Light Node 3.1.11 und neuer. Siehe Aktualisieren.
[telemetry]Ob Telemetrie aktiviert ist und die Aktualisierungsintervalle für Validatoren, Netzwerk, Bridge und Tokenomics.
[dashboard]Die lokale Dashboard-API. Die UX-Edition stellt sie immer bereit; die SX-Edition nur mit enabled = true. bind_addr (Standard 127.0.0.1:8420) und token (wenn gesetzt, verlangen jede /api-Route und /ws den Header Authorization: Bearer <token>). Siehe UX-Edition.
log_level / log_formatLogging-Ausführlichkeit (debug, info, warn, error) und Format (text oder json). Schlüssel der obersten Ebene: Setze sie vor die erste [table].

Umgebungsvariablen​

VariableVerwendet für
QORE_LIGHTNODE_KEYRING_PASSPHRASEPassphrase des Node-Keyrings (keyring_backend = "file"), der den Post-Quantum-Schlüssel des Nodes und den Schlüssel des Operator-Kontos enthält. Erforderlich für jeden Befehl, der den Keyring öffnet, und für start; der Node lehnt eine leere ab.
QORE_LIGHTNODE_QORECHAIND_PASSPHRASENur für den qorechaind-Fallback: Passphrase des qorechaind-Keyrings mit dem Operator-Schlüssel; wird qorechaind über stdin übergeben, nie in einer Kommandozeile.
QORECHAIN_RPC_ADDRÜberschreibt rpc_addr (und primary_addr, wenn es rpc_addr entsprach). Wird von docker-compose.yml gesetzt.
Witness-Endpunkte werden beim Start validiert

Ein Witness auf demselben Host wie der Primary wird abgelehnt — ein kompromittierter Endpunkt würde sich einfach selbst bestätigen und damit nichts korroborieren. Ein Klartext-http://-Witness auf einem entfernten Host wird ebenfalls abgelehnt, da ein Angreifer, der diese Verbindung umschreiben kann, als jeder Witness gleichzeitig antworten könnte; Loopback-http:// ist unbedenklich. Richte Witnesses auf RPC-Endpunkte, denen du aus unabhängigen Gründen vertraust.

Die Delegations-Standardwerte aktivieren die Stake-Warnungen und lassen auto_claim aus; siehe Belohnungen und Überwachung dazu, was diese bewirken.

Erster Start: onboard​

Beim ersten Start stoppt start und verweist dich auf den Onboarding-Assistenten, falls noch keine Konfigurationsdatei existiert. Setze zuerst die Keyring-Passphrase — onboard startet ohne sie nicht, damit es nie einen Schlüssel erzeugt, den es nicht speichern kann — und führe dann den Assistenten aus:

export QORE_LIGHTNODE_KEYRING_PASSPHRASE='choose-a-passphrase'
lightnode-sx onboard

onboard führt dich in vier Schritten durch die Einrichtung:

  1. PQC-Selbsttest — führt den vollständigen Dilithium-5-Roundtrip aus (dieselben Prüfungen wie selftest). Wenn der PQC-Stack fehlschlägt, verweigert der Assistent das Fortfahren.
  2. Chain-RPC-Endpunkt — füge deine QoreChain-RPC-URL ein (Mainnet https://rpc.qore.host, Testnet https://rpc-testnet.qore.host) oder lasse sie leer, um im Local-only-Modus zu laufen. Wenn du eine URL angibst, testet der Assistent sie live und liest die Chain-ID daraus.
  3. Node-Schlüssel — der Assistent nennt ihn „privater Validator-Schlüssel“, aber es ist der eigene Dilithium-5-Schlüssel des Light Nodes, kein Validator-Schlüssel. Füge einen hex-kodierten privaten Dilithium-5-Schlüssel ein oder tippe g (oder generate), um auf diesem Node ein frisches Schlüsselpaar zu erzeugen.
  4. Speichern — schreibt config.toml (mit dem Endpunkt und der Chain-ID) und legt den Schlüssel unter dem Namen validator im Keyring ab (oder validator-<hex>, falls dieser Name vergeben ist), wobei key_name darauf gesetzt wird.
Local-only-Modus

Wenn du den Endpunkt leer lässt, startet der Daemon im Local-only-Modus: Der PQC-Stack wird vollständig durchlaufen, aber der Node synchronisiert keine Chain. Führe onboard erneut aus, sobald dein Chain-Endpunkt bereit ist, um den Node darauf zu verweisen.

onboard überschreibt immer die aktive Konfiguration. Verwende --config, um an einen nicht standardmäßigen Pfad zu schreiben, oder --non-interactive, um schnell fehlzuschlagen statt nachzufragen (nützlich in CI).

Als Nächstes: das Operator-Konto

onboard weiß nicht, welches Konto dir gehört. Bevor du register ausführst, füge das Operator-Konto mit keys add-operator hinzu. Es trägt operator_address für dich ein. War der Endpunkt während onboard nicht erreichbar, prüfe außerdem, ob chain_id in config.toml qorechain-vladi (Mainnet) oder qorechain-diana (Testnet) ist, und dass api_addr gesetzt ist (onboard schreibt ihn; ein Testnet-Node mit 3.1.12 oder früher und leerem api_addr meldet möglicherweise „404 page not found“).

Ausführen: start​

Sobald das Onboarding eine Konfiguration geschrieben hat, starte den Daemon:

build/lightnode-sx start

Der Daemon synchronisiert Header, verfolgt Delegationen und stellt Telemetrie bereit, bis er unterbrochen wird. Wenn du absichtlich ohne Konfigurationsdatei starten möchtest (Local-only, kein Chain-RPC), übergib --skip-onboarding-check.

Den PQC-Stack verifizieren: selftest​

Du kannst jederzeit bestätigen, dass der Post-Quantum-Stack funktionsfähig ist:

lightnode-sx selftest

selftest führt fünf Prüfungen gegen Dilithium-5 (ML-DSA-87) aus und schließt in unter einer Sekunde ab:

  1. Keygen — ein frisches Schlüsselpaar erzeugen.
  2. Sign — eine Testnachricht signieren.
  3. Verify (gültige Signatur) — bestätigen, dass die Signatur mit dem passenden öffentlichen Schlüssel verifiziert.
  4. Manipulierte Signatur ablehnen — ein Byte der Signatur umdrehen; die Verifizierung muss es ablehnen.
  5. Manipulierte Nachricht ablehnen — ein Byte der Nachricht umdrehen; die Verifizierung muss es ablehnen.

Wenn eine Prüfung fehlschlägt, beendet sich die Binärdatei mit einem Exit-Code ungleich null und Diagnoseausgabe. Dies ist derselbe Test, den der Onboarding-Assistent als ersten Schritt ausführt, und er ist praktisch für die Verifizierung vor dem Deployment und für Support-Diagnosen.

Die Operator-Wallet​

Der Dilithium-5-Schlüssel des Nodes ist keine Wallet. Auf QoreChain wird ein Post-Quantum-Schlüssel an ein Konto angehängt; er erzeugt keines. Deshalb zeigt keys list dafür keine Adresse an. Deine Operator-Adresse ist ein gewöhnliches qor1…-Konto, das die Lizenz und den Stake hält, die Gebühren zahlt und die Light-Node-Belohnungen erhält. Es muss ein Konto sein, dessen Wiederherstellungswörter du besitzt (deine eigenen Wörter, Keplr oder qorechaind); ein eigenes Konto ist am besten. Eine Custodial-Wallet im Dashboard kann keinen Node betreiben, es sei denn, du exportierst ihren Seed. Siehe Das Operator-Konto.

Lege den Schlüssel des Operator-Kontos im Keyring des Nodes ab:

# The account the licence is for: type its recovery words, then Enter
lightnode-sx keys add-operator --recover

# Or create a new account; its 24 words are shown once
lightnode-sx keys add-operator

keys add-operator:

  • leitet den Kontoschlüssel aus den Wörtern genau so ab wie qorechaind und Keplr (m/44'/118'/0'/0/0), legt ihn im Keyring als operator ab und schreibt das Konto in operator_address in config.toml. Ist operator_address bereits auf ein anderes Konto gesetzt, verweigert es die Ausführung;
  • wählt den Post-Quantum-Schlüssel, mit dem der Node signiert, legt ihn als operator-pqc ab und setzt key_name darauf. Hat das Konto bereits einen Post-Quantum-Schlüssel — meist von einer Wallet aus denselben Wörtern registriert —, wird dieser Schlüssel aus den Wörtern rekonstruiert (die Ableitungen von wallet-adapter und Dashboard, dieselbe wie qorechaind tx pqc recover-key). Hat das Konto keinen, wird ein Schlüssel aus den Wörtern abgeleitet, sodass die Wörter auch den Schlüssel des Nodes wiederherstellen. Ist der registrierte Schlüssel des Kontos bereits der aktuelle Schlüssel des Nodes, wird dieser beibehalten. Lässt sich der Schlüssel des Kontos nicht aus den Wörtern reproduzieren, verweigert der Befehl die Ausführung und empfiehlt ein eigenes Konto;
  • nennt, woher die Lizenz für das jeweilige Netzwerk kommt: ein Kauf im Dashboard im Mainnet, die kostenlose Self-Service-Anfrage im Testnet;
  • erstellt ohne --recover ein neues Konto und zeigt dessen 24 Wörter einmal an. Schreibe sie auf; sie sind die einzige Sicherung. Finanziere das Konto und kaufe die Lizenz für seine Adresse, bevor du dich registrierst.

Die Keyring-Passphrase (QORE_LIGHTNODE_KEYRING_PASSPHRASE) schützt diesen Schlüssel ebenso wie den Node-Schlüssel. Registriere dich dann:

lightnode-sx register --delegate-to qorvaloper1...

register prüft die Lizenz, hängt den Post-Quantum-Schlüssel an, sofern das Konto ihn nicht bereits hat, delegiert den fehlenden Stake nur, wenn du mit --delegate-to einen Validator angibst, und registriert den Node; jeder Schritt wird in einem Block bestätigt, bevor der nächste folgt. Siehe Registrierung und Lizenzierung für die Details und für den Fallback register --print für Betreiber, die den Kontoschlüssel in einem qorechaind-Keyring aufbewahren.

Neue Schutzmaßnahmen in 3.1.14​

  • Der Schlüsselimport bleibt aus der Prozessliste heraus. keys import <name> liest den privaten Hex-Schlüssel von der Standardeingabe oder aus --key-file <file>. Ein als zweites Argument getippter Schlüssel wird abgelehnt. --unsafe-argv stellt die alte Form mit einer Warnung wieder her.
  • Der Schlüsselspeicher wird atomar geschrieben. keystore/keys.enc wird in einem Schritt ersetzt, und die vorherige Version bleibt als keystore/keys.enc.bak erhalten. Sichere nach der Einrichtung keys.enc (oder deine Wiederherstellungsworte) an einem Ort außerhalb der Maschine.
  • Begrenzter Auto-Claim. Der Node prüft höchstens alle 10 Minuten (ein niedrigerer compound_interval wird auf 10m angehoben) und sendet höchstens alle 6 Stunden eine Anforderung.
  • Begrenzte Dashboard-Verbindungen. Der Dashboard-WebSocket akzeptiert höchstens 32 Verbindungen.
  • Begrenzte Chain-Antworten. Jede REST-Antwort der Chain ist auf 4 MiB begrenzt. Beim Start warnt der Node, wenn api_addr einfaches http:// zu einer anderen Maschine ist: Verwende https://.

Management-Befehle​

Die SX-CLI enthält Befehle zum Einsehen des Node-Zustands und zur Schlüsselverwaltung. Seit 3.1.7 hat die UX-Binärdatei (lightnode-ux) dieselben Befehle.

BefehlZweck
onboardInteraktiver Assistent für den ersten Start.
startDen Daemon ausführen.
selftestDen PQC-Selbsttest ausführen.
statusNode- und Light-Client-Sync-Status anzeigen (Chain-ID, neueste Höhe, Aufhol-Status) sowie die Zeilen Signer (nativ oder qorechaind), Operator, Licence und Registration.
keys create <name>Einen neuen Dilithium-5-Node-Schlüssel erstellen und seinen öffentlichen Schlüssel ausgeben.
keys listSchlüssel im Keyring auflisten (Name, Typ, ggf. Adresse, öffentlicher Schlüssel).
keys show <name>Typ und vollständigen öffentlichen Schlüssel eines Schlüssels ausgeben.
keys import <name> [--key-file <file>]Einen hex-kodierten privaten Schlüssel importieren. Ab 3.1.14 wird der Schlüssel von der Standardeingabe oder aus --key-file <file> gelesen. Ein als zweites Argument angegebener Schlüssel wird abgelehnt, weil er in der Prozessliste und im Shell-Verlauf sichtbar wäre; --unsafe-argv stellt die alte Form mit einer Warnung wieder her.
keys export <name> [--out <file>]Einen privaten Schlüssel im Hex-Format exportieren. --out schreibt die Datei, die qorechaind --pqc-key liest (ohne abschließenden Zeilenumbruch, Modus 0600).
keys add-operator [--recover]Den Schlüssel des Operator-Kontos ablegen (neu oder aus seinen Wörtern über die Standardeingabe wiederhergestellt) und den Post-Quantum-Schlüssel wählen; trägt operator_address ein. Siehe Die Operator-Wallet.
register [--delegate-to <qorvaloper>] [--print]Den Node on-chain registrieren: Post-Quantum-Schlüssel, fehlender Stake, Registrierung, jeweils in einem Block bestätigt. --print gibt stattdessen die qorechaind-Befehle aus — siehe Registrierung und Lizenzierung.
validatorsGebundene (bonded) Validatoren auflisten.
delegationDie Delegationen des Operator-Kontos anzeigen, wie sie vom laufenden Daemon in die lokale Datenbank gespiegelt wurden.
rewardsDie ausstehenden Staking-Belohnungen des Operator-Kontos anzeigen (nicht die Light-Node-Belohnungen; siehe Belohnungen und Überwachung).
networkNetzwerk-Telemetrie (kürzlich synchronisierte Header) aus der lokalen Datenbank anzeigen.
update [--check]Light Node 3.1.11 und neuer. --check sagt, ob ein neueres Release existiert; ohne es wird verifiziert, installiert und die vorherige Binärdatei als <name>.old behalten. Starte den Node danach neu. Siehe Aktualisieren.
versionDie Version der Binärdatei ausgeben.

Für Details zu Staking, Belohnungen und Überwachung siehe Belohnungen und Überwachung. Zum On-Chain-Registrieren siehe Registrierung und Lizenzierung.