Blockchain : Comment installer un nœud validateur Lava Network ?

Lava Network est une infrastructure multi-chaînes que nous avons déjà présenté dans nos colonnes. Cet écosystème dynamique permet à plus de 30 blockchains de couche primaire d’accéder aux meilleurs fournisseurs de données disponibles. Il s’agit donc de la première infrastructure modulaire pour les données blockchains grâce aux spécifications correspondantes.

Le protocole Lava rémunère les nœuds validateurs du réseau, tout comme les fournisseurs de services. N’importe qui peut participer : la première étape est de disposer d’un nœud Lava fonctionnel.

Dans cet article, nous allons détailler la marche à suivre pour déployer un nœud sur le réseau de test, qui est entré dans sa phase 2. Lava repose sur le Cosmos SDK et fonctionne en preuve d’enjeu.

Pour rappel, avant d’entrer dans le vif du sujet, voici un diagramme résumant les interactions coûts/flux entre les différents acteurs du réseau :

Préliminaires

Les participants qui rejoignent le réseau Lava ont pour mission de renforcer sa qualité de service et la disponibilité des données. Il est donc important d’avoir la configuration matérielle nécessaire au bon fonctionnement de votre nœud.

Configuration matérielle des instances

Vous pouvez déployer Lava sur trois types d’instances :

• Un serveur privé virtuel ou service de cloud (option recommandée) ;
• Une instance de calcul partagé comme les EC2 d’AWS ;
• Un ordinateur personnel.

Au niveau du hardware, il faut avoir à l’esprit que la configuration requise augmente avec la croissance du réseau. Voici les pré-requis pour le testnet et le mainnet :

Pour un nœud déployé sur AWS, la configuration sera :

• Minimum Instance Type – c4.xlarge
• Configure storage – GP2 drive

Les informations détaillées sur l’installation et le déploiement d’un nœud Lava via AWS et autres fournisseurs de cloud sont disponibles ici :

https://github.com/waelsy123/lava-net

Système opérationnel

Il faut disposer d’Ubuntu 20 ou plus et donner les permissions sudo à l’instance, qui permettent d’obtenir les privilèges administrateur pour lancer les commandes.

Configuration réseau

Tout trafic sortant doit être autorisé. Au niveau du trafic entrant, il faut ouvrir les ports suivants :

• 1317 pour REST ;
• 26657 pour Tendermint RPC ;
• 26656 pour Cosmos ;
• Pour les fournisseurs, il faut ouvrir les ports 22221, 22231 et 22241.

Installation des binaires

Lava comporte trois fichiers binaires :

• lavad : dédié au mécanisme de consensus, au maintien du nœud, aux fichiers de genèse et à la création et à la gestion des clefs.
• lavap : concerne les services du protocole, les RPC et le serveur badge
• lavavisor : initialisation automatique du fournisseur/consommateur de RPC avec mise à jour et synchronisation de lavap.

Lava nécessite également la version 1.20.3 ou supérieure de Go. Les programmes sont conçus pour les systèmes opérationnels *nix bien qu’il soit possible de les déployer sur d’autres OS (non-recommandé).

Pour installer Go, utiliser la commande suivante :

rm -rf $HOME/go
sudo rm -rf /usr/local/go
cd $HOME
curl https://dl.google.com/go/go1.20.5.linux-amd64.tar.gz | sudo tar -C/usr/local -zxvf -
cat <<'EOF' >>$HOME/.profile
export GOROOT=/usr/local/go
export GOPATH=$HOME/go
export GO111MODULE=on
export PATH=$PATH:/usr/local/go/bin:$HOME/go/bin
EOF
source $HOME/.profile
go version

Les dépendances suivantes sont constitutives du processus d’installation :

make gcc jq unzip coreutils git

Pour les installer, utiliser la commande ci-dessous :

sudo apt update
sudo apt-get install git curl build-essential make jq gcc snapd chrony lz4 tmux unzip bc -y

Il est conseillé d’installer tous les binaires de Lava en une seule fois :

git clone https://github.com/lavanet/lava.git
cd lava
make install-all

git clone https://github.com/lavanet/lava.git
cd lava
make build-all

Tous les binaires seront alors installés dans ./build/ – pour vérifier leur version, utiliser :

lavad version && lavap version

On peut aussi installer les binaires séparément. Exemple avec lavad :

export LAVA_BINARY=lavad
cd || return
rm -rf lava
git clone https://github.com/lavanet/lava
cd lava || return
git checkout v2.1.3
make install
make build

Une fois les fichiers installés, il faut créer un portefeuille Lava.

Création d’un portefeuille

Lava intègre tous les portefeuilles Cosmos existants grâce aux modules bank et account du SDK de Cosmos. Il y a donc plusieurs options, dont :

• Keplr
• Leap
• Le CLI wallet pour les utilisateurs avancés.

Utilisation de Lava avec Keplr

Le portefeuille Keplr (qui intègre les hardware wallets) peut être téléchargé ici : https://www.keplr.app/

Une fois l’extension installée, il faut y accéder puis rafraîchir la page. Le bouton “Add Lava To Kepler” apparaît et il faudra approuver l’action.

Dans les paramètres (settings), il faudra sélectionner « General » puis « Manage Chain Visibility ». Chercher « Lava Testnet », cocher la case puis cliquer sur « Save ».

Le wallet comprendra désormais une adresse Lava à copier dans le presse papier, du type « lava@11223344556677889900aabbccddeeff1122334 ».

Utiliser Lava avec Leap

Le portefeuille Leap est téléchargeable à l’adresse suivante : https://www.leapwallet.io/

Tout comme Keplr, il supporte les hardware wallets. Une fois l’extension installée, il faut effectuer les mêmes opérations : ouvrir l’extension puis rafraîchir la page. Cliquez sur le bouton « Add Lava To Kepler » et sélectionnez « Approve ».

L’adresse du wallet Lava apparaît alors dans l’extension, et peut être copiée dans le presse-papier :

Utiliser Lava avec le client en lignes de commandes

Le portefeuille CLI concerne les utilisateurs expérimentés. Il fournit divers backends et supporte les hardware wallets.

Tout d’abord, il faut choisir son keyring backend. Le keyring contient les paires de clés privées/publiques utilisées pour interagir avec un nœud Lava. La clé privée peut être sauvegardée à différents endroits (les backends) comme un fichier, ou le système de stockage de clés sécurisé par défaut du système opérationnel. Plus d’informations sur les différents keyrings sont disponibles dans la documentation du SDK de Cosmos.

lavad config keyring-backend [os|file|kwallet|pass|test|memory]

Ensuite, il faut ajouter la clé – remplacer $NOM_DU_COMPTE par le nom choisi pour le compte :

current_lavad_binary="$HOME/.lava/cosmovisor/current/bin/lavad"
ACCOUNT_NAME="votre_nom"
$current_lavad_binary keys add $NOM_DU_COMPTE

Bien entendu, la seed doit être stockée en lieu sûr.

Enfin, il faut vérifier que le compte se trouve bien dans la liste des clés :

$current_lavad_binary keys show $NOM_DU_COMPTE
$current_lavad_binary keys list

Restauration d’un compte

Les clés privées s’exportent via la commande suivante :

lavad keys export mykey

Pour restaurer un compte en utilisant la mnémonique :

lavad keys add $NEW_NAME --recover

Vérification :

$current_lavad_binary keys show $ACCOUNT_NAME

Création d’un portefeuille multisignatures Lava avec le CLI

Il faut commencer par importer les clé publiques des différents signataires :

$current_lavad_binary keys add multisig_imported_alice --pubkey  '{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"data1..."}'
$current_lavad_binary keys add multisig_imported_bob --pubkey '{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"data2..."}'

Puis vérifier que les clés ont bien été importées :

$current_lavad_binary keys show wallet_imported

- address: lava@xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx...
  name: wallet_imported
  pubkey: '{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"data..."}'
  type: offline

$current_lavad_binary keys show wallet_generated_keyring

- address: lava@xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx...
  name: wallet_generated_keyring
  pubkey: '{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"data..."}'
  type: local

Ensuite, voici les lignes de commande pour la création du portefeuille multisignatures correspondant aux clés importées :

$current_lavad_binary keys add $NOM_DU_COMPTE_MULTISIG --multisig multisig_imported_alice,multisig_imported_bob --multisig-threshold $THRESHOLD

Le paramètre $THRESHOLD correspond au nombre de signataires requis pour que la signature soit valide.

L’adresse multisignatures publique peut être retrouvée ainsi :

$current_lavad_binary keys show $NOM_DU_COMPTE_MULTISIG

En sortie, un portefeuille multisig 2 sur 3 renverra les données suivantes :

$current_lavad_binary keys add multisig2_of_3 --multisig wallet1,wallet2,wallet3 --multisig-threshold 2

- address: lava@xxxxx...
  name: multisig2_of_3
  pubkey: '{"@type":"/cosmos.crypto.multisig.LegacyAminoPubKey","threshold":2,"public_keys":[{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"data1..."},{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"data2..."},{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"data3..."}]}'
  type: multi

Signature des transactions

Une transaction multi signatures est créée ainsi :

$current_lavad_binary tx bank send $(lavad keys show alice-bob-multisig -a) lava@destination-address 10000000ulava  --generate-only --chain-id lava-testnet-2 > tx_bank.json

Ensuite, chaque signataire doit signer indépendamment la transaction hors-ligne selon le même processus :

lavad tx sign --from $(lavad keys show -a alice-ledger) --multisig lava@multisig-address tx.json --sign-mode amino-json --chain-id lava-testnet-2 >> tx-signed-alice.json

ou

lavad tx sign --from $(lavad keys show -a alice-ledger) --multisig lava@multisig-address tx.json --sign-mode amino-json --chain-id lava-testnet-2 --account-number X --sequence X >> tx-signed-alice.json

Autres portefeuilles

Les utilisateurs avancés désireux d’expérimenter d’autres portefeuilles Cosmos pour utiliser Lava doivent utiliser les paramètres suivants :

• coinType – 118 (standard cosmos wallet type)
• minimal denom – ulava
• prefix – lava@
• coinDecimals – 6
• rpc : https://public-rpc.lavanet.xyz
• rest : https://public-rpc.lavanet.xyz/rest

Tester le portefeuille

Une fois le portefeuille créé, il faut tester son bon fonctionnement en utilisant un faucet pour obtenir des jetons de testnet. On peut ensuite exécuter des transactions entre différents comptes.

Le Discord Faucet de Lava est à privilégier, car il permet de dépenser une plus grande quantité de jetons comparativement au faucet de l’API (qui est pour l’instant à l’arrêt). Le Discord de Lava requiert des procédures de vérification avant de pouvoir y être admis. Un bon usage est le suivant :

• Pas d’usage excessif ou abusif ;
• Ne pas partager ses jetons ou ses accès ;
• Report des problèmes ou des bugs.

Configuration du nœud

Il est possible d’installer et de configurer le nœud en une seule fois en utilisant un script :

wget -O lava.sh https://raw.githubusercontent.com/appieasahbie/lava/main/lava.sh && chmod +x lava.sh && ./lava.sh

Pour une installation manuelle :

export LAVA_BINARY=lavad
cd || return
rm -rf lava
git clone https://github.com/lavanet/lava
cd lava || return
git checkout v2.1.3
make install
make build

Une fois le nœud validateur déployé, il faut lui donner un nom :

MONIKER="NOM_DU_NŒUD_VALIDATEUR"

Initialisation :

lavad init "$NOM_DU_NŒUD_VALIDATEUR" --chain-id=lava-testnet-2

Téléchargement des fichiers de genèse et du carnet d’adresses :

curl -Ls https://snapshots.aknodes.net/snapshots/lava/genesis.json > $HOME/.lava/config/genesis.json

curl -Ls https://snapshots.aknodes.net/snapshots/lava/addrbook.json > $HOME/.lava/config/addrbook.json

Création du service :

sudo tee /etc/systemd/system/lavad.service > /dev/null <<EOF
[Unit]
Description=lavad Daemon
After=network-online.target
[Service]
User=$USER
ExecStart=$(which lavad) start
Restart=always
RestartSec=3
LimitNOFILE=65535
[Install]
WantedBy=multi-user.target
EOF
sudo systemctl daemon-reload
sudo systemctl enable lavad

Téléchargement du snapshot :

lavad tendermint unsafe-reset-all --home $HOME/.lava --keep-addr-book 
curl https://snapshots.aknodes.net/snapshots/lava/snapshot-lava.AKNodes.lz4 | lz4 -dc - | tar -xf - -C $HOME/.lava

Démarrage du nœud Lava :

sudo systemctl restart lavad
journalctl -u lavad -f

Mise à jour automatique de Lavad :

cd $HOME && \
wget -O lavad https://github.com/lavanet/lava/releases/download/v2.1.3/lavad-v2.1.3-linux-amd64 && \
chmod +x $HOME/lavad && \
old_bin_path=$(which lavad) && \
home_path=$HOME && \
rpc_port=$(grep -m 1 -oP '^laddr = "\K[^"]+' "$HOME/.lava/config/config.toml" | cut -d ':' -f 3) && \
tmux new -s lava-upgrade "sudo bash -c 'curl -s https://raw.githubusercontent.com/appieasahbie/testnet-guides/main/utils/autoupgrade/upgrade.sh | bash -s -- -u \"1407000\" -b lavad -n \"$HOME/lavad\" -o \"$old_bin_path\" -h \"$home_path\" -p \"https://api.lava.aknodes.net//cosmos/gov/v1/proposals/207\" -r \"$rpc_port\"'"

Mise à jour de Lavap vers la version 2.0.1 :

wget -O lavap https://github.com/lavanet/lava/releases/download/v2.0.1/lavap-v2.0.1-linux-amd64
chmod +x lavap
mv lavap $(which lavap)
sudo systemctl restart lavap && sudo journalctl -u lavap -f -o cat

Synchronisation

Prise du snapshot (recommandée toutes les 6 heures) :

sudo systemctl stop lavad
cp $HOME/.lava/data/priv_validator_state.json $HOME/.lava/priv_validator_state.json.backup 
lavad tendermint unsafe-reset-all --home $HOME/.lava --keep-addr-book 
curl https://snapshots.aknodes.net/snapshots/lava/snapshot-lava.AKNodes.lz4 | lz4 -dc - | tar -xf - -C $HOME/.lava
mv $HOME/.lava/priv_validator_state.json.backup $HOME/.lava/data/priv_validator_state.json 
sudo systemctl restart lavad
sudo journalctl -u lavad -f --no-hostname -o cat

Synchronisation de l’état :

sudo systemctl stop lavad
cp $HOME/.lava/data/priv_validator_state.json $HOME/.lava/priv_validator_state.json.backup
lavad tendermint unsafe-reset-all --home $HOME/.lava
peers="[email protected]:17656,3693ea5a8a9c0590440a7d6c9a98a022ce3b2455@lava-testnet-peer.itrocket.net:20656,[email protected]:11656,[email protected]:15656,[email protected]:26656"  
SNAP_RPC="https://rpc.lava.aknodes.net:443"
sed -i.bak -e "s/^persistent_peers *=.*/persistent_peers = \"$peers\"/" $HOME/.lava/config/config.toml 
LATEST_HEIGHT=$(curl -s $SNAP_RPC/block | jq -r .result.block.header.height);
BLOCK_HEIGHT=$((LATEST_HEIGHT - 1000));
TRUST_HASH=$(curl -s "$SNAP_RPC/block?height=$BLOCK_HEIGHT" | jq -r .result.block_id.hash) 
echo $LATEST_HEIGHT $BLOCK_HEIGHT $TRUST_HASH && sleep 2
sed -i.bak -E "s|^(enable[[:space:]]+=[[:space:]]+).*$|\1true| ;
s|^(rpc_servers[[:space:]]+=[[:space:]]+).*$|\1\"$SNAP_RPC,$SNAP_RPC\"| ;
s|^(trust_height[[:space:]]+=[[:space:]]+).*$|\1$BLOCK_HEIGHT| ;
s|^(trust_hash[[:space:]]+=[[:space:]]+).*$|\1\"$TRUST_HASH\"| ;
s|^(seeds[[:space:]]+=[[:space:]]+).*$|\1\"\"|" $HOME/.lava/config/config.toml
mv $HOME/.lava/priv_validator_state.json.backup $HOME/.lava/data/priv_validator_state.json
sudo systemctl restart lavad && sudo journalctl -u lavad -f

Commandes utiles pour utiliser Lava

La liste des commandes pour Lava est disponible chez AKNodes :

https://services.aknodes.com/lava/useful-commands

Rejoindre le testnet de Lava en tant que validateur

Ça y est, un fois le nœud déployé, nous pouvons rejoindre le Testnet de Lava et devenir validateur. Les fichiers de configuration sont téléchargeables ainsi :

# Téléchargement de la configuration
git clone https://github.com/lavanet/lava-config.git
cd lava-config/testnet-2
# Lecture de la configuration depuis le fichier
# On peut vérifier la configuration en lisant le fichier correspondant
source setup_config/setup_config.sh

Ensuite, il faut les copier dans le dossier correspondant :

echo "Lava config file path: $lava_config_folder"
mkdir -p $lavad_home_folder
mkdir -p $lava_config_folder
cp default_lavad_config_files/* $lava_config_folder

Puis il faut y placer le fichier de genèse :

# Copy the genesis.json file to the Lava config folder
cp genesis_json/genesis.json $lava_config_folder/genesis.json

Il est conseillé d’utiliser Cosmovisor afin d’automatiser les processus de mise à jour. Pour l’installer :

go install github.com/cosmos/cosmos-sdk/cosmovisor/cmd/[email protected]
# Crée le dossier Cosmovisor et y copie les fichiers de configuration
mkdir -p $lavad_home_folder/cosmovisor/genesis/bin/
# Télécharge les binaires de genèse
wget -O  $lavad_home_folder/cosmovisor/genesis/bin/lavad "https://github.com/lavanet/lava/releases/download/v0.21.1.2/lavad-v0.21.1.2-linux-amd64"
chmod +x $lavad_home_folder/cosmovisor/genesis/bin/lavad

Configuration des variables d’environnement :

echo "# Setup Cosmovisor" >> ~/.profile
echo "export DAEMON_NAME=lavad" >> ~/.profile
echo "export CHAIN_ID=lava-testnet-2" >> ~/.profile
echo "export DAEMON_HOME=$HOME/.lava" >> ~/.profile
echo "export DAEMON_ALLOW_DOWNLOAD_BINARIES=true" >> ~/.profile
echo "export DAEMON_LOG_BUFFER_SIZE=512" >> ~/.profile
echo "export DAEMON_RESTART_AFTER_UPGRADE=true" >> ~/.profile
echo "export UNSAFE_SKIP_BACKUP=true" >> ~/.profile
source ~/.profile

Initialisation de la chaîne :

$lavad_home_folder/cosmovisor/genesis/bin/lavad init \
my-node \
--chain-id lava-testnet-2 \
--home $lavad_home_folder \
--overwrite
cp genesis_json/genesis.json $lava_config_folder/genesis.json

Il ne faut pas se soucier de l’erreur renvoyée par Cosmovisor. Afin de créer le fichier systemd :

echo "[Unit]
Description=Cosmovisor daemon
After=network-online.target
[Service]
Environment="DAEMON_NAME=lavad"
Environment="DAEMON_HOME=${HOME}/.lava"
Environment="DAEMON_RESTART_AFTER_UPGRADE=true"
Environment="DAEMON_ALLOW_DOWNLOAD_BINARIES=true"
Environment="DAEMON_LOG_BUFFER_SIZE=512"
Environment="UNSAFE_SKIP_BACKUP=true"
User=$USER
ExecStart=${HOME}/go/bin/cosmovisor start --home=$lavad_home_folder --p2p.seeds $seed_node
Restart=always
RestartSec=3
LimitNOFILE=infinity
LimitNPROC=infinity
[Install]
WantedBy=multi-user.target
" >cosmovisor.service
sudo mv cosmovisor.service /lib/systemd/system/cosmovisor.service

Enfin, il faut lancer le service. Les commandes suivantes permettent de configurer Cosmovisor pour qu’il se lance au démarrage, et démarrent le service :

sudo systemctl daemon-reload
sudo systemctl enable cosmovisor.service
sudo systemctl restart systemd-journald
sudo systemctl start cosmovisor

Vérifications

Afin de vérifier l’état du service :

sudo systemctl status cosmovisor

Pour accéder aux journaux du service (Ctrl + C pour quitter) :

sudo journalctl -u cosmovisor -f

Vérification du statut du nœud – lavad est désormais localisé sous le chemin d’accès de Cosmovisor :

$HOME/.lava/cosmovisor/current/bin/lavad status | jq .SyncInfo.catching_up

Il est désormais temps de devenir un validateur de Lava Network.

Devenir un nœud validateur Lava

Il faut préalablement financer le compte via faucet comme expliqué dans le chapitre ci-dessus. Ensuite, procéder à la vérification de l’état de la synchronisation du nœud avec le reste du réseau :

$current_lavad_binary status | jq .SyncInfo.catching_up
# Wait until you see the output: "false"

Il faut alors vérifier que le compte a les fonds nécessaires pour participer au processus de validation :

# Vérifier que l'on voit son compte dans la liste des clés
$current_lavad_binary keys list

# Vérifier que le compte comporte des jetons Lava
VOTRE_ADDRESSE=$($current_lavad_binary keys show -a $NOM_DU_COMPTE)
$current_lavad_binary query \
    bank balances \
    $VOTRE_ADDRESSE \
    --denom ulava

De plus, il faut veiller à sauvegarder la clé de consensus du compte validateur. C’est cette clé qui sert à signer les messages, elle est automatiquement générée lors de la première exécution du nœud. Une sauvegarde est nécessaire en cas de migration du nœud ou de perte d’accès. Cette clé est stockée dans un fichier json, situé ici par défaut :

$lavad_home_folder/config/priv_validator_key.json

Pour choisir un chemin d’accès différent, il faut le spécifier dans le paramètre priv_validator_key_file du fichier config.toml.

Il est temps de stake des jetons LAVA sur le réseau. Dans cet exemple, le stake est de 50000000ulava. <<moniker_node>> est à remplacer par le nom choisi pour le validateur comme expliqué dans le chapitre « configuration du nœud ».

$current_lavad_binary tx staking create-validator \
    --amount="50000000ulava" \
    --pubkey=$($current_lavad_binary tendermint show-validator --home "$HOME/.lava/") \
    --moniker="<<moniker_node>>" \
    --chain-id=lava-testnet-2 \
    --commission-rate="0.10" \
    --commission-max-rate="0.20" \
    --commission-max-change-rate="0.01" \
    --min-self-delegation="10000" \
    --gas="auto" \
    --gas-adjustment "1.5" \
    --gas-prices="0.05ulava" \
    --home="$HOME/.lava/" \
    --from=$NOM_DU_COMPTE

Une fois la commande exécutée, la sortie renverra le code 0 en cas de succès. Pour vérifier la configuration du nœud validateur, voici les commandes :

block_time=60
# Vérifie que le nœud validateur est enregistré sur le réseau et qu'il possède un stake
validator_pubkey=$($current_lavad_binary tendermint show-validator | jq .key | tr -d '"')

$current_lavad_binary q staking validators | grep $validator_pubkey

# Vérifie le pouvoir de vote du nœud validateur - il faut environ 30-60 secondes pour que la sortie soit mise à jour
sleep $block_time
$current_lavad_binary status | jq .ValidatorInfo.VotingPower | tr -d '"'
# Output should be > 0

Ça y est, la configuration et le déploiement du nœud validateur est terminée. Voici quelques commandes de base :

• Stopper le nœud Lava :

sudo systemctl stop lava

• Démarrer ou redémarrer le nœud Lava :

sudo systemctl start lava
sudo systemctl restart lava

• Supprimer le nœud :

sudo systemctl disable lava.service
sudo rm /etc/systemd/system/lava.service
sudo systemctl daemon-reload
rm -rf $HOME/.lava 
rm -rf lava
sudo rm -rf $(which lava)

En conclusion

Les validateurs de Lava permettent de sécuriser le réseau, via leur stake, et participent au processus de gouvernance du protocole. Ils sont donc rémunérés par le protocole grâce aux récompenses de bloc et au gas, à hauteur de 98 %. De plus, ils bénéficient de récompenses additionnelles : 4,9 % des souscriptions des consommateurs et des pools RPC incitatifs.

Il est également possible de devenir fournisseur de services, en opérant un nœud RPC. Les deux activités (validateur et fournisseur) peuvent également être menées en parallèle. Nous verrons dans un autre article comme devenir RPC provider pour le réseau Lava.

Si déployer un nœud validateur vous intéresse, il vous faut rejoindre le Discord de Lava Network. Tous les liens utiles sont disponibles ci-dessous :

• Site officiel
• Discord
• X
• Github
• Blog
• Documentation
• Foire aux questions
• Tutoriels