🥇Come costruire, distribuire e testare un dApp Waves RIDE

Ciao! In questo articolo ti mostrerò come scrivere e avviare un dApp sulla rete Waves. Esamineremo gli strumenti necessari, i metodi e un esempio di sviluppo.

Lo schema di sviluppo di dApp e applicazioni tradizionali è quasi lo stesso:

Scriviamo codice
Scriviamo test automatizzati
Avviamo l'applicazione
Testiamo

Strumenti

1. docker per avviare la rete e Waves Explorer

Se non desideri avviare una rete, puoi saltare questo passaggio. Esistono reti di test e sperimentali. Tuttavia, senza il dispiegamento della tua rete, il processo di test potrebbe richiedere più tempo.

Avrai costantemente bisogno di nuovi account con token di test. Il faucet della rete di test invia 10 WAVES ogni 10 minuti.
Il tempo medio dei blocchi nella rete di test è di 1 minuto, nella rete è di 15 secondi. Questo è particolarmente evidente quando una transazione richiede diverse conferme.
Nelle reti pubbliche di test è possibile un caching aggressivo.
Inoltre, potrebbero essere temporaneamente non disponibili a causa di manutenzione.

D'ora in poi considererò che stai lavorando sulla tua rete.

2. Strumento della riga di comando Surfboard

Scarica e installa Node.js tramite ppa, homebrew o exe qui: https://nodejs.org/en/download/.
Installa Surfboard - uno strumento che ti consentirà di eseguire test su un nodo esistente.

npm install -g @waves/surfboard

3. Plugin per Visual Studio Code

Questo passaggio è facoltativo se non sei un fan delle IDE e preferisci editor di testo. Gli strumenti necessari sono utility da linea di comando. Se usi vim, fai attenzione al plugin vim-ride.

Scarica e installa Visual Studio Code: https://code.visualstudio.com/

Apri VS Code e installa il plugin waves-ride:

Estensione del browser Waves Keeper: https://wavesplatform.com/products-keeper

Fatto!

Avvia il nodo e Waves Explorer

1. Avvia il nodo:

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

Assicurati che il nodo venga avviato tramite REST API in http://localhost:6869:

Interfaccia Swagger REST API per il nodo

2. Avvia un'istanza di Waves Explorer:

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

Apri il browser e vai a http://localhost:3000. Vedrai come si costruisce rapidamente una catena vuota del nodo locale.

Waves Explorer visualizza l'istanza del nodo locale

Struttura RIDE e strumento Surfboard

Crea una directory vuota ed esegui il comando

surfboard init

Il comando inizializza la directory con la struttura del progetto, un'applicazione di tipo 'hello world' e test. Se apri questa cartella con VS Code, vedrai:

Surfboard.config.json

Nella cartella ./ride/ troverai un singolo file wallet.ride – la directory dove si trova il codice dApp. Esamineremo brevemente la dApp nel prossimo blocco.
Nella cartella ./test/ troverai il file *.js. Qui sono memorizzati i test.
./surfboard.config.json – file di configurazione per l'esecuzione dei test.

Envs – una sezione importante. Ogni ambiente è configurato in questo modo:

L'endpoint REST API del nodo che verrà utilizzato per eseguire la dApp e il CHAIN_ID della rete.
Frase segreta per l'account con i token, che saranno le fonti dei token per il tuo test.

Come puoi vedere, surfboard.config.json supporta più ambienti per impostazione predefinita. L'ambiente predefinito è impostato su locale (la chiave defaultEnv è un parametro modificabile).

Applicazione Wallet-demo

Questa sezione non è un manuale per il linguaggio RIDE. È piuttosto uno sguardo all'applicazione che stiamo distribuendo e testando per comprendere meglio cosa sta accadendo nella blockchain.

Consideriamo una semplice applicazione Wallet-demo. Chiunque può inviare token all'indirizzo dApp. Puoi prelevare solo i tuoi WAVES. Due funzioni @Callable sono disponibili tramite InvokeScriptTransaction:

deposit(), che richiede un pagamento allegato in WAVES.
withdraw(amount: Int), che restituisce i token.

Durante tutto il ciclo di vita dell'dApp, la struttura (indirizzo → importo) sarà mantenuta:

Action
Stato risultante

iniziale
vuoto

Alice deposita 5 WAVES
indirizzo-alice → 500000000

Bob deposita 2 WAVES

indirizzo-alice → 500000000
indirizzo-bob → 200000000

Bob ritira 7 WAVES
RIFIUTATO!

Alice ritira 4 WAVES
indirizzo-alice → 100000000
indirizzo-bob → 200000000

Ecco il codice per comprendere completamente la situazione:

# 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 esempio di codice è disponibile anche su GitHub.

Il plugin VSCode supporta la compilazione continua durante la modifica del file. Pertanto, puoi sempre tenere d'occhio gli errori nella scheda PROBLEMI.

Se desideri utilizzare un altro editor di testo durante la compilazione del file, usa

surfboard compile ride/wallet.ride

Questo stamperà una serie di codice RIDE compilato in base64.

Scenario di test per ‘wallet.ride’

Diamo un'occhiata a file di test. Funziona sul framework JavaScript Mocha. Ci sono una funzione «Before» e tre test:

«Before» finanzia diversi account tramite MassTransferTransaction, compila lo script e lo distribuisce nella blockchain.
«Can deposit» invia alla rete InvokeScriptTransaction, attivando la funzione deposit() per ciascuno dei due account.
«Can’t withdraw more than was deposited» testa che nessuno possa rubare i token degli altri.
«Can deposit» verifica che i prelievi vengano elaborati correttamente.

Esegui i test con Surfboard e analizza i risultati in Waves Explorer.

Per avviare il test, esegui

test surfboard

Se hai più scenari (ad esempio, hai bisogno di uno script di distribuzione separato), puoi avviare

surfboard test my-scenario.js

Surfboard raccoglierà i file di test nella cartella ./test/ e avvierà lo script nel nodo configurato in surfboard.config.json. Dopo pochi secondi, vedrai qualcosa del genere:

suite di test wallet
Generazione degli account con nonce: ce8d86ee
Account generato: foofoofoofoofoofoofoofoofoofoofoo#ce8d86ee - 3M763WgwDhmry95XzafZedf7WoBf5ixMwhX
Account generato: barbarbarbarbarbarbarbarbarbar#ce8d86ee - 3MAi9KhwnaAk5HSHmYPjLRdpCAnsSFpoY2v
Account generato: wallet#ce8d86ee - 3M5r6XYMZPUsRhxbwYf1ypaTB6MNs2Yo1Gb
Accounts finanziati con successo
Script impostato
   √ Può depositare (4385ms)
   √ Non può prelevare più di quanto è stato depositato
   √ Può prelevare (108ms)
3 passaggi (15s)

Evviva! I test sono stati superati. Ora diamo un'occhiata a cosa succede utilizzando Waves Explorer: visualizziamo i blocchi o inseriamo uno degli indirizzi sopra indicati nella ricerca (ad esempio, il corrispondente wallet#. Qui puoi trovare la cronologia delle transazioni, lo stato della dApp, il file binario decompilato.

Waves Explorer. L'applicazione che hai appena distribuito.

Alcuni consigli su Surfboard:

1. Per testare nell'ambiente testnet, utilizza:

surfboard test --env=testnet

Ottenere token di test

2. Se vuoi vedere le versioni JSON delle transazioni e come vengono elaborate dal nodo, avvia il test con -v (significa 'verbose'):

surfboard test -v

Utilizzo delle applicazioni con Waves Keeper

1. Configura Waves Keeper per funzionare: http://localhost:6869

Impostazione di Waves Keeper per lavorare con un nodo locale

2. Importa la frase segreta con i token per la rete? Per semplicità, utilizza il seed iniziale del tuo nodo: waves private node seed with waves tokens. Indirizzo: 3M4qwDomRabJKLZxuXhwfqLApQkU592nWxF.

3. Puoi eseguire un'applicazione senza server a pagina unica da solo, utilizzando npm. Oppure vai a una esistente: chrome-ext.wvservices.com/dapp-wallet.html

4. Inserisci l'indirizzo del wallet dal test di avvio (sottolineato sopra) nel campo di testo dell'indirizzo dApp

5. Inserisci una piccola somma nel campo 'Deposit' e premi il pulsante:

Waves Keeper richiede il permesso per firmare l'InvokeScriptTransaction con un pagamento di 10 WAVES.