🥇Hvordan man bygger, implementerer og tester Waves RIDE dApp

Hej! I denne artikel vil jeg vise, hvordan man skriver og kører en almindelig dApp på Waves-noden. Vi vil se på de nødvendige værktøjer, metoder og et udviklingseksempel.

Udviklingsskemaet for dApps og almindelige applikationer adskiller sig stort set ikke:

Skriv koden
Skriv automatiserede tests
Start applikationen
Testning

Værktøjer

1. docker til at starte noden og Waves Explorer

Hvis du ikke ønsker at starte noden, kan du springe dette trin over. Der er dog et test- og eksperimentelt netværk. Men uden at have din egen node kan testprocessen blive forsinket.

Du vil konstant have brug for nye konti med test tokens. Testnetværket giver 10 WAVES hver 10. minut.
Den gennemsnitlige bloktid i testnetværket er 1 minut, mens den i noden er 15 sekunder. Dette mærkes især, når en transaktion kræver flere bekræftelser.
I offentlige testnoder kan der forekomme aggressiv caching.
Desuden kan de være midlertidigt utilgængelige på grund af vedligeholdelse.

Jeg vil fremover antage, at du arbejder med din egen node.

2. Kommandolinjeværktøjet Surfboard

Download og installer Node.js via ppa, homebrew eller exe her: https://nodejs.org/en/download/.
Installer Surfboard - et værktøj, der gør det muligt at køre tests på en eksisterende node.

npm install -g @waves/surfboard

3. Visual Studio Code-plugin

Dette trin er valgfrit, hvis du ikke er fan af IDE'er og foretrækker tekstredigerere. Alle nødvendige værktøjer er kommandolinje-værktøjer. Hvis du bruger vim, så vær opmærksom på plugin'et vim-ride.

Download og installer Visual Studio Code: https://code.visualstudio.com/

Åbn VS Code og installer plugin'et waves-ride:

Browserudvidelsen Waves Keeper: https://wavesplatform.com/products-keeper

Færdig!

Start noden og Waves Explorer

1. Start noden:

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

Sørg for, at noden kører via REST API i http://localhost:6869:

Swagger REST API-grænseflade for noden

2. Start en instans af Waves Explorer:

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

Åbn en browser og gå til http://localhost:3000. Du vil se, hvor hurtigt en tom kæde fra den lokale node bygges.

Waves Explorer viser en instans af den lokale node

RIDE-strukturen og værktøjet Surfboard

Opret en tom mappe og udfør kommandoen i den

surfboard init

Kommandoen initialiserer mappen med projekts struktur, en "hello world"-applikation og tests. Hvis du åbner denne mappe med VS Code, vil du se:

Surfboard.config.json

Under mappen ./ride/ finder du en enkelt fil wallet.ride - mappen, hvor koden til dApp'en ligger. Vi vil kort analysere dApp'en i næste afsnit.
Under the folder .\/test\/ you will find the file *.js. This is where the tests are stored.
.\/surfboard.config.json – the configuration file for running tests.

Envs – an important section. Each environment is configured as follows:

The endpoint of the REST API node that will be used to launch the dApp and the CHAIN_ID of the network.
A secret phrase for the account with tokens that will be the sources of your test tokens.

As you can see, surfboard.config.json supports multiple environments by default. The local environment is set as default (defaultEnv key is a configurable parameter).

The Wallet-demo application

This section is not a guide to the RIDE language. Rather, it's a look at the application that we're deploying and testing to better understand what's happening on the blockchain.

Let’s consider a simple Wallet-demo application. Anyone can send tokens to the dApp address. You can only withdraw your WAVES. Two @Callable functions are available through InvokeScriptTransaction:

deposit(), which requires an attached payment in WAVES.
withdraw(amount: Int), which returns the tokens.

Throughout the lifecycle of the dApp, the structure (address → amount) will be maintained:

Handling
Resulting state

initial
empty

Alice deposits 5 WAVES
alice-address → 500000000

Bob deposits 2 WAVES

alice-address → 500000000
bob-address → 200000000

Bob withdraws 7 WAVES
DENIED!

Alice withdraws 4 WAVES
alice-address → 100000000
bob-address → 200000000

Here’s the code for a complete understanding of the 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

A code example can also be found at GitHub.

The VSCode plugin supports continuous compilation while editing the file. Therefore, you can always keep track of the errors in the PROBLEMS tab.

If you want to use another text editor when compiling the file, use

surfboard compile ride\/wallet.ride

This will output a series of base64 compiled RIDE code.

A test scenario for ‘wallet.ride’

Let’s look at the test file. It works on the JavaScript Mocha framework. There is a "Before" function and three tests:

The "Before" funds several accounts through MassTransferTransaction, compiles the script, and deploys it to the blockchain.
"Can deposit" sends an InvokeScriptTransaction to the network, activating the deposit() function for each of the two accounts.
"Can’t withdraw more than was deposited" tests that no one can steal someone else's tokens.
"Can deposit" checks that withdrawals are processed correctly.

Running tests with Surfboard and analyzing results in Waves Explorer

To run the test, execute

surfboard test

If you have several scenarios (for example, if a separate deployment script is needed), you can run

surfboard test my-scenario.js

Surfboard samler testfiler i mappen ./test/ og kører scriptet på noden, der er konfigureret i surfboard.config.json. Efter et par sekunder vil du se noget som dette:

wallet test suite
Genererer konti med nonce: ce8d86ee
Konto genereret: foofoofoofoofoofoofoofoofoofoofoo#ce8d86ee - 3M763WgwDhmry95XzafZedf7WoBf5ixMwhX
Konto genereret: barbarbarbarbarbarbarbarbarbar#ce8d86ee - 3MAi9KhwnaAk5HSHmYPjLRdpCAnsSFpoY2v
Konto genereret: wallet#ce8d86ee - 3M5r6XYMZPUsRhxbwYf1ypaTB6MNs2Yo1Gb
Kontoer er blevet finansieret med succes
Scriptet er blevet indstillet
   √ Kan indsætte (4385ms)
   √ Kan ikke trække mere tilbage, end der blev indsat
   √ Kan trække tilbage (108ms)
3 bestået (15s)

Hurra! Tests er bestået. Lad os se på, hvad der sker ved brug af Waves Explorer: vi kan gennemse blokke eller indsætte en af de nævnte adresser i søgningen (fx den relevante wallet#. Her kan man finde transaktionshistorik, status for dApp, dekompileret binærfil.

Waves Explorer. Applikationen, der lige er blevet implementeret.

Nogle tips til Surfboard:

1. For at teste i testnet-miljøet, brug:

surfboard test --env=testnet

Få test tokens

2. Hvis du vil se JSON-versioner af transaktioner og hvordan de behandles af noden, kør testen med -v (det betyder 'verbose'):

surfboard test -v

Brug af applikationer med Waves Keeper

1. Konfigurer Waves Keeper til at fungere: http://localhost:6869

Konfigurer Waves Keeper til at fungere med den lokale node

2. Importer den hemmelige sætning med tokens til netværket? For nemheds skyld brug start-sæden for din node: waves private node seed with waves tokens. Adresse: 3M4qwDomRabJKLZxuXhwfqLApQkU592nWxF.

3. Du kan køre en enkeltstående serverless applikation selv med npm. Eller gå til den eksisterende: chrome-ext.wvservices.com/dapp-wallet.html

4. Indtast wallet-adressen fra teststarten (fremhævet ovenfor) i tekstfeltet for dApp-adresse

5. Indtast et lille beløb i feltet 'Deposit' og klik på knappen:

Waves Keeper beder om tilladelse til at underskrive InvokeScriptTransaction med en betaling på 10 WAVES.