🥇Come costruire, implementare e testare un dApp Waves RIDE

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

Lo schema di sviluppo delle dApps e delle applicazioni tradizionali è quasi identico:

Scriviamo codice
Scriviamo test automatizzati
Avviamo l'applicazione
Testiamo

Strumenti

1. docker per avviare il nodo e Waves Explorer

Se non vuoi avviare un nodo, puoi saltare questo passo. Infatti, ci sono reti di test e sperimentali. Ma senza implementare il tuo nodo, il processo di test potrebbe allungarsi.

Avrai costantemente bisogno di nuovi account con token di test. Il faucet della rete di test fornisce 10 WAVES ogni 10 minuti.
Il tempo medio dei blocchi nella rete di test è di 1 minuto, nel nodo è di 15 secondi. Questo è particolarmente evidente quando una transazione richiede diverse conferme.
Nei nodi di test pubblici, è possibile una cache aggressiva.
Inoltre, potrebbero essere temporaneamente non disponibili a causa di manutenzione tecnica.

D'ora in poi considererò che stai lavorando con il tuo nodo.

2. Strumento da riga di comando Surfboard

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

npm install -g @waves/surfboard

3. Estensione per Visual Studio Code

Questo passo è facoltativo se non sei un fan delle IDE e preferisci gli editor di testo. Tutti gli strumenti necessari sono utility da riga di comando. Se usi vim, dai un'occhiata 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 si avvii 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 quanto velocemente si costruisce una catena vuota del nodo locale.

Waves Explorer visualizza un'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\/ troverete un file singolo wallet.ride – la directory dove si trova il codice dApp. Analizzeremo brevemente la dApp nel prossimo blocco.
Nella cartella .\/test\/ troverete il file *.js. Qui sono memorizzati i test.
.\/surfboard.config.json – file di configurazione per l'esecuzione dei test.

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

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

Come potete vedere, surfboard.config.json supporta per impostazione predefinita diversi ambienti. L'ambiente locale è impostato come predefinito (chiave defaultEnv – parametro modificabile).

Applicazione Wallet-demo

Questa sezione non è una guida al linguaggio RIDE. Piuttosto, uno sguardo all'applicazione che stiamo distribuendo e testando per comprendere meglio cosa accade nella blockchain.

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

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

Durante l'intero ciclo di vita della dApp, la struttura (address → amount) sarà mantenuta:

Azione
Stato risultante

iniziale
vuoto

Alice deposita 5 WAVES
alice-address → 500000000

Bob deposita 2 WAVES

alice-address → 500000000
bob-address → 200000000

Bob preleva 7 WAVES
RIFIUTATO!

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

Ecco il codice per una comprensione completa della 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 può essere trovato anche su GitHub.

Il plugin VSCode supporta la compilazione continua durante la modifica del file. Pertanto, puoi sempre monitorare gli errori nella scheda PROBLEMS.

Se desideri utilizzare un altro editor di testo per compilare il file, utilizza

surfboard compile ride\/wallet.ride

Questo restituirà una serie di codici RIDE compilati in base64.

Scenario di test per 'wallet.ride'

Diamo un'occhiata al file di test. Funziona sul framework JavaScript’s Mocha. C'è una funzione 'Before' e tre test:

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

Esecuzione dei test con Surfboard e analisi dei risultati in Waves Explorer

Per eseguire il test, utilizza

surfboard test

Se hai diversi 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 alcuni secondi, vedrai qualcosa di simile:

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

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

Waves Explorer. L'applicazione che è stata appena distribuita.

Alcuni suggerimenti su Surfboard:

1. Per testare nell'ambiente testnet, usa:

surfboard test --env=testnet

Ottenere token di test

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

surfboard test -v

Utilizzare applicazioni con Waves Keeper

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

Configurazione 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 in una pagina da solo utilizzando npm. Oppure vai a quella esistente: chrome-ext.wvservices.com\/dapp-wallet.html

4. Inserisci l'indirizzo del portafoglio della sessione di test (sottolineato sopra) nel campo di testo dell'indirizzo dApp

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

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