Avalanche Francophone
  • Documentation du développeur
  • Apprendre
    • Aperçu de la plateforme
      • Staking
      • Frais de transaction
    • Les bases de la blockchain
    • FAQ
    • Forum
    • Communauté
  • Créer
  • Pour commencer: exécuter un nœud Avalanche
  • Notes de version
    • Alertes par email
    • Notes de mise à jour d'AvalancheGo
    • Notes de mise à jour d'Ortelius
  • Tutoriels
    • Plateforme
      • Créer une nouvelle blockchain
      • Créer un Réseau Local Testnet
      • Créer un sous-réseau (subnet)
      • Créer une Machine Virtuelle (VM)
      • Configurez votre Ledger Nano S avec Avalanche
      • Transférer de l'AVAX entre la X-Chain et la C-Chain
      • Transférer de l'AVAX entre la X-Chain et la P-Chain
    • Nœuds et mise en jeu
      • Ajouter un validateur
      • Maintenir un nœud Avalanche
      • Exécutez un nœud Avalanche et devenez validateur
      • Exécuter un nœud Avalanche avec Oracle VM VirtualBox
      • Exécutez un nœud Avalanche avec un Raspberry Pi 4
      • Exécutez un nœud Avalanche et faites une mise en jeu avec le portefeuille
      • Exécuter un nœud Avalanche avec OVH
      • Exécuter un nœud Avalanche avec Amazon Web Services (AWS)
      • Exécuter un nœud Avalanche avec Microsoft Azure
      • Exécuter un nœud Avalanche sous Linux à l'aide du script d'installation
      • Configuration du monitoring des nœuds
      • Mise en jeu d'AVAX, en validant ou délégant via le portefeuille Avalanche
      • Déléguer à un nœud
      • Sécurisation d'un serveur VPS
      • Mettez à niveau votre nœud AvalancheGo
    • Contrats intelligents
      • Déployer un contrat intelligent en utilisant Remix et MetaMask
      • Utilisation de Truffle avec la C-Chain d'Avalanche
    • Actifs Numériques Intelligents
      • Créer un token ERC-20
      • Créer un actif à capitalisation fixe
      • Créer un actif à capitalisation variable
      • Création d'un NFT - Partie 1
      • Créez des NFT avec le portefeuille Avalanche
      • Utilisez les Wrapped AVAX (WAVAX) sur Avalanche
  • AvalancheGo APIs
    • Émettre des appels d'API
    • Platform API (P-Chain)
    • EVM API (C-Chain)
    • AVM API (X-Chain)
    • Appels d'API obsolètes
    • API Admin
    • API Auth
    • API Health
    • API Info
    • API IPC
    • API Keystore
    • API Metrics
    • API Timestamp
  • Outils
    • AvalancheJS
      • Créer un actif sur la X-Chain
      • Management des clés sur la X-Chain
      • Envoyer un actif sur la X-Chain
      • API
    • Avash
    • Ortelius
  • Références
    • AVM Transaction Format
    • Command Line Interface
    • Coreth Atomic Transaction Format
    • Cryptographic Primitives
    • Network Protocol
    • Serialization Primitives
    • Platform Transaction Format
  • Papiers
Propulsé par GitBook
Sur cette page
  • Exigences
  • Exécutez un nœud Avalanche et envoyez des fonds
  • Télécharger AvalancheGo
  • Démarrez un nœud et connectez-vous à Avalanche
  • Créer un utilisateur Keystore
  • Créer une adresse
  • Envoyez des fonds du portefeuille Avalanche à votre nœud
  • Envoyer des AVAX

Cet article vous a-t-il été utile ?

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.

PrécédentCommunautéSuivantNotes de version

Dernière mise à jour il y a 4 ans

Cet article vous a-t-il été utile ?

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 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: >= 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 )

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/...

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

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.

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

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

Créer un utilisateur Keystore

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
}

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.

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.

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.

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

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.

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

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

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

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

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 , si vous rencontrez toujours des problèmes, veuillez nous contacter sur .

Les nœuds d'avalanche fournissent un keystore intégré. Le Keystore gère les utilisateurs et ressemble beaucoup à un . 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 :

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' pour voir comment.

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

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

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 contrôlées par votre utilisateur jusqu'à ce qu'il trouve suffisamment d'AVAX pour satisfaire la demande.

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

Telegram Avalanche francophone !
Go
les transactions nécessaires
repository AvalancheGo
page de versions
faucet
FAQ
Telegram
API Keystore
portefeuille Avalanche
Frais de transaction
clés privées
Ajouter un validateur
Créer un actif à capitalisation fixe
Créer une nouvelle blockchain
Créer un sous-réseau (subnet)
AvalancheGo APIs
Références
portefeuille
API de la X-Chain
info.isBootstrapped
keystore.createUser
avm.createAddress
avm.getTxStatus