Pour commencer: exécuter un nœud Avalanche

Le moyen le plus rapide d'en savoir plus sur Avalanche est d'exécuter un nœud et d'interagir avec le réseau.

Dans ce tutoriel (durée estimée: 10 minutes), nous allons:

  • Installer et lancer un noeud Avalanche

  • Nous connecter à Avalanche

  • Envoyer des AVAX

  • Ajoutez votre nœud à l'ensemble de validateurs

Si votre problème n'est pas abordé dans la FAQ, venez demander de l'aide dans le Telegram Avalanche francophone ! Nous travaillerons pour vous aider à surmonter tous les obstacles.

Si vous souhaitez lancer votre nœud sur un VPS et avoir un tutoriel pas-à-pas merci de regarder ce tutoriel:

Exigences

Avalanche est un protocole incroyablement léger, donc les exigences informatiques minimales requises sont assez modestes.

  • Matériel: CPU> 2 GHz, RAM> 4 Go, stockage> 10 Go d'espace libre

  • OS: Ubuntu 18.04/20.04 ou Mac OS X >= Catalina

  • Software: Go >= 1.13

Exécutez go version. Il doit être en version 1,13 ou plus. Exécutez echo $GOPATH. Il ne doit pas être vide.

Ce tutoriel suppose que vous avez suffisamment d'AVAX pour ajouter un validateur sous une phrase clé mnémonique. (2,000 AVAX + frais pour les transactions nécessaires)

Exécutez un nœud Avalanche et envoyez des fonds

Installons AvalancheGo, l'implémentation Go d'un nœud Avalanche, et connectons-nous au Public Testnet d'Avalanche.

Télécharger AvalancheGo

Le nœud est un programme binaire. Vous pouvez soit télécharger le code source puis créer le programme binaire, soit télécharger le binaire pré-construit.

Vous pouvez effectuer l'une des opérations ci-dessous. Vous n’avez pas besoin de faire les deux. Code source ou Binaire.

Code source

Téléchargez le repository AvalancheGo :

go get -v -d github.com/ava-labs/avalanchego/...

Remarque aux utilisateurs avancés: AvalancheGo utilise des modules Go, vous pouvez donc cloner le le repository AvalancheGo vers des emplacements autres que votre GOPATH

Changer le répertoire avalanchego :

cd $GOPATH/src/github.com/ava-labs/avalanchego

Construisez AvalancheGo:

./scripts/build.sh

Le binaire, nommé avalanchego, est en avalanchego/build.

Binaire

Accédez à notre page de versions et sélectionnez la version de votre choix (probablement la dernière).

SousAssets, sélectionnez le fichier approprié.

Pour MacOS : Télécharger : avalanche-osx-<VERSION>.zip unzip avalanche-osx-<VERSION>.zip Le dossier résultantavalanche-<VERSION>, contient les binaires. Vous pouvez exécuter le nœud avec ./avalanche-<VERSION>/avalanchego

Pour Linux : Téléchargez : avalanche-linux-<VERSION>.tar.gz Décompressez : tar -xvf avalanche-linux-<VERSION>.tar.gz Le dossier résultant, avalanche-<VERSION> contient les binaires. Vous pouvez exécuter le nœud avec ./avalanche-<VERSION>/avalanchego

Démarrez un nœud et connectez-vous à Avalanche

Si vous avez construit à partir de la source :

./build/avalanchego

Si vous utilisez les binaires publiés :

./avalanche-<VERSION>/avalanchego

Si vous voulez pouvoir effectuer des appels API vers votre nœud à partir d'autres machines, incluez l'argument --http-host= (par exemple ./build/avalanchego --http-host=)

Vous pouvez utiliser Ctrl + C pour tuer le nœud.

Pour vous connecter à Fuji Testnet à la place, utilisez l'argument --network-id=fuji. Vous pouvez obtenir des fonds sur le Testnet à partir du faucet.

Lorsque le nœud démarre, il doit démarrer (bootstrap - rattraper le reste du réseau). Vous verrez des journaux sur l'amorçage. Lorsqu'une chaîne donnée a terminé le bootstrap, elle imprimera un journal comme celui-ci :

INFO [06-07|19:54:06] <X Chain> /snow/engine/avalanche/transitive.go#80: bootstrapping finished with 1 vertices in the accepted frontier

Pour vérifier si une chaîne donnée est terminée, appelez info.isBootstrapped comme ceci :

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

Si cela renvoietrue, la chaîne est amorcée (boostrapped). Si vous effectuez un appel d'API à une chaîne dont le bootstrap n'est pas terminé, il renverra le message suivant :API call rejected because chain is not done bootstrapping. Si votre nœud ne termine jamais le démarrage/boostrap, suivez cette FAQ, si vous rencontrez toujours des problèmes, veuillez nous contacter sur Telegram.

Créer un utilisateur Keystore

Les nœuds d'avalanche fournissent un keystore intégré. Le Keystore gère les utilisateurs et ressemble beaucoup à un portefeuille. Un utilisateur est une identité protégée par mot de passe qu'un client peut utiliser lorsqu'il interagit avec des blockchains. Vous ne devez créer un utilisateur de keystore que sur un nœud que vous exploitez, car l'opérateur de nœud a accès à votre mot de passe en texte brut. Pour créer un utilisateur, faites un call keystore.createUser:

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

La réponse devrait être :

{
"jsonrpc":"2.0",
"result":{"success":true},
"id":1
}

Maintenant, vous avez un utilisateur sur ce nœud. Les données de Keystore existent au niveau du nœud. Les utilisateurs que vous créez sur le Keystore d’un nœud n’existent pas sur les autres nœuds, mais vous pouvez importer / exporter des utilisateurs vers / depuis le Keystore. Voir l'API Keystore pour voir comment.

Vous ne devez conserver qu'une petite quantité de vos fonds sur votre nœud. La plupart de vos fonds doivent être sécurisés par un mnémonique qui n'est enregistré sur aucun ordinateur.

Créer une adresse

Avalanche est une plateforme de blockchains hétérogènes, dont la X-Chain, qui agit comme une plate-forme décentralisée pour créer et échanger des actifs numériques. Nous allons maintenant créer une adresse pour contenir AVAX sur notre nœud.

Pour créer une nouvelle adresse sur la X-Chain, faites un call avm.createAddress une méthode de l'API de la X-Chain :

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

Si votre nœud n’a pas fini de démarrer, cet appel renverra l’état 503 avec le message suivant : API call rejected because chain is not done bootstrapping

Notez que nous faisons cette demande à 127.0.0.1:9650/ext/bc/X. La partie bc/X signifie que la demande est envoyée à la blockchain dont l'ID (ou l'alias) est X (c'est-à-dire la X-Chain).

La réponse devrait ressembler à ceci :

{
"jsonrpc":"2.0",
"id":2,
"result" :{
"address":"X-avax1xeaj0h9uy7c5jn6fxjp0rg4g39jeh0hl27vf75"
}
}

Votre utilisateur contrôle maintenant l'adresse X-avax1xeaj0h9uy7c5jn6fxjp0rg4g39jeh0hl27vf75 sur la X-Chain. Pour distinguer les adresses sur différentes chaînes, la convention Avalanche veut qu'une adresse inclue l'ID ou l'alias de la chaîne sur laquelle elle existe. Par conséquent, cette adresse commence X-, indiquant qu'elle existe sur la X-Chain.

Envoyez des fonds du portefeuille Avalanche à votre nœud

Remarque: les instructions ci-dessous déplacent des fonds réels.

Transférons les fonds du portefeuille Avalanche vers votre nœud.

Accédez au portefeuille Avalanche. Cliquez sur ACCESS WALLET, puis sur MNEMONIC KEY PRHASE. Entrez votre phrase mnémotechnique.

Click the Send tab on the left. For amount, select, .002 AVAX. Enter the address of your node, then click Confirm.

Cliquez sur l'onglet Send sur la gauche. Pour le montant, sélectionnez .002 AVAX. Saisissez l'adresse de votre nœud, puis cliquez sur Confirm.

Nous pouvons vérifier le solde d'une adresse pour un élément donné en appelant avm.getBalance, une autre méthode de l'API de X-Chain. Vérifions que le transfert a bien été effectué:

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

Notez qu'AVAX a l'ID spécial AVAX. Un ID d'élément est généralement une chaîne alphanumérique.

La réponse doit indiquer que nous avons 2 000 000 nAVAX ou 0,002 AVAX.

{
"jsonrpc":"2.0",
"id" :3,
"result" :{
"balance":2000000,
"utxoIDs": [
{
"txID": "x6vR85YPNRf5phpLAEC7Sd6Tq2PXWRt3AAHAK4BpjxyjRyhtu",
"outputIndex": 0
}
]
}
}

Envoyer des AVAX

Maintenant, envoyons des AVAX en effectuant un appel API à notre nœud:

curl -X POST --data '{
"jsonrpc":"2.0",
"id" :5,
"method" :"avm.send",
"params" :{
"assetID" :"AVAX",
"amount" :1000,
"to" :"X-avax1w4nt49gyv4e99ldqevy50l2kz55y9efghep0cs",
"changeAddr" :"X-avax1turszjwn05lflpewurw96rfrd3h6x8flgs5uf8",
"username" :"YOUR USERNAME HERE",
"password" :"YOUR PASSWORD HERE"
}
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/X

amount spécifie le nombre de nAVAX à envoyer.

Si vous souhaitez spécifier une adresse particulière où le changement doit aller, vous pouvez la spécifier dans changeAddr. Vous pouvez laisser ce champ vide; si vous le faites, toute modification ira à l'une des adresses contrôlées par votre utilisateur.

Afin d'éviter le spam, Avalanche exige le paiement de frais de transaction. Les frais de transaction seront automatiquement déduits d'une adresse contrôlée par votre utilisateur lorsque vous émettez une transaction. Gardez cela à l'esprit lorsque vous vérifiez les soldes ci-dessous.

Lorsque vous envoyez cette demande, le nœud vous authentifiera à l'aide de votre nom d'utilisateur et de votre mot de passe. Ensuite, il examinera toutes les clés privées contrôlées par votre utilisateur jusqu'à ce qu'il trouve suffisamment d'AVAX pour satisfaire la demande.

La réponse contient l'ID de la transaction. Ce sera différent pour chaque invocation send.

{
"jsonrpc":"2.0",
"id" :5,
"result" :{
"txID":"2QouvFWUbjuySRxeX5xMbNCuAaKWfbk5FeEa2JmoF85RKLk2dD",
"changeAddr" :"X-avax1turszjwn05lflpewurw96rfrd3h6x8flgs5uf8"
}
}

Vérification du statut de la transaction

Cette transaction ne prendra qu'une seconde ou deux pour finaliser. Nous pouvons vérifier son statut avec avm.getTxStatus:

curl -X POST --data '{
"jsonrpc":"2.0",
"id" :6,
"method" :"avm.getTxStatus",
"params" :{
"txID":"2QouvFWUbjuySRxeX5xMbNCuAaKWfbk5FeEa2JmoF85RKLk2dD"
}
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/X

La réponse doit indiquer que la transaction a été Accepted:

{
"jsonrpc":"2.0",
"id" :6,
"result" :{
"status":"Accepted"
}
}

You might also see that status is Processing if the network has not yet finalized the transaction.

Vous pouvez également voir que lestatus est en cours de traitement Processingsi le réseau n'a pas encore finalisé la transaction.

Once you see that the transaction is Accepted, check the balance of the to address to see that it has the AVAX we sent:

Une fois que vous voyez que la transaction est acceptéeAccepted, vérifiez le solde de l'adresse to pour voir qu'elle contient l'AVAX que nous avons envoyé:

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

La réponse devrait être :

{
"jsonrpc":"2.0",
"id" :7,
"result" :{
"balance":1000
}
}

IDe la même manière, nous avons pu vérifier X-avax1xeaj0h9uy7c5jn6fxjp0rg4g39jeh0hl27vf75 pour voir que les AVAX que nous avons envoyé a été déduit de son solde, ainsi que les frais de transaction.