Appendix A: Tutoriel web3.js

Bannière Amazon du livre Maîtriser Ethereum

Descriptif

Ce tutoriel est basé sur [email protected] web3.js . Il est conçu comme une introduction à web3.js.

La bibliothèque JavaScript web3.js est une collection de modules qui contiennent des fonctionnalités spécifiques pour l’écosystème Ethereum, ainsi qu’une API JavaScript compatible Ethereum qui implémente la spécification Generic JSON RPC.

Pour exécuter ce script, vous n’avez pas besoin d’exécuter votre propre nœud local, car il utilise services Infura.

Interaction de base du contrat web3.js de manière non bloquée (asynchrone)

Vérifiez que vous disposez d’une version npm valide :

$ npm -v
5.6.0

Si ce n’est pas le cas, initialisez npm :

$ npm init

Installez les dépendances de base :

$ npm i command-line-args
$ npm i web3
$ npm i node-rest-client-promise

Cela mettra à jour votre fichier de configuration package.json avec vos nouvelles dépendances.

Exécution du script Node.js

Exécution de base :

$ node code/web3js/web3-contract-basic-interaction.js

Utilisez votre propre jeton Infura (enregistrez-vous sur https://infura.io/ et stockez la clé API dans un fichier local appelé infura_token) :

$ node code/web3js/web3-contract-basic-interaction.js \
  --infuraFileToken /path/to/file/with/infura_token

ou:

$ node code/web3js/web3-contract-basic-interaction.js \
  /path/to/file/with/infura_token

Cela lira le fichier avec votre propre jeton et le transmettra comme argument de ligne de commande à la commande réelle.

Examen du script de démonstration

Ensuite, passons en revue notre script de démonstration, web3-contract-basic-interaction.

Nous utilisons l’objet Web3 pour obtenir un fournisseur web3 de base :

var web3 = new Web3(infura_host);

Nous pouvons alors interagir avec web3 et essayer quelques fonctions de base. Voyons la version du protocole :

web3.eth.getProtocolVersion().then(function(protocolVersion) {
      console.log(`Protocol Version: ${protocolVersion}`);
  })

Regardons maintenant le prix actuel du gaz :

web3.eth.getGasPrice().then(function(gasPrice) {
      console.log(`Gas Price: ${gasPrice}`);
  })

Quel est le dernier bloc extrait de la chaîne actuelle ?

web3.eth.getBlockNumber().then(function(blockNumber) {
      console.log(`Block Number: ${blockNumber}`);
  })

Interaction de contrat

Essayons maintenant quelques interactions de base avec un contrat. Pour ces exemples, nous utiliserons le WETH9_ contract sur le testnet Kovan.

Tout d’abord, initialisons notre adresse de contrat :

var our_contract_address = "0xd0A1E359811322d97991E03f863a0C30C2cF029C";

On peut alors regarder son solde :

web3.eth.getBalance(our_contract_address).then(function(balance) {
      console.log(`Balance of ${our_contract_address}: ${balance}`);
})

et voir son code intermédiaire :

web3.eth.getCode(our_contract_address).then(function(code) {
      console.log(code);
})

Ensuite, nous allons préparer notre environnement pour interagir avec l’API de l’explorateur Etherscan.

Initialisons notre URL de contrat dans l’API de l’explorateur Etherscan pour la chaîne Kovan :

var etherscan_url =
  "https://kovan.etherscan.io/api?module=contract&action=getabi&
  address=${our_contract_address}"

Et initialisons un client REST pour interagir avec l’API Etherscan :

var client = require('node-rest-client-promise').Client();

et obtenir une promesse client :

client.getPromise(etherscan_url)

Une fois que nous avons une promesse client valide, nous pouvons obtenir notre ABI de contrat à partir de l’API Etherscan :

.then((client_promise) => {
  our_contract_abi = JSON.parse(client_promise.data.result);

Et maintenant nous pouvons créer notre objet contrat comme une promesse de consommer plus tard :

  return new Promise((resolve, reject) => {
      var our_contract = new web3.eth.Contract(our_contract_abi,
                                               our_contract_address);
      try {
        // Si tout se passe bien
        resolve(our_contract);
      } catch (ex) {
        // Si quelque chose va mal
        reject(ex);
      }
    });
})

Si notre promesse de contrat revient avec succès, nous pouvons commencer à interagir avec elle :

.then((our_contract) => {

Voyons notre adresse de contrat :

console.log(`Our Contract address:
            ${our_contract._address}`);

Ou bien:

console.log(`Our Contract address in another way:
            ${our_contract.options.address}`);

Interrogeons maintenant notre ABI de contrat :

console.log("Our contract abi: " +
            JSON.stringify(our_contract.options.jsonInterface));

Nous pouvons voir l’approvisionnement total de notre contrat à l’aide d’un rappel :

our_contract.methods.totalSupply().call(function(err, totalSupply) {
    if (!err) {
        console.log(`Total Supply with a callback:  ${totalSupply}`);
    } else {
        console.log(err);
    }
});

Ou nous pouvons utiliser la promesse retournée au lieu de transmettre le rappel :

our_contract.methods.totalSupply().call().then(function(totalSupply){
    console.log(`Total Supply with a promise:  ${totalSupply}`);
}).catch(function(err) {
    console.log(err);
});

Fonctionnement asynchrone avec attente

Maintenant que vous avez vu le didacticiel de base, vous pouvez essayer les mêmes interactions en utilisant une construction asynchrone wait . Passez en revue le script web3-contract-basic-interaction-async-await.js dans code/web3js et comparez-le à ce didacticiel pour voir en quoi ils diffèrent. Async-wait est plus facile à lire, car il fait en sorte que l’interaction asynchrone se comporte davantage comme une séquence d’appels bloquants.