Sari la conținutul principal

Rularea unui Validator

Acest ghid acoperă modul de creare a unui validator pe rețeaua QoreChain, înțelegerea designului de clasificare pe pool-uri, înregistrarea unei chei PQC (semnături hibride ML-DSA-87, FIPS 204) și monitorizarea nodului tău.

notă

Acest ghid vizează mainnet-ul qorechain-vladi (chain ID EVM 9801), activ din 7 iunie 2026, care rulează versiunea de nod v3.2.7 (aplicată prin propunerea de guvernanță 16 la înălțimea 4.164.600, pe 12 noiembrie 2026, după v3.2.6 la înălțimea 4.020.000, pe 4 noiembrie 2026, v3.2.5 la înălțimea 3.906.833, pe 29 octombrie 2026, v3.2.4 la înălțimea 3.742.566, pe 23 octombrie 2026 și v3.2.3 la înălțimea 3.662.051, pe 20 octombrie 2026). Un validator trebuie să ruleze binarul v3.2.7 (minCompatible din manifest este 3.2.7); un nod rămas pe v3.2.6 s-a oprit la înălțimea 4.164.600 și are nevoie de pachetul v3.2.7 (vezi Rularea unui nod: Upgrade-uri). Testnet-ul qorechain-diana (chain ID EVM 9800) rulează v3.2.8 din 12 noiembrie 2026 (după v3.2.7 pe 6 noiembrie, v3.2.6 pe 27 octombrie și v3.2.5 pe 26 octombrie; minCompatible din manifestul său este 3.2.8, vezi nota despre testnet din Rularea unui nod) și este recomandat pentru a-ți repeta configurația înainte de a trece pe rețeaua live. Înlocuiește --chain-id cu valoarea corespunzătoare rețelei tale țintă. Timpii de bloc diferă: aproximativ 3,1 s pe mainnet (ultimele 1.000 de blocuri au durat 52 de minute și 21 de secunde pe 27 octombrie 2026) și aproximativ 1,3 s pe testnet; ambele variază, așa că convertește numărul de blocuri în timp separat pentru fiecare rețea.

Folosește binarul de release, nu un build din sursă

Un validator trebuie să ruleze qorechaind de release indicat în manifestul live (https://download.qore.host/mainnet/latest.json; vezi Rularea unui Nod). Un binar construit din sursa publică are keeper-i stub și nu are semnatar post-cuantic: nu poate reproduce starea de consens a rețelei și nu poate crea semnătura hibridă de care au nevoie create-validator și orice altă tranzacție de pe lane-ul Cosmos (vezi Construirea din Sursă). Începând cu v3.2.3, un binar construit din sursa publică refuză cu totul să pornească pe o rețea publică. Un nod de mainnet nou are nevoie de v3.2.0 sau mai nou; ține ceasul sistemului sincronizat prin NTP, deoarece începând cu v3.2.1 nodul se oprește dacă ceasul lui deviază cu mai mult de 60 de secunde.

Care părți ale acestei pagini sunt active

Producerea de blocuri folosește rotația standard de validatori ponderată după stake, iar slashing-ul și guvernanța folosesc modulele standard Cosmos SDK, cu parametrii afișați mai jos. Logica Triple-Pool CPoS (clasificarea pe pool-uri, selecția propunătorului ponderată pe pool-uri, curba de bonding și slashing-ul progresiv) este implementată în modulul x/qca, iar parametrii ei sunt on-chain, dar nu este încă conectată la producerea de blocuri, la recompense sau la slashing. Secțiunile despre aceste subiecte descriu designul; nu planifica în funcție de apartenența la un pool sau de reputație, care nu îți modifică astăzi cota de propuneri de bloc sau recompensele.


Cerințe preliminare​

  • Un nod qorechaind de release complet sincronizat (vezi Conectarea la Mainnet, sau Conectarea la Testnet pentru a repeta configurația)
  • O cheie PQC ML-DSA-87 înregistrată pe contul operatorului (vezi Înregistrarea Cheii PQC) — create-validator are nevoie de semnătura hibridă
  • Un cont alimentat cu cel puțin 100.000 QOR (100.000.000.000 uqor) pentru auto-delegarea inițială — acest minim este impus on-chain, iar create-validator este respins sub acest prag
  • O acordare validator_operator activă pe adresa ta de operator, emisă prin Validator Program de pe pagina Nodes & Validators a Dashboard-ului (aplici, ești selectat, plătești taxa de program de $1,000); vezi nota de mai jos. Fără ea, create-validator eșuează cu ErrUnauthorized, indiferent cât de mult QOR auto-bondezi
  • Familiaritate cu modelul Staking și Delegare

Alăturarea la rețea​

Folosește state sync ca modalitate implicită de a te alătura. Acesta preia de la peer-i o stare recentă a aplicației, în loc să reia fiecare bloc de la genesis. Descărcarea snapshot-ului este doar o variantă de rezervă: snapshot-ul din manifestul mainnet este în continuare arhiva din 21 august 2026 (înălțimea 1.966.629, aproximativ 27 GB), care precede mai multe upgrade-uri și apoi reia aproximativ două luni de blocuri, iar testnet-ul nu publică niciun snapshot.

  1. Instalează qorechaind de release pe care îl numește manifestul (vezi Rularea unui Nod), rulează qorechaind init <moniker> --chain-id qorechain-vladi, apoi pune la locul lor genesis-ul, peer-ii și seed-urile din manifest, așa cum este descris acolo, și setează minimum-gas-prices = "0.1uqor" în app.toml.
  2. Ia punctul de încredere din manifest și scrie secțiunea [statesync] din config.toml:
curl -s https://download.qore.host/mainnet/latest.json -o latest.json
TRUST_HEIGHT=$(jq -r .stateSync.trustHeight latest.json)
TRUST_HASH=$(jq -r .stateSync.trustHash latest.json)
[statesync]
enable = true
rpc_servers = "https://rpc.qore.host:443,https://<a second RPC you run or trust>:26657"
trust_height = <TRUST_HEIGHT>
trust_hash = "<TRUST_HASH>"
trust_period = "168h0m0s"
  1. Opțional, ține discul mic (vezi Hardware): în app.toml setează pruning = "custom" cu pruning-keep-recent = "100000" și pruning-interval = "10", iar în config.toml setează indexer = "null" sub [tx_index] (un validator nu servește căutări de tranzacții; nu folosi null pe un nod pe care îl interoghezi).
  2. Pornește cu qorechaind start --minimum-gas-prices=0.1uqor și așteaptă până când catching_up este false.
State sync are nevoie de două servere RPC diferite

State sync verifică încrucișat punctul de încredere cu două servere RPC. stateSync.rpcServers din manifest listează https://rpc.qore.host de două ori (iar manifestul testnet listează https://rpc-testnet.qore.host de două ori). Două intrări identice satisfac numărătoarea, dar anulează verificarea încrucișată, deoarece ambele răspunsuri vin de la un singur server. Adaugă un al doilea RPC pe care îl rulezi tu sau în care ai încredere independent și verifică hash-ul de încredere față de o a doua sursă înainte de a porni, de exemplu curl -s "https://<second-rpc>/block?height=$TRUST_HEIGHT" | jq -r .result.block_id.hash trebuie să fie egal cu $TRUST_HASH. Punctul de încredere din manifest este reîmprospătat din oră în oră, așa că preia-l din nou dacă a devenit învechit.

Ține ceasul sistemului sincronizat prin NTP: începând cu v3.2.1 nodul se oprește dacă ceasul lui deviază cu mai mult de 60 de secunde.


Parametrii rețelei​

Aceste valori au fost citite din API-ul REST al mainnet-ului pe 27 octombrie 2026 (qorechain-vladi, atunci pe v3.2.4) și recitite pe 4 noiembrie 2026 pe v3.2.6: neschimbate (nu au fost recitite după upgrade-ul v3.2.7) (8 validatori bonded, niciunul jailed). Citește-le live înainte să te bazezi pe ele: qorechaind query staking params, qorechaind query slashing params, sau GET /cosmos/staking/v1beta1/params și GET /cosmos/slashing/v1beta1/params.

ElementValoare
Dimensiunea setului activ (max_validators)100 (astăzi 8 validatori sunt bonded, niciunul jailed)
Perioada de unbonding1.814.400 s (21 de zile); cel mult 7 intrări de unbonding (max_entries) per delegator
Rata minimă de comision (min_commission_rate)0 (îți alegi singur rata, până la commission-max-rate)
Fereastra de blocuri semnate10.000 de blocuri (signed_blocks_window)
Minim semnat per fereastră0,05, deci un validator este băgat la închisoare (jailed) când semnează mai puțin de 5% din fereastră
Jail / slash pentru downtime600 s de jail, 1% din stake slashed
Slash pentru double-sign5% din stake
Pragul de auto-bond pentru a crea un validator100.000 QOR (100000000000uqor), impus on-chain; sub acesta create-validator eșuează cu codul 18
Acordarea de operatorEste necesară o acordare validator_operator activă pe expeditor; fără ea create-validator eșuează cu ErrUnauthorized
Pragul minim al comisionului0,1 uqor per gas

Ordinea operațiunilor. Fă-le în această ordine: (1) înregistrează cheia PQC a contului, (2) obține acordarea validator_operator, (3) construiește create-validator cu --generate-only și semnează-l cu tx pqc cosign. Cheia vine prima, deoarece un cont fără cheie înregistrată poate trimite doar înregistrarea însăși (vezi Înregistrarea Cheii PQC), iar acordarea este verificată când rulează create-validator. Detaliile sunt în Crearea unui Validator și Înregistrarea Cheii PQC.

min-self-delegation nu este pragul de 100.000 QOR

Validatorii de la genesis arată min_self_delegation = 1 (1 uqor) on-chain. Acesta nu este pragul: tranzacțiile lor de genesis au fost scutite de el. Câmpul min-self-delegation din validator.json este propria ta promisiune de a păstra cel puțin atât auto-bondat, fără legătură cu pragul de 100.000 QOR, care se aplică sumei amount pe care o auto-delegi la crearea validatorului.


Hardware​

Măsurat pe validatorii mainnet aflați în funcțiune (27 octombrie 2026): aproximativ 3,2 până la 3,5 GB de RAM și sub 10% CPU în sarcină normală. Un validator rulează confortabil pe 3 până la 4 vCPU, 8 până la 16 GB de RAM și stocare NVMe. Viteza pe un singur nucleu contează mai mult decât numărul de nuclee: verificarea semnăturilor ML-DSA-87 reprezintă aproximativ jumătate din munca de verificare a unei tranzacții și atinge vârful sub sarcină.

ElementProfil de validator sugerat
CPU4 vCPU, frecvență ridicată
RAM16 GB
Disc100 GB sau mai mult, NVMe
CeasSincronizat prin NTP (regula celor 60 de secunde de mai sus)
RețeaDoar P2P 26656 deschis către lume; RPC, REST și EVM legate de localhost

Utilizarea discului depinde de modul în care te-ai alăturat. Un validator care s-a alăturat prin state sync cu pruning = "custom" (keep-recent 100000) și indexer = "null" ocupă aproximativ 10 GB după două luni. Un nod cu pruning implicit, care rulează de la genesis, ocupă aproximativ 100 până la 130 GB după patru luni. Cei 500 GB sau mai mult sugerați pentru nodurile RPC în Rularea unui Nod sunt generoși pentru un validator.


Cum este rulată rețeaua​

Pe 27 octombrie 2026 rețeaua are 8 validatori activi, în mai multe țări și la mai mult de un furnizor de hosting. Endpoint-urile publice (rpc.qore.host, api.qore.host, evm.qore.host, svm.qore.host) sunt servite de noduri dedicate, care nu sunt validatori, aflate în spatele unei rețele edge, niciodată de validatori, iar adresele IP ale validatorilor nu sunt publicate în DNS. Puterea de vot urmează stake-ul bonded: un validator nou, cu auto-bond-ul minim, pornește cu o cotă mică de putere și crește pe măsură ce sosesc delegări.


Crearea unui Validator​

Acordarea de operator: validator_operator​

create-validator este condiționat de două verificări independente, ambele impuse on-chain, și ai nevoie de amândouă — un auto-bond mare, de unul singur, nu este suficient:

  1. Auto-bond minim de 100.000 QOR.
  2. O acordare validator_operator activă pe contul care trimite tranzacția.

Acordarea este emisă on-chain de QoreChain Association prin Validator Program: aplici pe pagina Nodes & Validators a Dashboard-ului (Tools Hub), rulezi un validator pe testnet-ul diana pentru perioada de probă de 14 zile și, odată selectat, plătești taxa de program de $1,000; acordarea este apoi semnată în loturi pentru adresa de operator din aplicația ta. Verifică-o pe a ta cu GET /qorechain/license/v1/check/{grantee}/validator_operator. Câmpul expires_at al unei licențe este o înălțime de bloc, nu o dată sau o durată — 0 înseamnă fără expirare. Dacă lipsește sau a expirat, create-validator eșuează cu ErrUnauthorized, indiferent cât de mult auto-bondezi; acesta este cel mai frecvent motiv pentru care o încercare bine finanțată eșuează și pare inexplicabilă. Această poartă există special pentru că lane-ul de execuție EVM nu o poate vedea sau impune (un singur decorator ante acolo ar ocoli-o complet) — este unul dintre motivele pentru care staking-ul și validarea rămân exclusiv pe lane-ul Nativ.

Creează un fișier validator.json (forma bazată pe flag-uri a fost eliminată în SDK-ul actual):

{
"pubkey": {"@type": "/cosmos.crypto.ed25519.PubKey", "key": "<base64 key from: qorechaind comet show-validator>"},
"amount": "100000000000uqor",
"moniker": "my-validator",
"identity": "",
"website": "",
"security": "",
"details": "",
"commission-rate": "0.10",
"commission-max-rate": "0.20",
"commission-max-change-rate": "0.01",
"min-self-delegation": "1"
}

Apoi generează și semnează tranzacția (are nevoie de semnătura hibridă, ca orice tranzacție de pe lane-ul Cosmos; vezi Comenzi de Tranzacție):

qorechaind tx staking create-validator validator.json \
--from mykey --chain-id qorechain-vladi \
--gas 600000 --fees 60000uqor \
--generate-only > tx.json

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

Pragul minim de comision al rețelei este de 0,1 uqor per unitate de gas, deci o limită de gas de 600.000 necesită cel puțin 60.000 uqor.

Câmp validator.jsonDescriere
amountSuma auto-delegată — minimum 100.000 QOR (100000000000uqor)
pubkeyCheia publică de consens a validatorului (ed25519)
monikerNumele lizibil al validatorului tău
commission-rateRata de comision inițială (ex., 0.10 = 10%)
commission-max-rateRata maximă de comision (imuabilă după creare)
commission-max-change-rateRata maximă de schimbare zilnică a comisionului
min-self-delegationPropriul tău angajament de a păstra cel puțin atât auto-bondat (în uqor). Nu este pragul on-chain de 100.000 QOR, care se aplică lui amount

După confirmarea tranzacției, verifică validatorul tău:

qorechaind query staking validator $(qorechaind keys show mykey --bech val -a)

Clasificarea pe Pool-uri​

Design, încă neactiv în producerea de blocuri

Clasificarea pe pool-uri de mai jos este designul x/qca. Parametrii ei sunt on-chain (qorechaind query qca config), dar propunătorii de blocuri nu sunt încă aleși după pool, iar pool-urile nu modifică încă recompensele sau slashing-ul.

Modulul x/qca (Quantum Consensus Allocation) al QoreChain definește un sistem de clasificare pe trei pool-uri. La fiecare 1.000 de blocuri (aproximativ 52 de minute la blocurile de 3,1 s ale mainnet-ului), validatorii urmează să fie reclasificați într-unul dintre cele trei pool-uri, în funcție de reputația și stake-ul lor:

PoolCriteriuAlocare de blocuri
RPoS (Reputation Proof-of-Stake)Reputație >= percentila 70 ȘI stake >= mediana40% din blocuri
DPoS (Delegated Proof-of-Stake)Delegare totală >= 10.000 QOR35% din blocuri
PoS (Proof-of-Stake)Toți ceilalți validatori activi25% din blocuri

În design, propunătorii de blocuri din cadrul fiecărui pool sunt selectați prin selecție ponderată aleatorie, proporțională cu stake-ul lor efectiv, astfel încât atât validatorii cu reputație ridicată, cât și cei cu delegare ridicată primesc o reprezentare corectă, permițând în același timp validatorilor mai mici să participe.

Interogarea Configurației Pool-urilor​

# Pool weights and classification parameters (there is no per-validator classification query)
qorechaind query qca config

Prin JSON-RPC:

Încă nu este servit: nicio versiune de nod lansată nu servește namespace-ul JSON-RPC qor_, așa că acest apel returnează -32601 (method not found) pe toate endpoint-urile publice astăzi. Vezi namespace-ul qor_.

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

Curba de Bonding​

Design, încă neactiv

Curba de bonding este implementată în x/qca, dar nu este încă conectată la distribuirea recompenselor; recompensele de staking urmează astăzi modulul standard de distribuție. Formula de mai jos este designul.

Recompensa de staking pentru un validator este concepută să fie determinată de o curbă de bonding care încorporează mai mulți factori:

R = beta * S * (1 + alpha * log(1 + L)) * Q(r) * P(t)
VariabilăDescriere
RSuma recompensei
betaRata de bază a recompensei
SStake efectiv
alphaConstanta de scalare a loialității
LDurata loialității (timpul de staking continuu)
Q(r)Factorul de calitate al reputației, interval [0.75 - 1.25]
P(t)Multiplicatorul fazei protocolului (se ajustează pe parcursul ciclului de viață al rețelei)

Concluzii-cheie:

  • Bonusul pentru durata loialității: designul adaugă un termen logaritmic pentru timpul de staking continuu.
  • Factorul de calitate al reputației: Variază de la 0.75 (reputație slabă) la 1.25 (reputație excelentă). Ponderile formulei de reputație sunt on-chain (qorechaind query reputation params).
  • Multiplicatorul fazei protocolului: Se ajustează pe măsură ce rețeaua se maturizează prin diferite faze (bootstrap, creștere, maturitate).

Slashing​

Penalizările de bază pentru încălcări, interogabile live și valabile la momentul redactării:

qorechaind query slashing params
ParametruValoare
Fereastra de blocuri semnate10.000 de blocuri (aproximativ 8,7 ore pe mainnet la 3,1 s per bloc; mai puțin pe testnet)
Minim semnat per fereastră5% (min_signed_per_window = 0.05): un validator este băgat la închisoare (jailed) când semnează mai puțin de 5% din ultimele 10.000 de blocuri, adică atunci când ratează mai mult de 95%
Durata de închisoare (jail) pentru downtime600 de secunde (10 minute)
Fracțiunea de slash pentru downtime1% din stake
Fracțiunea de slash pentru double-sign5% din stake

Băgarea la închisoare (jailing) este un timeout fix de 10 minute cu o penalizare fixă. Unbonding-ul durează 21 de zile (1.814.400 s), setul activ conține cel mult 100 de validatori (max_validators), iar fiecare delegator poate avea cel mult 7 intrări de unbonding (max_entries). Modelul progresiv de mai jos este un design separat, care ar adăuga peste acestea consecințe suplimentare, escaladate, pentru încălcările repetate; nu este încă conectat.

Slashing Progresiv​

Design, încă neactiv

Slashing-ul progresiv este implementat în x/qca, dar nu este conectat la slashing: penalizările în vigoare sunt valorile standard x/slashing din tabelul de mai sus. Parametrii de mai jos reprezintă designul (qorechaind query qca config).

Designul de slashing progresiv escaladează penalizările pentru cei care încalcă regulile în mod repetat, permițând în același timp validatorilor să își revină în timp:

penalty = base_rate * escalation^effective_count * severity
ParametruValoare
Penalizare maximă per eveniment33% din stake
Timp de înjumătățire (decay)100.000 blocuri
Severitate downtime1.0
Severitate double-sign2.0
Severitate atac light client3.0
  1. Fiecare încălcare incrementează numărul efectiv. Fiecare încălcare (downtime, double-signing etc.) crește numărul efectiv al validatorului, ceea ce afectează penalizările viitoare.

  2. Penalizarea escaladează exponențial. Penalizarea escaladează în funcție de numărul efectiv, conform formulei de mai sus, astfel încât cei care încalcă regulile în mod repetat se confruntă cu penalizări mult mai mari.

  3. Numărul efectiv scade în timp. Numărul efectiv scade cu un timp de înjumătățire de 100.000 de blocuri (aproximativ 3,6 zile la blocurile de 3,1 s ale mainnet-ului), permițând validatorilor să își revină după o perioadă de comportament corect.

  4. Evenimente singulare versus încălcări repetate. Un singur eveniment accidental de downtime are ca rezultat o penalizare minoră, în timp ce încălcările repetate declanșează consecințe cu creștere exponențială.


Înregistrarea Cheii PQC​

Înregistrează-ți cheia publică criptografică post-cuantică (PQC) (ML-DSA-87) înainte de a rula create-validator, și cât mai devreme: panoul Validator Readiness o verifică din momentul în care aplici. Acest lucru nu este opțional și nu este automat: chain-ul impune o semnătură hibridă PQC pe fiecare tranzacție de pe lane-ul Cosmos, MsgCreateValidator nu se numără printre tipurile de mesaje exceptate, iar niciun cont nu își înregistrează cheia automat: înregistrarea este o tranzacție explicită pe care fiecare cont (inclusiv operatorii de validatori) trebuie să o trimită el însuși, din timp. Generează mai întâi cheia:

qorechaind tx pqc gen-key mypqc # prints the public key (hex); stored unencrypted under ~/.qorechaind/pqc/
qorechaind tx pqc register-key-v2 dilithium5 <pubkey-hex> hybrid \
--from mykey \
--pqc-key mypqc \
--chain-id qorechain-vladi \
--gas 600000 --fees 60000uqor \
-y

--pqc-key mypqc atașează o dovadă de posesie (proof of possession): cheia semnează qorechain-pqc-pop-v1|chainid|algo|address|hex(pubkey), iar chain-ul o verifică, astfel încât nimeni nu poate înregistra o cheie publică a cărei jumătăți private nu o deține. În v3.2.3 este opțională și recomandată. Începând cu v3.2.4 (mainnet din 23 octombrie 2026, testnet din 19 octombrie 2026), înregistrarea contului raportează și dacă o dovadă a fost verificată (possession_proven, în GET /qorechain/pqc/v1/account/{address}).

Ce a schimbat v3.2.3 la înregistrarea cheilor
  • Un cont fără cheie înregistrată poate trimite doar înregistrarea însăși: orice altă tranzacție care poartă o extensie de semnătură hibridă este refuzată. Înregistrează mai întâi cheia, apoi semnează tot restul cu tx pqc cosign.
  • Cheile classical_only, goale și degenerate sunt refuzate la înregistrare.
  • Odată ce un cont deține o cheie, întreținerea ulterioară a cheii (rotație, migrare, reînregistrare) trebuie să fie ea însăși semnată hibrid și nu poate fi trimisă prin authz.
  • tx pqc gen-key nu suprascrie niciodată un fișier de cheie existent.
ParametruDescriere
dilithium5Algoritm (ML-DSA-87)
<pubkey-hex>Cheie publică ML-DSA-87 de 2592 de bytes, codificată hex
hybridTipul cheii (hybrid = atât clasic, cât și PQC)

(qorechaind tx pqc register-key <pubkey-hex> hybrid este forma legacy echivalentă pentru Dilithium-5.)

Setează --gas explicit

Cheia publică ML-DSA-87 are 2.592 de bytes, iar scrierea ei on-chain poate depăși limita implicită de gas de 200.000 (înregistrările pe mainnet au folosit între 220.000 și 350.000 de gas). Fără --gas 600000 (sau mai mult), tranzacția poate eșua cu o eroare opacă out of gas. Comisionul trebuie să fie cel puțin limita de gas înmulțită cu 0,1 uqor, deci --gas 600000 necesită --fees 60000uqor sau mai mult.

Verifică înregistrarea:

qorechaind query pqc account <account-address>

Fișierul de cheie din ~/.qorechaind/pqc/ este cheia de semnare post-cuantică a contului: fă-i backup ca la mnemonic și ține-l, pe cât posibil, departe de mașina care rulează cheia de consens. Vezi Semnarea Post-Cuantică pentru recuperare și rotație.


Monitorizare​

Metrici Prometheus​

QoreChain expune metrici Prometheus pe portul 26660:

http://localhost:26660/metrics

Activează endpoint-ul cu prometheus = true în secțiunea [instrumentation] din config.toml. Nodul expune metricile standard ale motorului de consens (înălțimea blocului, rundele de consens, setul de validatori, peer-i, mempool); vezi ce servește nodul tău cu curl -s localhost:26660/metrics | grep -i -E 'height|validator|peers|mempool'. Sănătatea semnării per validator se citește cel mai fiabil chiar din chain (vezi Verificările de sănătate de mai jos), deoarece evidența proprie a chain-ului este cea care decide închisoarea (jailing).

Interogarea Parametrilor de Reputație​

# Formula weights only (there is no per-validator score query)
qorechaind query reputation params

Prin JSON-RPC:

Încă nu este servit: nicio versiune de nod lansată nu servește namespace-ul JSON-RPC qor_, așa că acest apel returnează -32601 (method not found) pe toate endpoint-urile publice astăzi. Vezi namespace-ul qor_.

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

Verificări de sănătate (Health Checks)​

# Node status
qorechaind status | jq '.sync_info'

# Validator signing info (uptime, missed blocks)
qorechaind query slashing signing-info $(qorechaind comet show-validator)

# Check if your validator is in the active set
qorechaind query staking validators --status BOND_STATUS_BONDED | grep "my-validator"

Bune Practici Operaționale​

  1. Folosește o arhitectură cu noduri sentinel (sentry node). Rulează-ți validatorul în spatele nodurilor sentinel pentru a-l proteja de atacurile DDoS. Expune public doar nodurile sentinel.

  2. Configurează alertare. Configurează alerte pentru blocuri ratate, uptime scăzut și reporniri neașteptate. Câteva blocuri ratate sunt normale; ratările susținute vor declanșa slashing.

  3. Menține un uptime ridicat. Downtime-ul susținut duce la băgarea validatorului la închisoare (mai puțin de 5% din ultimele 10.000 de blocuri semnate) și la slashing; vezi Slashing.

  4. Menține software-ul actualizat. Urmărește lansările QoreChain și aplică actualizările prompt. Coordonează-te cu comunitatea de validatori pentru upgrade-urile de chain.

  5. Asigură-ți cheile. Protejează cheia de consens a validatorului (priv_validator_key.json) și ține backup-urile offline; ia în considerare un semnatar la distanță (remote signer). Semnarea la distanță (priv_validator_laddr) nu a fost verificată cu binarul de release qorechaind, iar modulul post-cuantic nu schimbă tipul cheii de consens (ed25519), așa că testează orice configurare de semnatar pe testnet înainte să te bazezi pe ea. Ține cheile contului de operator și fișierul său de cheie PQC departe, pe cât posibil, de mașina care rulează validatorul.

  6. Înregistrează mai întâi o cheie PQC. Contul operatorului are nevoie de o cheie ML-DSA-87 înregistrată înainte de a putea crea un validator sau de a trimite orice altă tranzacție pe lane-ul Cosmos.

  7. Ține ceasul sincronizat. Rulează un client NTP; începând cu v3.2.1 nodul se oprește dacă ceasul lui deviază cu mai mult de 60 de secunde.


Referință Comenzi Validator​

# Edit validator metadata
qorechaind tx staking edit-validator \
--new-moniker "new-name" \
--website "https://myvalidator.com" \
--details "Description of my validator" \
--from mykey --gas 400000 --fees 40000uqor --generate-only > tx.json

# Unjail after downtime slashing
qorechaind tx slashing unjail --from mykey --gas 300000 --fees 30000uqor --generate-only > tx.json

# Delegate additional stake
qorechaind tx staking delegate $(qorechaind keys show mykey --bech val -a) \
500000000uqor --from mykey --gas 400000 --fees 40000uqor --generate-only > tx.json

# Withdraw rewards and commission
qorechaind tx distribution withdraw-rewards $(qorechaind keys show mykey --bech val -a) \
--commission --from mykey --gas 400000 --fees 40000uqor --generate-only > tx.json

# Sign and broadcast any of the above (hybrid signature):
qorechaind tx pqc cosign tx.json --from mykey --pqc-key mypqc --chain-id qorechain-vladi

Pragul minim de comision al rețelei este de 0,1 uqor per unitate de gas. Un cont de operator care nu are o cheie PQC înregistrată poate totuși trimite unjail în mod clasic; odată ce o cheie este înregistrată, fiecare tranzacție (inclusiv unjail) are nevoie de semnătura hibridă.


Validarea Rețelelor Conectate​

Nicio rețea conectată nu este activă încă

Modulul bridge este implementat pe mainnet și pe testnet, dar nicio rută bridge nu este activă: toate cele 37 de configurații de chain au statusul pending, nu este înregistrat niciun validator bridge, nicio operațiune bridge nu a fost creată vreodată și nu este deschis niciun canal IBC pe mainnet (testnet-ul are un canal de transfer, care nu este o rută bridge). Framework-ul de mai jos descrie designul; astăzi nu există nimic de validat pe o rețea conectată.

Designul (începând cu versiunea de chain v3.1.80) permite unui validator QoreChain să ajute și la validarea rețelelor conectate prin bridge. Este condiționat de licență și opțional:

  1. Deții licența. Validatorul trebuie să dețină o licență activă validator_<chain> (sau qcb_bridge) pentru rețeaua țintă. Orchestratorul refuză să pornească un client extern fără aceasta (fail-closed).
  2. Activarea provizionează automat clientul. Când licența este activată, QoreChain provizionează clientul rețelei corespunzătoare pe nodul tău — descărcând clientul fixat (pinned), generând configurația acestuia și rulându-l sub orchestrarea QoreChain. Nimic nu este descărcat înainte de activare.
  3. Furnizează cheile și stake-ul rețelei respective. Cheile de validator/stake și cheile de semnare ale rețelei externe sunt furnizate de operator pentru fiecare rețea; QoreChain oferă framework-ul de driver și poarta de licență impusă (enforced), nu stake-ul tău pe chain-ul extern.

Există drivere pentru toate cele 37 de rețele bridge, clasificate în funcție de modul în care poate participa un validator:

ClasăParticipareExemple
Validator fără permisiune (permissionless)Face stake și ruleazăSolana, Ethereum, Avalanche, Sui, Aptos, Cardano, Tezos, Algorand, Starknet
Plafonat / ales / cu admitereFace stake, condiționat de un plafon sau de o alegereBSC, Polygon, Polkadot, TRON, Sei, Injective, NEAR, Hedera
Nod complet L2Rulează un nod complet (fără staking)Optimism, Base, zkSync Era, Linea, Scroll, Arbitrum
Fără staking / listă de încredereObservă / participă fără stakingBitcoin, Filecoin, XRPL, Stellar
notă

Fixările (pin-urile) de versiune ale clienților sunt best-effort; verifică lansarea clientului upstream pentru rețeaua ta țintă înainte de o activare în producție.

Pașii Următori​