🥇Comment construire, déployer et tester un dApp Waves RIDE

Bonjour ! Dans cet article, je vais vous montrer comment écrire et exécuter un dApp sur la nœud Waves. Nous examinerons les outils nécessaires, les méthodes et un exemple de développement.

Le schéma de développement des dApps et des applications classiques est presque identique :

Écrivons le code
Écrivons des tests automatisés
Démarrer l'application
Testons

Outils

1. docker pour lancer la nœud et Waves Explorer

Si vous ne souhaitez pas lancer la nœud, vous pouvez sauter cette étape. En effet, il existe un réseau de test et un réseau expérimental. Mais sans déployer votre propre nœud, le processus de test risque de s'étendre.

Vous aurez constamment besoin de nouveaux comptes avec des jetons de test. Le robinet du réseau de test envoie 10 WAVES toutes les 10 minutes.
Le temps moyen des blocs sur le réseau de test est d'une minute, tandis que sur la nœud, il est de 15 secondes. Cela se ressent particulièrement lorsque la transaction nécessite plusieurs confirmations.
Il est possible qu'il y ait un cache agressif sur les nœuds de test publics.
De plus, ils peuvent être temporairement indisponibles en raison de la maintenance technique.

Je vais désormais supposer que vous travaillez avec votre propre nœud.

2. Outil en ligne de commande Surfboard

Téléchargez et installez Node.js via ppa, homebrew ou exe ici : https://nodejs.org/en/download/.
Installez Surfboard, l'outil qui vous permettra de lancer des tests sur la nœud existante.

npm install -g @waves/surfboard

3. Plugin Visual Studio Code

Cette étape est facultative si vous n'êtes pas fan des IDE et préférez les éditeurs de texte. Tous les outils nécessaires sont des utilitaires en ligne de commande. Si vous utilisez vim, regardez le plugin vim-ride.

Téléchargez et installez Visual Studio Code : https://code.visualstudio.com/

Ouvrez VS Code et installez le plugin waves-ride :

Extension de navigateur Waves Keeper : https://wavesplatform.com/products-keeper

C'est fait !

Lancez la nœud et Waves Explorer

1. Lancez la nœud :

docker run -d -p 6869:6869 wavesplatform/waves-private-node

Assurez-vous que la nœud s'exécute via l'API REST sur http://localhost:6869:

L'interface Swagger REST API pour la nœud

2. Lancez une instance de Waves Explorer :

docker run -d -e API_NODE_URL=http://localhost:6869 -e NODE_LIST=http://localhost:6869 -p 3000:8080 wavesplatform/explorer

Ouvrez votre navigateur et allez à http://localhost:3000. Vous verrez comment une chaîne vide se construit rapidement sur la nœud locale.

Waves Explorer affiche une instance de la nœud locale

Structure RIDE et outil Surfboard

Créez un répertoire vide et exécutez-y la commande

surfboard init

La commande initialise le répertoire avec la structure du projet, une application de type « hello world » et des tests. Si vous ouvrez ce dossier avec VS Code, vous verrez :

Surfboard.config.json

Sous le dossier ./ride/, vous trouverez un fichier unique wallet.ride – le répertoire où se trouve le code du dApp. Nous allons analyser brièvement le dApp dans le prochain bloc.
Sous le dossier .\/test\/, vous trouverez le fichier *.js. C'est ici que sont stockés les tests.
.\/surfboard.config.json – fichier de configuration pour exécuter les tests.

Envs – section importante. Chaque environnement est configuré de la manière suivante :

Point de terminaison REST API du nœud, qui sera utilisé pour exécuter dApp et CHAIN_ID du réseau.
Phrase secrète pour le compte avec des jetons qui seront les sources de jetons de votre test.

Comme vous pouvez le voir, surfboard.config.json prend en charge plusieurs environnements par défaut. L'environnement local est défini par défaut (la clé defaultEnv est un paramètre modifiable).

L'application Wallet-demo

Cette section n'est pas un manuel de langage RIDE. Plutôt, elle donne un aperçu de l'application que nous déployons et testons pour mieux comprendre ce qui se passe sur la blockchain.

Considérons l'application simple Wallet-demo. Tout le monde peut envoyer des jetons à l'adresse dApp. On ne peut retirer que ses propres WAVES. Deux fonctions @Callable sont disponibles via InvokeScriptTransaction :

deposit(), qui nécessite un paiement attaché en WAVES
withdraw(amount: Int), qui renvoie des jetons

Tout au long du cycle de vie de dApp, la structure (adresse → montant) sera maintenue :

Action
État résultant

initial
vide

Alice dépose 5 WAVES
adresse-alice → 500000000

Bob dépose 2 WAVES

adresse-alice → 500000000
adresse-bob → 200000000

Bob retire 7 WAVES
REFUSÉ !

Alice retire 4 WAVES
adresse-alice → 100000000
adresse-bob → 200000000

Voici le code pour comprendre pleinement la situation :

# In this example multiple accounts can deposit their funds and safely take them back. No one can interfere with this.
# An inner state is maintained as mapping `address=>waves`.
{-# STDLIB_VERSION 3 #-}
{-# CONTENT_TYPE DAPP #-}
{-# SCRIPT_TYPE ACCOUNT #-}
@Callable(i)
func deposit() = {
 let pmt = extract(i.payment)
 if (isDefined(pmt.assetId))
    then throw("works with waves only")
    else {
     let currentKey = toBase58String(i.caller.bytes)
     let currentAmount = match getInteger(this, currentKey) {
       case a:Int => a
       case _ => 0
     }
     let newAmount = currentAmount + pmt.amount
     WriteSet([DataEntry(currentKey, newAmount)]) 
   }
 }
@Callable(i)
func withdraw(amount: Int) = {
 let currentKey = toBase58String(i.caller.bytes)
 let currentAmount = match getInteger(this, currentKey) {
   case a:Int => a
   case _ => 0
 }
 let newAmount = currentAmount - amount
 if (amount < 0)
   then throw("Can't withdraw negative amount")
   else if (newAmount < 0)
     then throw("Not enough balance")
     else ScriptResult(
       WriteSet([DataEntry(currentKey, newAmount)]),
       TransferSet([ScriptTransfer(i.caller, amount, unit)])
      )
 }
@Verifier(tx)
func verify() = false

Un exemple de code peut également être trouvé sur GitHub.

Le plugin VSCode prend en charge la compilation continue lors de l'édition du fichier. Vous pouvez donc toujours suivre les erreurs dans l'onglet PROBLEMS.

Si vous voulez utiliser un autre éditeur de texte lors de la compilation du fichier, utilisez

surfboard compile ride\/wallet.ride

Cela affichera une série de code RIDE compilé en base64.

Scénario de test pour ‘wallet.ride’

Regardons le fichier de test. Il fonctionne sur le cadre JavaScript Mocha. Il y a une fonction ‘Before’ et trois tests :

‘Before’ finance plusieurs comptes via MassTransferTransaction, compile le script et le déploie sur la blockchain.
‘Peut déposer’ envoie dans le réseau InvokeScriptTransaction, activant la fonction deposit() pour chacun des deux comptes.
‘Impossible de retirer plus que ce qui a été déposé’ teste que personne ne peut voler les jetons d'autrui.
‘Peut déposer’ vérifie que les retraits sont traités correctement.

Exécution des tests avec Surfboard et analyse des résultats dans Waves Explorer

Pour exécuter le test, exécutez

surfboard test

Si vous avez plusieurs scénarios (par exemple, un script de déploiement distinct est nécessaire), vous pouvez exécuter

surfboard test my-scenario.js

Surfboard rassemblera les fichiers de test dans le dossier . /test/ et lancera le script dans le nœud qui est configuré dans surfboard.config.json. Après quelques secondes, vous verrez quelque chose comme ceci :

série de tests de portefeuille
Génération de comptes avec nonce : ce8d86ee
Compte généré : foofoofoofoofoofoofoofoofoofoofoo#ce8d86ee - 3M763WgwDhmry95XzafZedf7WoBf5ixMwhX
Compte généré : barbarbarbarbarbarbarbarbarbar#ce8d86ee - 3MAi9KhwnaAk5HSHmYPjLRdpCAnsSFpoY2v
Compte généré : wallet#ce8d86ee - 3M5r6XYMZPUsRhxbwYf1ypaTB6MNs2Yo1Gb
Comptes financés avec succès
Le script a été configuré
   √ Peut déposer (4385 ms)
   √ Ne peut pas retirer plus que ce qui a été déposé
   √ Peut retirer (108 ms)
3 réussites (15 s)

Hourra ! Les tests sont passés. Voyons maintenant ce qui se passe lors de l'utilisation de Waves Explorer : consultons les blocs ou insérons l'une des adresses mentionnées ci-dessus dans la recherche (par exemple, la correspondante wallet#. Vous pouvez y trouver l'historique des transactions, l'état de la dApp, le fichier binaire décompilé.

Waves Explorer. L'application qui vient d'être déployée.

Quelques conseils sur Surfboard :

1. Pour tester dans l'environnement testnet, utilisez :

surfboard test --env=testnet

Obtenir des tokens de test

2. Si vous souhaitez voir les versions JSON des transactions et comment elles sont traitées par le nœud, lancez le test avec -v (signifie 'verbose') :

surfboard test -v

Utilisation des applications avec Waves Keeper

1. Configurez Waves Keeper pour fonctionner : http://localhost:6869

Configuration de Waves Keeper pour fonctionner avec un nœud local

2. Importez la phrase secrète avec des tokens pour le réseau ? Pour simplifier, utilisez la graine initiale de votre nœud : waves private node seed with waves tokens. Adresse : 3M4qwDomRabJKLZxuXhwfqLApQkU592nWxF.

3. Vous pouvez lancer une application sans serveur d'une seule page vous-même en utilisant npm. Ou allez à l'existant : chrome-ext.wvservices.com/dapp-wallet.html

4. Entrez l'adresse du portefeuille du lancement de test (soulignée ci-dessus) dans le champ de texte de l'adresse dApp

5. Saisissez un petit montant dans le champ 'Dépôt' et appuyez sur le bouton :

Waves Keeper demande l'autorisation de signer l'InvokeScriptTransaction avec un paiement de 10 WAVES.