Hallo! In dit artikel laat ik je zien hoe je een gewone dApp op een Waves-node schrijft en uitvoert. Laten we eens kijken naar de benodigde tools, methoden en een voorbeeld van ontwikkeling.
Het ontwikkelingsschema voor dApps en reguliere applicaties is vrijwel hetzelfde:
- Wij schrijven de code
- Geautomatiseerde testen schrijven
- De applicatie starten
- Testen
Gereedschap
1. docker om het knooppunt en Waves Explorer uit te voeren
Als u geen knooppunt wilt starten, kunt u deze stap overslaan. Er is immers een test- en experimenteernetwerk. Maar zonder uw eigen knooppunt in te zetten, kan het testproces zich voortslepen.
- Je hebt voortdurend nieuwe accounts met testtokens nodig. De testnetwerkkraan verzendt elke 10 minuten 10 GOLVEN.
- De gemiddelde bloktijd in het testnetwerk bedraagt 1 minuut, in het knooppunt 15 seconden. Dit is vooral merkbaar wanneer een transactie meerdere bevestigingen vereist.
- Agressieve caching is mogelijk op openbare testknooppunten.
- Het kan ook zijn dat ze tijdelijk niet beschikbaar zijn vanwege onderhoud.
Ik ga er vanaf nu van uit dat je met een eigen node werkt.
2. Surfboard-opdrachtregelprogramma
- Download en installeer Node.js hier met ppa, homebrew of exe: .
- Installeer Surfboard, een tool waarmee u tests kunt uitvoeren op een bestaand knooppunt.
npm install -g @waves/surfboard
3. Visual Studio Code-plug-in
Deze stap is optioneel als je geen fan bent van IDE's en de voorkeur geeft aan teksteditors. Alle benodigde hulpmiddelen zijn opdrachtregelhulpprogramma's. Als je vim gebruikt, let dan op de plug-in .
Download en installeer Visual Studio Code:
Open VS Code en installeer de Waves-Ride-plug-in:
Waves Keeper browserextensie:
Klaar!
Start het knooppunt en Waves Explorer
1. Start het knooppunt:
docker run -d -p 6869:6869 wavesplatform/waves-private-node
Zorg ervoor dat het knooppunt wordt gestart via de REST API in :
Swagger REST API voor knooppunt
2. Start een exemplaar van Waves Explorer:
docker run -d -e API_NODE_URL=http://localhost:6869 -e NODE_LIST=http://localhost:6869 -p 3000:8080 wavesplatform/explorer
Open een browser en ga naar . U zult zien hoe snel een leeg lokaal knooppuntcircuit wordt opgebouwd.
Waves Explorer geeft een lokaal knooppuntexemplaar weer
RIDE-structuur en surfplanktool
Maak een lege map en voer de opdracht daarin uit
surfboard init
De opdracht initialiseert een map met de projectstructuur, “hello world”-applicaties en tests. Als u deze map opent met VS Code, ziet u:
Surfboard.config.json
- Onder de map ./ride/ vindt u een enkel bestand wallet.ride - de map waarin de dApp-code zich bevindt. In het volgende blok zullen we dApps kort analyseren.
- Onder de map ./test/ vindt u een *.js-bestand. Tests worden hier opgeslagen.
- ./surfboard.config.json – configuratiebestand voor het uitvoeren van tests.
Envs is een belangrijk onderdeel. Elke omgeving is als volgt geconfigureerd:
- REST API-eindpunt van het knooppunt dat wordt gebruikt om de dApp en CHAIN_ID van het netwerk te starten.
- Een geheime zin voor een account met tokens die de bron zullen zijn van uw testtokens.
Zoals je kunt zien ondersteunt surfboard.config.json standaard meerdere omgevingen. De standaardwaarde is de lokale omgeving (de sleutel defaultEnv is een veranderlijke parameter).
Wallet-demo-applicatie
Dit gedeelte is geen verwijzing naar de RIDE-taal. In plaats daarvan kijken we naar de applicatie die we inzetten en testen om beter te begrijpen wat er in de blockchain gebeurt.
Laten we eens kijken naar een eenvoudige Wallet-demo-applicatie. Iedereen kan tokens naar een dApp-adres sturen. U kunt alleen uw WAVES intrekken. Er zijn twee @Callable-functies beschikbaar via InvokeScriptTransaction:
deposit()waarvoor een bijgevoegde betaling in WAVES vereist iswithdraw(amount: Int)die tokens retourneert
Gedurende de hele dApp-levenscyclus blijft de structuur (adres → bedrag) behouden:
Actie
Resulterende staat
eerste
leeg
Alice stort 5 GOLVEN
Alice-adres → 500000000
Bob stort 2 GOLVEN
Alice-adres → 500000000
bob-adres → 200000000
Bob trekt 7 GOLVEN terug
GEWEIGERD!
Alice trekt 4 GOLVEN terug
Alice-adres → 100000000
bob-adres → 200000000
Hier is de code om de situatie volledig te begrijpen:
# 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() = falseVoorbeeldcode is ook te vinden op .
De VSCode-plug-in ondersteunt continue compilatie tijdens het bewerken van een bestand. Daarom kunt u fouten altijd in de gaten houden op het tabblad PROBLEMEN.
Als u bij het compileren van het bestand een andere teksteditor wilt gebruiken, gebruikt u
surfboard compile ride/wallet.ride
Hierdoor wordt een reeks met base64 gecompileerde RIDE-code uitgevoerd.
Testscript voor 'wallet.ride'
Laten we eens kijken . Mogelijk gemaakt door het Mocha-framework van JavaScript. Er is een "Before" -functie en drie tests:
- “Before” financiert meerdere accounts via MassTransferTransaction, compileert het script en implementeert het op de blockchain.
- “Can deposit” stuurt een InvokeScriptTransaction naar het netwerk, waardoor de deposit()-functie voor elk van de twee accounts wordt geactiveerd.
- “Kan niet meer opnemen dan er is gestort” test dat niemand de tokens van anderen kan stelen.
- “Kan storten” controleert of opnames correct zijn verwerkt.
Voer tests uit vanaf Surfboard en analyseer de resultaten in Waves Explorer
Om de test uit te voeren, voert u uit
surfboard test
Als u meerdere scripts heeft (u hebt bijvoorbeeld een afzonderlijk implementatiescript nodig), kunt u deze uitvoeren
surfboard test my-scenario.js
Surfboard verzamelt de testbestanden in de map ./test/ en voert het script uit op het knooppunt dat is geconfigureerd in surfboard.config.json. Na een paar seconden zie je zoiets als dit:
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)
Hoera! Tests geslaagd. Laten we nu eens kijken wat er gebeurt als je Waves Explorer gebruikt: bekijk de blokken of plak een van de bovenstaande adressen in de zoekopdracht (bijvoorbeeld het bijbehorende wallet#. Daar kunt u de transactiegeschiedenis, de dApp-status en het gedecompileerde binaire bestand vinden.
Golvenverkenner. Een applicatie die zojuist is geïmplementeerd.
Enkele surfplanktips:
1. Om te testen in de testnet-omgeving gebruikt u:
surfboard test --env=testnet
2. Als je de JSON-versies van transacties wilt zien en hoe deze door het knooppunt worden verwerkt, voer je de test uit met -v (betekent 'uitgebreid'):
surfboard test -v
Apps gebruiken met Waves Keeper
1. Waves Keeper instellen om te werken:
Waves Keeper instellen om met een lokaal knooppunt te werken
2. Geheime zin met tokens voor het netwerk importeren? Gebruik voor de eenvoud het initiële zaad van uw knooppunt: waves private node seed with waves tokens. Adres: 3M4qwDomRabJKLZxuXhwfqLApQkU592nWxF.
3. U kunt zelf een serverloze applicatie met één pagina uitvoeren met behulp van npm. Of ga naar de bestaande:
4. Voer het portemonnee-adres van de testrun (hierboven onderstreept) in het tekstvak dApp-adres in
5. Voer een klein bedrag in het veld “Storten” in en klik op de knop:
Waves Keeper vraagt toestemming om een InvokeScriptTransaction te ondertekenen tegen betaling van 10 WAVES.
6. Bevestig de transactie:
De transactie wordt gemaakt en naar het netwerk verzonden. Nu kun je haar identiteitsbewijs zien
7. Volg de transactie met Waves Explorer. Voer ID in het zoekveld in
Conclusies en aanvullende informatie
We hebben gekeken naar de tools voor het ontwikkelen, testen, inzetten en gebruiken van eenvoudige dApps op het Waves Platform:
- RIDE-taal
- VS-code-editor
- Golvenverkenner
- Surfboard
- Golvenbewaarder
Links voor degenen die RIDE willen blijven leren:
Ga verder met het duiken in het RIDE-onderwerp en maak je eerste dApp!
TL; DR:
Bron: www.habr.com