🥇Jak budować, wdrażać i testować dApp w Waves RIDE

Witaj! W tym artykule pokażę, jak napisać i uruchomić zwykłego dApp na węźle Waves. Przyjrzymy się niezbędnym narzędziom, metodom i przykładowi rozwoju.

Schemat rozwoju dAppów i zwykłych aplikacji praktycznie się nie różni:

Pisanie kodu
Pisanie testów automatycznych
Uruchamiamy aplikację
Testowanie

Narzędzia

1. docker do uruchamiania węzła i Waves Explorer

Jeśli nie chcesz uruchamiać węzła, możesz pominąć ten krok. Istnieje sieć testowa i eksperymentalna. Ale bez wdrożenia własnego węzła proces testowania może się wydłużyć.

Będziesz regularnie potrzebować nowych kont z testowymi tokenami. Cieknij testowa sieć przekaże 10 WAVES co 10 minut.
Średni czas bloków w sieci testowej wynosi 1 minuta, w węźle – 15 sekund. Jest to szczególnie odczuwalne, gdy transakcja wymaga kilku potwierdzeń.
W publicznych węzłach testowych może wystąpić agresywne buforowanie.
Mogą również być tymczasowo niedostępne z powodu konserwacji technicznej.

Będę zakładać, że pracujesz ze swoim węzłem.

2. Narzędzie wiersza poleceń Surfboard

Pobierz i zainstaluj Node.js za pomocą ppa, homebrew lub exe tutaj: https://nodejs.org/en/download/.
Zainstaluj Surfboard – narzędzie, które pozwoli na uruchomienie testów na istniejącym węźle.

npm install -g @waves/surfboard

3. Rozszerzenie Visual Studio Code

Krok nie jest obowiązkowy, jeśli nie jesteś fanem IDE i wolisz edytory tekstu. Wszystkie niezbędne narzędzia to narzędzia wiersza poleceń. Jeśli używasz vim, zwróć uwagę na wtyczkę vim-ride.

Pobierz i zainstaluj Visual Studio Code: https://code.visualstudio.com/

Otwórz VS Code i zainstaluj wtyczkę waves-ride:

Rozszerzenie przeglądarki Waves Keeper: https://wavesplatform.com/products-keeper

Gotowe!

Uruchom węzeł i Waves Explorer

1. Uruchom węzeł:

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

Upewnij się, że węzeł uruchamia się przez REST API w http://localhost:6869:

Interfejs Swagger REST API dla węzła

2. Uruchom instancję Waves Explorer:

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

Otwórz przeglądarkę i przejdź do http://localhost:3000. Zobaczysz, jak szybko buduje się pusta łańcuch lokalnego węzła.

Waves Explorer wyświetla instancję lokalnego węzła

Struktura RIDE i narzędzie Surfboard

Utwórz pusty katalog i wykonaj w nim polecenie

surfboard init

Polecenie inicjuje katalog ze strukturą projektu, aplikacją typu „hello world” i testami. Jeśli otworzysz ten folder z VS Code, zobaczysz:

Surfboard.config.json

W folderze .\/ride\/ znajdziesz pojedynczy plik wallet.ride – katalog, w którym znajduje się kod dApp. Krótko przeanalizujemy dApp w następnym bloku.
W folderze .\/test\/ znajdziesz plik *.js. Tutaj przechowywane są testy.
.\/surfboard.config.json – plik konfiguracyjny do uruchamiania testów.

Envs – ważna sekcja. Każde środowisko jest konfigurowane w ten sposób:

Końcowy punkt REST API węzła, który będzie używany do uruchamiania dApp oraz CHAIN_ID sieci.
Sekretna fraza do konta z tokenami, które będą źródłami tokenów twojego testu.

Jak widać, surfboard.config.json domyślnie obsługuje wiele środowisk. Domyślnie ustawia się lokalne środowisko (klucz defaultEnv – zmienny parametr).

Aplikacja Wallet-demo

Ta sekcja – to nie podręcznik po języku RIDE. Raczej spojrzenie na aplikację, którą wdrażamy i testujemy, aby lepiej zrozumieć, co dzieje się w blockchainie.

Przyjrzyjmy się prostemu przedsięwzięciu Wallet-demo. Każdy może wysłać tokeny na adres dApp. Można wypłacić tylko swoje WAVES. Dwie funkcje @Callable są dostępne przez InvokeScriptTransaction:

deposit(), która wymaga dołączenia płatności w WAVES
withdraw(amount: Int), która zwraca tokeny

W trakcie całego cyklu życia dApp struktura (address → amount) będzie utrzymywana:

Akcja
Stan końcowy

początkowy
pusty

Alice wpłaca 5 WAVES
alice-address → 500000000

Bob wpłaca 2 WAVES

alice-address → 500000000
bob-address → 200000000

Bob wypłaca 7 WAVES
ODRZUCONE!

Alice wypłaca 4 WAVES
alice-address → 100000000
bob-address → 200000000

Oto kod dla pełnego zrozumienia sytuacji:

# 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

Przykład kodu można również znaleźć na GitHub.

Plugin VSCode obsługuje ciągłą kompilację podczas edytowania pliku. Dlatego możesz na bieżąco śledzić błędy w zakładce PROBLEMY.

Jeśli chcesz użyć innego edytora tekstu podczas kompilacji pliku, użyj

surfboard compile ride\/wallet.ride

To wygeneruje szereg zakodowanego w base64 skompilowanego kodu RIDE.

Scenariusz testowy dla 'wallet.ride'

Przyjrzyjmy się plikowi testowemu. Działa na frameworku JavaScript Mocha. Jest funkcja „Before” i trzy testy:

„Before” finansuje kilka kont przez MassTransferTransaction, kompiluje skrypt i wdraża go w blockchainie.
„Can deposit” wysyła do sieci InvokeScriptTransaction, aktywując funkcję deposit() dla każdego z dwóch kont.
„Can’t withdraw more than was deposited” testuje, że nikt nie będzie mógł ukraść cudzych tokenów.
„Can deposit” sprawdza, że wypłaty są przetwarzane poprawnie.

Uruchamianie testów z Surfboardem i analiza wyników w Waves Explorer

Aby uruchomić test, wykonaj

surfboard test

Jeśli masz kilka scenariuszy (na przykład potrzebny jest osobny skrypt wdrożeniowy), możesz uruchomić

surfboard test my-scenario.js

Surfboard zbierze pliki testowe w folderze ./test/ i uruchomi skrypt na węźle, który jest skonfigurowany w surfboard.config.json. Po kilku sekundach zobaczysz coś podobnego:

suite testowa portfela
Generowanie kont z nonce: ce8d86ee
Konto utworzone: foofoofoofoofoofoofoofoofoofoofoo#ce8d86ee - 3M763WgwDhmry95XzafZedf7WoBf5ixMwhX
Konto utworzone: barbarbarbarbarbarbarbarbarbar#ce8d86ee - 3MAi9KhwnaAk5HSHmYPjLRdpCAnsSFpoY2v
Konto utworzone: wallet#ce8d86ee - 3M5r6XYMZPUsRhxbwYf1ypaTB6MNs2Yo1Gb
Konta zostały pomyślnie doładowane
Skrypt został ustawiony
   √ Można wpłacać (4385ms)
   √ Nie można wypłacić więcej niż wpłacono
   √ Można wypłacić (108ms)
3 zaliczone (15s)

Hurra! Testy przeszły. Teraz przyjrzyjmy się, co dzieje się podczas korzystania z Waves Explorer: przyjrzyjmy się blokom lub wstawmy jeden z powyższych adresów do wyszukiwania (na przykład odpowiedni wallet#. Tutaj można znaleźć historię transakcji, stan dApp, zdekompilowany plik binarny.

Waves Explorer. Aplikacja, którą właśnie wdrożono.

Kilka wskazówek dotyczących Surfboard:

1. Aby testować w środowisku testnet, użyj:

surfboard test --env=testnet

Otrzymaj testowe tokeny

2. Jeśli chcesz zobaczyć wersje JSON transakcji i jak są przetwarzane przez węzeł, uruchom test z -v (oznacza 'verbose'):

surfboard test -v

Korzystanie z aplikacji z Waves Keeper

1. Skonfiguruj Waves Keeper do współpracy: http://localhost:6869

Konfiguracja Waves Keeper do pracy z lokalnym węzłem

2. Zaimportuj frazę sekretną z tokenami do sieci? Dla uproszczenia użyj początkowego seed twojego węzła: waves private node seed with waves tokens. Adres: 3M4qwDomRabJKLZxuXhwfqLApQkU592nWxF.

3. Możesz uruchomić jedną stronę bezserwerowej aplikacji samodzielnie, używając npm. Lub przejdź do istniejącego: chrome-ext.wvservices.com/dapp-wallet.html

4. Wprowadź adres portfela z testowego uruchomienia (podkreślony powyżej) w polu tekstowym adresu dApp

5. Wpisz małą kwotę w polu „Depozyt” i naciśnij przycisk:

Waves Keeper prosi o pozwolenie na podpisanie InvokeScriptTransaction z płatnością 10 WAVES.