Comment rejoindre Avalanche-Everest tesnet

Nous venons de publier la version candidate Everest pour Avalanche, la phase finale des tests avant le mainnet.

Avalanche offre un débit élevé (~ 5000 tps), une finalité rapide (moins de 2 secondes) et une résilience élevée. Dans notre récent incentive testnet, Denali, nous avons eu plus de 1000 validateurs producteurs de blocs participant activement au consensus.

Étape 1 — Installation et lancement d’Avalanche

Le client Gecko d’Avalanche a été testé pour fonctionner avec les systèmes d’exploitation suivants:

• Ubuntu 18.04 and 20.04
• OSX Catalina or higher

Configuration matérielle minimale:

• CPU: 2 GHz
• RAM: 3 Go de RAM
• Storage: 250 Mo de disque dur
• Les binaires ne sont compilés que pour x64, il faut construire soi-même à partir de la source pour le faire fonctionner sur d’autres architectures

Matériel recommandé:

• CPU: > 2 GHz
• RAM: > 3 Go de RAM
• Storage: > 5 Go sur un SSD
• Les binaires ne sont compilés que pour x64, il faut construire soi-même à partir de la source pour le faire fonctionner sur d’autres architectures

Pour les besoins de ce didacticiel, un utilitaire appelé curl est utilisé pour effectuer les appels d’API. Cependant, des options alternatives telles que l’outil Postman sont également couramment utilisées pour effectuer des appels API sur le réseau Avalanche. Bien que ce ne soit pas une exigence de Gecko, il est suggéré d’installer cet utilitaire sur votre système d’exploitation pour suivre le didacticiel textuellement.

• Téléchargez le dernier tar.gz d’Everest (zip pour osx) trouvé ici: https://github.com/ava-labs/gecko/releases
• Décompressez dans un dossier de votre choix:
  * Linux: tar -xvf gecko-linux-<VERSION>.tar.gz
  * OSX: unzip gecko-osx-<VERSION>.zip
• cd gecko-<VERSION>

Une fois que nous avons extrait les fichiers dans un dossier de notre choix, nous aurons simplement besoin d’ouvrir le répertoire dans un terminal de ligne de commande et de taper:

> ./avalanche

Étape 2 — Staking Avalanche

Pour devenir validateur du réseau Avalanche, il faut d’abord stake duAVAX sur la plateforme. Pour Everest, le montant minimum de stake est de 5 000 000 nAVAX (nano-AVAX). Ce montant ne sera pas le même que sur Mainnet, mais nous avons fixé ce seuil à un montant très raisonnable pour inciter autant de passionnés à devenir validateurs.

La plate-forme Avalanche utilise actuellement des primitives RPC de base pour effectuer le travail. Ces types de primitives aident les utilisateurs à créer des transactions, à signer des transactions, à envoyer des transactions et à gérer le nœud. À l’avenir, ces primitives feront l’objet d’une abstraction pour aider pour aider aux tâches de base, mais pour Everest, nous nous assurons que ces blocs de construction fonctionnent comme prévu.

Étape 1 — Créer un utilisateur et des adresses

Pour devenir validateur, un utilisateur doit être créé. L’appel API suivant créera un utilisateur avec le nom d’utilisateur et le mot de passe que nous spécifions.

curl -X POST --data '{
     "jsonrpc": "2.0",
     "id": 1,
     "method": "keystore.createUser",
     "params": {
         "username": "YOUR USERNAME",
         "password": "YOUR PASSWORD"
    }
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/keystore

Maintenant que nous avons un compte, nous devons créer une adresse sur la X-Chain. Cette adresse recevra AVAX du faucet

curl -X POST --data '{
    "jsonrpc":"2.0",
    "id"     :1,
    "method" :"avm.createAddress",
    "params" :{
        "username": "YOUR USERNAME",
        "password": "YOUR PASSWORD"
    }
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/X

Cela renverra une réponse comme suit, qui contient l’adresse que nous venons de créer. Nous devrons noter notre adresse X-Chain car nous l’utiliserons dans les étapes ultérieures.

{
    "jsonrpc": "2.0",
    "result": {
        "address": "YOUR X-CHAIN ADDRESS"
    },
    "id": 1
}

Nous devons également créer une adresse sur la P-Chain en utilisant notre utilisateur.

curl -X POST --data '{
    "jsonrpc": "2.0",
    "method": "platform.createAddress",
    "params": {
        "username": "YOUR USERNAME",
        "password": "YOUR PASSWORD"
    },
    "id": 1
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/P

Cela renvoie le compte P-Chain. Nous devons également noter cela, car nous l’utiliserons dans les étapes ultérieures.

{
    "jsonrpc": "2.0",
    "result": {
        "address": "YOUR P-CHAIN ADDRESS"
    },
    "id": 1
}

Étape 2 — Acquérir des fonds

Bien! Maintenant que nous avons des comptes, mettons des fonds dedans. Pour commencer, nous allons obtenir des fonds de l’Avalanche Testnet Faucet. Nous mettons notre adresse X-Chain dans le formulaire, confirmons que nous sommes humains et demandons 10 000 000 nAVAX (nano-AVAX).

Ces fonds devraient arriver en moins de 2 secondes. Pour vérifier que les fonds sont à notre adresse, appelez la fonction suivante, en remplaçant “YOUR X-CHAIN ADDRESS HERE” par l’adresse X-Chain fournie au faucet.

curl -X POST --data '{
    "jsonrpc":"2.0",
    "id"     :1,
    "method" :"avm.getBalance",
    "params" :{
        "address":"YOUR X-CHAIN ADDRESS HERE",
        "assetID"  :"AVAX"
    }
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/X

Nous verrons la réponse suivante, confirmant que nous avons bien reçu nos AVAX.

{
    "jsonrpc": "2.0",
    "result": {
        "balance": "10000000",
        "utxoIDs": [
            {
                "txID": "ZckGnBciWaRyDXiYcs9igvXjyMZH28cSrDVvpkBteHxhYEA3Z",
                "outputIndex": 0
            }
        ]
    },
    "id": 1
}

Étape 3 — Envoyez-le à la plateforme

Nous sommes financés! Il est maintenant temps d’en faire quelque chose. Pour ce faire, nous allons mettre les AVAX de notre X-Chain sur notre P-Chain. La P-Chain contrôle tous les comptes de staker et les ensembles de validateurs. C’est là que se produit la coordination de la plate-forme et, comme la chaîne X, elle est exécutée par défaut sur tous les nœuds de la plate-forme AVAX.

L’appel API “exportAVAX” lance une procédure sur le nœud local pour signer une transaction qui peut, en une seule étape, transférer des fonds de la X-Chain vers la P-Chain à travers le réseau. Il s’agit d’un échange atomique et chaque nœud l‘effectura. Assurez-vous d’utiliser l’adresse P-Chain créée à l’étape 1, et non l’adresse X-Chain. Nous allons envoyer le montant minimum pour le staking d’Everest — 5 000 000 nAVAX — à la P-Chain afin que nous puissions valider sur le réseau. Nous souhaitons également inclure 2 000 000 nAVAX supplémentaires pour payer 2 frais de transaction — le premier consiste à importer les fonds dans la P-Chain et le second à ajouter notre nœud en tant que validateur.

curl -X POST --data '{
    "jsonrpc":"2.0",
    "id"     :1,
    "method" :"avm.exportAVAX",
    "params" :{
        "username": "YOUR USERNAME",
        "password": "YOUR PASSWORD",
        "to":"YOUR PLATFORM ADDRESS HERE",
        "amount": 7000000
    }
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/X

Cela renverra un TxID dans la réponse. Nous n’avons pas besoin de conserver ce TxID, il peut être ignoré.

L’étape suivante consiste à accepter ce transfert sur la P-Chain. Pour ce faire, nous devons passer notre adresse P-Chain à la méthode “importAVAX” sur la P-Chain. Nous transmettons également une “sourceChain” qui est l’ID ou l’alias de la chaîne à partir de laquelle l’AVAX est importé. Pour importer des fonds de la X-Chain, utilisez"X".

curl -X POST --data '{
    "jsonrpc": "2.0",
    "method": "platform.importAVAX",
    "params": {
        "username": "YOUR USERNAME",
        "password": "YOUR PASSWORD",
        "to":"YOUR PLATFORM ADDRESS HERE",
        "sourceChain": "X"    
},
    "id": 1
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/P

Cela renverra un TxID dans la réponse. Nous n’avons pas besoin de conserver ce TxID, il peut être ignoré.

Ça devrait être ça! La P-Chain doit disposer de fonds suffisants pour stake et participer en tant que validateur au réseau de test Everest. Pour vérifier, nous faisons un appelgetBalance sur la P-Chain et vérifions le solde.

curl -X POST --data '{
    "jsonrpc": "2.0",
    "method": "platform.getBalance",
    "params":{
        "address":"YOUR PLATFORM ADDRESS HERE"
    },
    "id": 1
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/P

Étape 3 — Validation

Succès! Maintenant que nous avons des fonds sur la P-Chain, nous sommes prêts à nous inscrire pour devenir validateur sur le réseau. Chaque nœud a un “nodeID” qui est utilisé pour identifier de manière unique le nœud sur le réseau. Pour devenir validateur, nous devons valider ce nodeID comme étant le nœud qui effectue le travail. La première chose à faire est d’obtenir notre nodeID et de le noter afin que nous puissions l’utiliser plus tard.

curl -X POST --data '{
    "jsonrpc": "2.0",
    "method": "info.getNodeID",
    "params":{},
    "id": 1
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/info

L’étape suivante consiste à créer une transaction qui ajoute notre nodeID au réseau. Dans l’exemple ci-dessous, nous mettons une heure de début de 15 minutes à partir de maintenant, et nous terminons le 15 août 2021.

• Remarque: sous OSX, vous devez utiliser “$ (gdate” au lieu de “$ (date”. Si vous n’avez pas installé “gdate”, exécutez “brew install coreutils” dans votre terminal.

curl -X POST --data '{
    "jsonrpc": "2.0",
    "method": "platform.addDefaultSubnetValidator",
    "params": {
        "username":"YOUR USERNAME HERE",
        "password":"YOUR PASSWORD HERE",
        "nodeID":"YOUR NODEID HERE",
        "rewardAddress":"YOUR PLATFORM ADDRESS HERE",
        "startTime":'$(date --date="15 minutes" +%s)',
        "endTime":1629032852,
        "stakeAmount":5000000,
        "delegationFeeRate":0
    },
    "id": 1
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/P

Cela renverra un TxID dans la réponse. Nous n’avons pas besoin de conserver ce TxID, il peut être ignoré. Et ça devrait être bon! Nous devrions nous retrouver dans la liste des validateurs en attente maintenant, et dans 15 minutes nous serons dans la liste des validateurs actuels!

curl -X POST --data '{
    "jsonrpc": "2.0",
    "method": "platform.getPendingValidators",
    "params": {},
    "id": 4
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/P
curl -X POST --data '{
    "jsonrpc": "2.0",
    "method": "platform.getCurrentValidators",
    "params": {},
    "id": 1
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/P

Outils disponibles

Maintenant que nous avons un nœud configuré localement, n’hésitez pas à consulter les autres outils et ressources disponibles pour Avalanche.

* Avalanche Explorer
* Avalanche Test Faucet
* Avalanche Wallet
* Avalanche Documentation
* GitHub

Amusez-vous et faut nous savoir si vous avez besoin d’assistance sur le channel francophone!

À propos d’Avalanche :

Avalanche est une plateforme open-source permettant de lancer des applications financières décentralisées et des déploiements de blockchain d’entreprise dans un écosystème interopérable et hautement évolutif. Les développeurs qui se servent d’Avalanche peuvent facilement créer des applications puissantes, fiables et sécurisées et des réseaux blockchain personnalisées avec des ensembles de règles complexes ou s’appuyer sur des sous-réseaux privés ou publics existants.

Telegram Francophone | Twitter Francophone |Site Web |Papier blanc | Twitter | Discord | GitHub | Documentation | Explorer | Avalanche-X | Telegram | Facebook | LinkedIn | Reddit | YouTube