Exécuter un nœud

Ce guide couvre l'exécution d'un déploiement QoreChain nœud seul — un nœud complet ou RPC qui synchronise la chaîne et expose des points de terminaison pour l'intégration, sans fonctions de validateur. Il s'adresse aux plateformes d'échange (CEX), aux backends de portefeuilles, aux indexeurs et aux intégrateurs qui ont besoin d'un accès fiable en lecture/écriture au réseau mais qui ne signent pas de blocs.

remarque

Pour la production de blocs, le staking, le slashing et la classification des pools, consultez plutôt Exécuter un validateur. Un déploiement nœud seul ne détient jamais de clé de consensus de validateur et n'apparaît jamais dans l'ensemble actif.

attention

Les binaires, le genesis et les snapshots sont publiés sur download.qore.host avec des sommes de contrôle SHA-256. Vérifiez toujours les sommes de contrôle avant d'installer ou d'extraire, et vérifiez les dépôts uniquement auprès de votre propre nœud synchronisé.

Nœud vs validateur

Aspect	Nœud seul (ce guide)	Validateur
Clé de consensus	Aucune	Clé de consensus ed25519 (à sécuriser)
Production de blocs	Non	Oui — propose et signe des blocs
Staking / slashing	Sans objet	Auto-délégation, risque de slashing
Objectif principal	Servir RPC/REST/gRPC/EVM/SVM aux intégrations	Sécuriser le réseau, gagner des récompenses
Exposition publique	Points de terminaison RPC/EVM généralement exposés	Validateur caché derrière des nœuds sentinelles

Réseaux cibles

Réseau	Chain ID	Chain ID EVM	Remarques
Mainnet	`qorechain-vladi`	`9801` (hex `0x2649`)	Principal — en production depuis le 7 juin 2026
Testnet	`qorechain-diana`	`9800`	Répétez d'abord vos intégrations ici

Remplacez le --chain-id par celui de votre réseau cible tout au long de ce guide. Les exemples utilisent le mainnet par défaut.

Matériel recommandé

Profil	CPU	RAM	Disque (SSD NVMe)	Réseau
Nœud RPC élagué	4 cœurs	16 GB	500 GB+	100 Mbps+
Nœud complet/archive	8 cœurs	32 GB	2 TB+ (croît avec le temps)	1 Gbps
Intégration d'échange	8 cœurs	32 GB	2 TB+ avec marge	1 Gbps

Un SSD NVMe est fortement recommandé — l'état de la chaîne et les magasins EVM/SVM sont intensifs en E/S. Les nœuds d'archive (sans élagage, indexation complète des transactions) croissent en continu ; provisionnez le disque avec de la marge et une supervision.

Déploiement

Docker Compose

Un déploiement nœud seul avec Docker Compose. Épinglez le tag de l'image sur la version en production de la chaîne (v3.1.85 sur le mainnet) et montez un volume persistant pour les données de la chaîne.

# docker-compose.yml
services:
  qorechain-node:
    image: qorechain/qorechaind:v3.1.85
    container_name: qorechain-node
    restart: unless-stopped
    command: ["start", "--home", "/root/.qorechaind"]
    volumes:
      - qorechain-data:/root/.qorechaind
    ports:
      - "26657:26657"   # RPC
      - "26656:26656"   # P2P
      - "1317:1317"     # REST
      - "9090:9090"     # gRPC
      - "8545:8545"     # EVM JSON-RPC
      - "8546:8546"     # EVM WebSocket
      - "8899:8899"     # SVM RPC
      - "26660:26660"   # Prometheus

volumes:
  qorechain-data:

Initialisez le répertoire de données une fois (le genesis et la configuration des pairs sont couverts ci-dessous), puis démarrez :

docker compose up -d
docker compose logs -f qorechain-node

systemd

Pour une installation bare-metal, exécutez qorechaind sous systemd :

# /etc/systemd/system/qorechaind.service
[Unit]
Description=QoreChain node
After=network-online.target
Wants=network-online.target

[Service]
User=qorechain
ExecStart=/usr/local/bin/qorechaind start --home /var/lib/qorechaind
Restart=on-failure
RestartSec=5
LimitNOFILE=65535

[Install]
WantedBy=multi-user.target

sudo systemctl daemon-reload
sudo systemctl enable --now qorechaind
sudo journalctl -u qorechaind -f

Rejoindre le réseau

1. Initialiser

qorechaind init my-node --chain-id qorechain-vladi

2. Télécharger et vérifier le genesis

curl -fsSL https://download.qore.host/genesis.json -o ~/.qorechaind/config/genesis.json

# Cross-verify against the genesis served live by the chain:
curl -s https://rpc.qore.host/genesis | jq '.result.genesis' > /tmp/genesis-live.json

3. Configurer les pairs et le plancher de frais

Ouvrez ~/.qorechaind/config/config.toml et définissez les pairs sentinelles publics du mainnet :

persistent_peers = "0c9b83801ad519671daf19387b6635f72cb9ddd3@44.200.237.4:26656,83cab9ae05d17073c4e45c25d2422b25fff71fe7@35.174.136.254:26656"

Puis définissez le prix minimum du gas dans ~/.qorechaind/config/app.toml (plancher de frais du réseau : 0.1uqor) :

minimum-gas-prices = "0.1uqor"

4. Démarrer la synchronisation

qorechaind start --minimum-gas-prices=0.1uqor

Amorçage rapide

La synchronisation depuis le genesis peut prendre beaucoup de temps. Pour les intégrations, utilisez le state sync ou un snapshot pour un démarrage à froid rapide.

State sync

Le state sync récupère un snapshot récent de l'état de l'application depuis des serveurs RPC de confiance au lieu de rejouer chaque bloc. Configurez la section [statesync] dans config.toml :

[statesync]
enable = true
rpc_servers = "https://rpc.qore.host:443,https://rpc.qore.host:443"
trust_height = <TRUSTED_BLOCK_HEIGHT>
trust_hash = "<TRUSTED_BLOCK_HASH>"
trust_period = "168h0m0s"

Déterminez une hauteur et un hash de confiance récents depuis le RPC public :

curl -s https://rpc.qore.host/block | jq -r '.result.block.header.height, .result.block_id.hash'

Restauration depuis un snapshot

Vous pouvez aussi télécharger le snapshot publié des données de la chaîne, vérifier sa somme de contrôle et l'extraire par-dessus votre répertoire de données :

curl -fsSL https://download.qore.host/qore-vladi-snapshot-90833.tar.gz -o snapshot.tar.gz
sha256sum snapshot.tar.gz
# ebe469796ad96e692877846c7bfd8513d773321c77e415b1358790b7c4e53396

tar xzf snapshot.tar.gz -C ~/.qorechaind/
qorechaind start --minimum-gas-prices=0.1uqor

remarque

Les snapshots sont publiés sous des noms de fichiers estampillés par hauteur de bloc — consultez download.qore.host pour le snapshot le plus récent et sa somme de contrôle SHA-256, et vérifiez toujours avant d'extraire.

Élagage et indexation

Ajustez l'élagage et l'indexation des transactions selon votre intégration. Les plateformes d'échange qui ont besoin de l'historique complet des transactions doivent fonctionner avec un élagage minimal et un indexeur de transactions activé.

Élagage (`app.toml`)

# Keep recent state only — smallest disk footprint
pruning = "default"

# Keep everything — required for archive / full historical queries
# pruning = "nothing"

`pruning`	Comportement	Cas d'usage
`default`	Conserve l'état récent, élague le reste	Nœud RPC, consultations de soldes/état
`nothing`	Conserve tout l'état historique	Nœud d'archive, historique complet
`custom`	Valeurs keep/interval définies par l'opérateur	Rétention personnalisée

Indexation des transactions (`config.toml`)

[tx_index]
indexer = "kv"

Définissez indexer = "kv" (ou un indexeur plus riche) pour que les transactions soient interrogeables par hash et par événement — essentiel pour les plateformes d'échange qui rapprochent dépôts et retraits. Ne définissez indexer = "null" que si vous n'avez pas besoin de requêtes sur l'historique des transactions.

Exposer des points de terminaison pour l'intégration

Activez et liez les serveurs d'API dont les intégrateurs ont besoin dans app.toml :

[api]
enable = true
address = "tcp://0.0.0.0:1317"

[grpc]
enable = true
address = "0.0.0.0:9090"

[json-rpc]
enable = true
address = "0.0.0.0:8545"
ws-address = "0.0.0.0:8546"
api = "eth,net,web3,qor"

Et l'écouteur RPC dans config.toml :

[rpc]
laddr = "tcp://0.0.0.0:26657"

Point de terminaison	Port	Usage
RPC	`26657`	Diffusion des transactions, interrogation des blocs/statut
REST	`1317`	Requêtes HTTP de l'état de la chaîne
gRPC	`9090`	Accès programmatique à haut débit
EVM JSON-RPC	`8545`	Intégrations compatibles Ethereum (chain ID `9801`)
EVM WS	`8546`	Abonnements aux événements EVM
SVM RPC	`8899`	Intégrations compatibles Solana

attention

N'exposez jamais le RPC, l'EVM JSON-RPC ou le gRPC directement sur l'internet public sans reverse proxy, limitation de débit, authentification et pare-feu. Ne liez sur 0.0.0.0 que derrière une couche d'entrée contrôlée.

Santé et suivi de la synchronisation

État de synchronisation

curl -s localhost:26657/status | jq '.result.sync_info.catching_up'

true — synchronisation toujours en cours.
false — entièrement synchronisé et servant l'état courant.

# Latest height and network
curl -s localhost:26657/status | jq '.result.sync_info.latest_block_height, .result.node_info.network'

Le champ network doit indiquer qorechain-vladi (mainnet) ou qorechain-diana (testnet).

Prometheus et Grafana

QoreChain expose des métriques Prometheus sur le port 26660 :

http://localhost:26660/metrics

Collectez-les avec n'importe quel collecteur compatible Prometheus. Si vous exécutez la pile de supervision Docker Compose, Grafana est disponible sur http://localhost:3001 — définissez vos propres identifiants à la première connexion. Suivez le retard de hauteur de bloc, le nombre de pairs et l'utilisation des ressources ; déclenchez une alerte lorsque catching_up reste à true ou que le nombre de pairs tombe à zéro.

Vérification du point de terminaison EVM

curl -s -X POST http://localhost:8545 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_chainId","params":[],"id":1}'
# Expect "0x2649" (9801) on mainnet

Bonnes pratiques opérationnelles

Épinglez la version de la chaîne. Exécutez le tag en production (v3.1.85 sur le mainnet) et suivez les versions officielles pour des mises à niveau coordonnées.
Exécutez des nœuds redondants. Faites fonctionner au moins deux nœuds derrière un répartiteur de charge afin qu'un simple redémarrage ou une resynchronisation n'interrompe pas le trafic d'intégration.
Vérifiez le genesis et les snapshots. Validez toujours le SHA-256 du genesis et la somme de contrôle de tout snapshot par rapport à la version officielle avant de démarrer.
Protégez les points de terminaison publics. Placez RPC/EVM/gRPC derrière un reverse proxy, une limitation de débit et un pare-feu. N'exposez jamais un RPC en écriture non authentifié sur Internet.
Adaptez l'élagage au besoin. Utilisez pruning = "nothing" plus tx_index = "kv" pour les plateformes d'échange qui rapprochent l'historique complet des dépôts/retraits ; utilisez default pour des consultations légères.
Surveillez la synchronisation en continu. Alertez sur le retard de hauteur de bloc, l'absence de pairs et un nœud bloqué en catching_up.

Pour un accès en lecture ultra-léger sans exécuter de nœud complet, consultez la documentation Light Node.

Prochaines étapes

Connexion au mainnet — Genesis du mainnet, pairs et détails de connexion
Exécuter un validateur — Ajouter les fonctions de production de blocs
Compiler depuis les sources — Compiler le binaire qorechaind
Light Node — Accès en lecture seule ultra-léger (documentation à venir)

Nœud vs validateur​

Réseaux cibles​

Matériel recommandé​

Déploiement​

Docker Compose​

systemd​

Rejoindre le réseau​

1. Initialiser​

2. Télécharger et vérifier le genesis​

3. Configurer les pairs et le plancher de frais​

4. Démarrer la synchronisation​

Amorçage rapide​

State sync​

Restauration depuis un snapshot​

Élagage et indexation​

Élagage (app.toml)​

Indexation des transactions (config.toml)​

Exposer des points de terminaison pour l'intégration​

Santé et suivi de la synchronisation​

État de synchronisation​

Prometheus et Grafana​

Vérification du point de terminaison EVM​

Bonnes pratiques opérationnelles​

Prochaines étapes​