Ciao! In questo articolo ti mostrerò come scrivere ed eseguire una normale dApp su un nodo Waves. Diamo un'occhiata agli strumenti necessari, ai metodi e ad un esempio di sviluppo.
Lo schema di sviluppo per le dApp e le applicazioni normali è quasi lo stesso:
- Scriviamo il codice
- Scrittura di test automatizzati
- Avvio dell'applicazione
- analisi
Strumenti
1. docker per eseguire il nodo e Waves Explorer
Se non vuoi avviare un nodo, puoi saltare questo passaggio. Dopotutto, esiste una rete di prova e sperimentale. Ma senza distribuire il proprio nodo, il processo di test potrebbe trascinarsi.
- Avrai costantemente bisogno di nuovi account con token di prova. Il rubinetto di rete di prova trasferisce 10 ONDE ogni 10 minuti.
- Il tempo medio di blocco nella rete di prova è di 1 minuto, nel nodo – 15 secondi. Ciò è particolarmente evidente quando una transazione richiede più conferme.
- Il caching aggressivo è possibile sui nodi di test pubblici.
- Potrebbero anche essere temporaneamente non disponibili a causa di manutenzione.
D'ora in poi presumo che tu stia lavorando con il tuo nodo.
2. Strumento da riga di comando della tavola da surf
- Scarica e installa Node.js utilizzando ppa, homebrew o exe qui: .
- Installa Surfboard, uno strumento che ti consente di eseguire test su un nodo esistente.
npm install -g @waves/surfboard
3. Plug-in Codice di Visual Studio
Questo passaggio è facoltativo se non sei un fan degli IDE e preferisci gli editor di testo. Tutti gli strumenti necessari sono utilità della riga di comando. Se usi vim, presta attenzione al plugin .
Scarica e installa il codice di Visual Studio:
Apri VS Code e installa il plugin waveride:
Estensione del browser Waves 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 l'API REST in :
API REST Swagger per node
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 un browser e vai su . Vedrai quanto velocemente viene costruito un circuito di nodo locale vuoto.
Waves Explorer visualizza un'istanza del nodo locale
Struttura RIDE e strumento tavola da surf
Crea una directory vuota ed esegui il comando al suo interno
surfboard init
Il comando inizializza una directory con la struttura del progetto, le applicazioni "ciao mondo" e i test. Se apri questa cartella con VS Code, vedrai:
Surfboard.config.json
- Nella cartella ./ride/ troverai un singolo file wallet.ride, la directory in cui si trova il codice dApp. Analizzeremo brevemente le dApp nel blocco successivo.
- Nella cartella ./test/ troverai un file *.js. I test sono archiviati qui.
- ./surfboard.config.json – file di configurazione per l'esecuzione dei test.
Envs è una sezione importante. Ogni ambiente è configurato in questo modo:
- Endpoint API REST del nodo che verrà utilizzato per avviare la dApp e CHAIN_ID della rete.
- Una frase segreta per un account con token che saranno le fonti dei tuoi token di prova.
Come puoi vedere, surfboard.config.json supporta più ambienti per impostazione predefinita. Il valore predefinito è l'ambiente locale (la chiave defaultEnv è un parametro modificabile).
Applicazione demo di Wallet
Questa sezione non è un riferimento al linguaggio RIDE. Piuttosto, uno sguardo all’applicazione che distribuiamo e testiamo per capire meglio cosa sta succedendo nella blockchain.
Diamo un'occhiata a una semplice applicazione demo di Wallet. Chiunque può inviare token a un indirizzo dApp. Puoi ritirare solo le tue WAVES. Due funzioni @Callable sono disponibili tramite InvokeScriptTransaction:
deposit()che richiede un pagamento allegato in WAVESwithdraw(amount: Int)che restituisce token
Durante tutto il ciclo di vita della dApp, la struttura (indirizzo → importo) verrà mantenuta:
Action
Stato risultante
inizialmente
vuoto
Alice deposita 5 ONDE
indirizzo-alice → 500000000
Bob deposita 2 ONDE
indirizzo-alice → 500000000
indirizzo-bob → 200000000
Bob ritira 7 ONDE
NEGATO!
Alice ritira 4 ONDE
indirizzo-alice → 100000000
indirizzo-bob → 200000000
Ecco il codice per comprendere appieno 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() = falseIl codice di esempio è disponibile anche all'indirizzo .
Il plugin VSCode supporta la compilazione continua durante la modifica di un file. Pertanto puoi sempre monitorare gli errori nella scheda PROBLEMI.
Se desideri utilizzare un editor di testo diverso durante la compilazione del file, utilizza
surfboard compile ride/wallet.ride
Ciò genererà una serie di codice RIDE compilato base64.
Script di prova per "wallet.ride"
Guardiamo . Alimentato dal framework Mocha di JavaScript. C'è una funzione "Prima" e tre test:
- "Prima" finanzia più account tramite MassTransferTransaction, compila lo script e lo distribuisce sulla blockchain.
- “Can deposit” invia una InvokeScriptTransaction alla rete, attivando la funzione deposit() per ciascuno dei due conti.
- "Non è possibile ritirare più di quanto è stato depositato" prova che nessuno può rubare i gettoni di altre persone.
- “Può depositare” controlla che i prelievi siano elaborati correttamente.
Esegui test da Surfboard e analizza i risultati in Waves Explorer
Per eseguire il test, corri
surfboard test
Se disponi di più script (ad esempio, hai bisogno di uno script di distribuzione separato), puoi eseguire
surfboard test my-scenario.js
Surfboard raccoglierà i file di test nella cartella ./test/ ed eseguirà lo script sul nodo configurato in surfboard.config.json. Dopo qualche secondo vedrai qualcosa del genere:
wallet test suite
Generating accounts with nonce: ce8d86ee
Account generated: foofoofoofoofoofoofoofoofoofoofoo#ce8d86ee - 3M763WgwDhmry95XzafZedf7WoBf5ixMwhX
Account generated: barbarbarbarbarbarbarbarbarbar#ce8d86ee - 3MAi9KhwnaAk5HSHmYPjLRdpCAnsSFpoY2v
Account generated: wallet#ce8d86ee - 3M5r6XYMZPUsRhxbwYf1ypaTB6MNs2Yo1Gb
Accounts successfully funded
Script has been set
√ Can deposit (4385ms)
√ Cannot withdraw more than was deposited
√ Can withdraw (108ms)
3 passing (15s)
Evviva! Prove superate. Ora diamo un'occhiata a cosa succede quando si utilizza Waves Explorer: guarda i blocchi o incolla nella ricerca uno degli indirizzi sopra (ad esempio, il corrispondente wallet#. Lì puoi trovare la cronologia delle transazioni, lo stato della dApp, il file binario decompilato.
Esploratore delle onde. Un'applicazione che è stata appena distribuita.
Alcuni suggerimenti per la tavola da surf:
1. Per testare nell'ambiente testnet, utilizzare:
surfboard test --env=testnet
2. Se vuoi vedere le versioni JSON delle transazioni e il modo in cui vengono elaborate dal nodo, esegui il test con -v (significa 'verbose'):
surfboard test -v
Utilizzo delle app con Waves Keeper
1. Configura Waves Keeper affinché funzioni:
Configurazione di Waves Keeper per funzionare con un nodo locale
2. Importare la frase segreta con i token per la rete? Per semplicità, usa il seed iniziale del tuo nodo: waves private node seed with waves tokens. Indirizzo: 3M4qwDomRabJKLZxuXhwfqLApQkU592nWxF.
3. Puoi eseguire tu stesso un'applicazione serverless a pagina singola utilizzando npm. Oppure vai a quello esistente:
4. Inserisci l'indirizzo del portafoglio dall'esecuzione del test (sottolineato sopra) nella casella di testo dell'indirizzo della dApp
5. Inserisci un piccolo importo nel campo “Deposito” e fai clic sul pulsante:
Waves Keeper richiede l'autorizzazione per firmare una InvokeScriptTransaction con il pagamento di 10 WAVES.
6. Conferma la transazione:
La transazione viene creata e trasmessa alla rete. Ora puoi vedere il suo documento d'identità
7. Monitorare la transazione utilizzando Waves Explorer. Inserisci l'ID nel campo di ricerca
Conclusioni e informazioni aggiuntive
Abbiamo esaminato gli strumenti per sviluppare, testare, distribuire e utilizzare semplici dApp sulla piattaforma Waves:
- Linguaggio RIDE
- Editor del codice VS
- Esploratore delle onde
- Surf
- Custode delle onde
Link per chi vuole continuare ad imparare RIDE:
Continua ad approfondire l'argomento RIDE e crea la tua prima dApp!
TL; DR:
Fonte: habr.com