🥇 Como construir, implantar e testar um dApp Waves RIDE

Olá! Neste artigo, vou mostrar como escrever e executar um dApp comum em um nó Waves. Vamos considerar as ferramentas necessárias, métodos e um exemplo de desenvolvimento.

O esquema de desenvolvimento de dApps e aplicativos comuns quase não difere:

Escrevendo código
Escrevendo testes automatizados
Iniciamos o aplicativo
Testando

Ferramentas

1. docker para executar um nó e o Waves Explorer

Se você não deseja executar um nó, pode pular esta etapa. Há uma rede de testes e uma experimental. Mas sem o despliegue do seu próprio nó, o processo de teste pode demorar.

Você sempre precisará de novas contas com tokens de teste. O faucet da rede de teste transfere 10 WAVES a cada 10 minutos.
O tempo médio dos blocos na rede de teste é de 1 minuto, no nó é de 15 segundos. Isso é especialmente perceptível quando uma transação requer várias confirmações.
Nos nós de teste públicos, é possível o cache agressivo.
Além disso, eles podem ficar temporariamente indisponíveis devido a manutenção técnica.

A partir de agora, assumirei que você está trabalhando com seu próprio nó.

2. Ferramenta de linha de comando Surfboard

Baixe e instale o Node.js usando ppa, homebrew ou exe aqui: https://nodejs.org/en/download/.
Instale o Surfboard — uma ferramenta que permitirá executar testes em um nó existente.

npm install -g @waves/surfboard

3. Plugin do Visual Studio Code

Esta etapa é opcional, se você não for fã de IDEs e preferir editores de texto. Todas as ferramentas necessárias são utilitários de linha de comando. Se você usa vim, atente-se ao plugin vim-ride.

Baixe e instale o Visual Studio Code: https://code.visualstudio.com/

Abra o VS Code e instale o plugin waves-ride:

Extensão do navegador Waves Keeper: https://wavesplatform.com/products-keeper

Pronto!

Inicie o nó e o Waves Explorer

1. Inicie o nó:

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

Verifique se o nó está sendo iniciado via REST API em http://localhost:6869:

Interface Swagger REST API para o nó

2. Inicie uma instância do Waves Explorer:

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

Abra o navegador e vá para http://localhost:3000. Você verá como uma cadeia vazia da rede local é construída rapidamente.

O Waves Explorer exibe uma instância do nó local

Estrutura do RIDE e ferramenta Surfboard

Crie um diretório vazio e execute o comando

surfboard init

O comando inicializa o diretório com a estrutura do projeto, um aplicativo do tipo 'hello world' e testes. Se você abrir esta pasta com o VS Code, verá:

Surfboard.config.json

Na pasta .\/ride\/ você encontrará um único arquivo wallet.ride – o diretório onde está o código do dApp. Vamos analisar brevemente o dApp no próximo bloco.
Na pasta .\/test\/ você encontrará o arquivo *.js. Aqui estão armazenados os testes.
.\/surfboard.config.json – é o arquivo de configuração para executar os testes.

Envs – uma seção importante. Cada ambiente é configurado da seguinte maneira:

O ponto final da API REST da node que será usado para executar o dApp e o CHAIN_ID da rede.
A frase secreta para a conta com tokens, que serão as fontes de tokens do seu teste.

Como você pode ver, o surfboard.config.json suporta várias ambientes por padrão. O ambiente local é a configuração padrão (o parâmetro defaultEnv é um parâmetro modificável).

O aplicativo Wallet-demo

Esta seção não é um guia sobre a linguagem RIDE. Em vez disso, é um olhar sobre o aplicativo que estamos implantando e testando para entender melhor o que está acontecendo na blockchain.

Vamos considerar o aplicativo Wallet-demo. Qualquer um pode enviar tokens para o endereço do dApp. Somente os seus WAVES podem ser retirados. Duas funções @Callable estão disponíveis através da InvokeScriptTransaction:

deposit(), que requer um pagamento anexado em WAVES
withdraw(amount: Int), que retorna tokens

Ao longo do ciclo de vida do dApp, a estrutura (endereço → quantidade) será mantida:

Ações
Estado resultante

inicial
vazio

Alice deposita 5 WAVES
alice-address → 500000000

Bob deposita 2 WAVES

alice-address → 500000000
bob-address → 200000000

Bob retira 7 WAVES
DENIED!

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

Aqui está o código para uma compreensão completa da situação:

# 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

Um exemplo de código pode ser encontrado também em GitHub.

O plugin VSCode suporta a compilação contínua ao editar o arquivo. Portanto, você pode sempre monitorar os erros na aba PROBLEMS.

Se você quiser usar outro editor de texto ao compilar o arquivo, use

surfboard compile ride\/wallet.ride

Isso irá gerar uma série de códigos RIDE compilados em base64.

Cenário de teste para ‘wallet.ride’

Vamos olhar para o arquivo de teste. Funciona no framework Mocha do JavaScript. Há uma função 'Before' e três testes:

‘Before’ financia várias contas através da MassTransferTransaction, compila o script e o implanta na blockchain.
‘Can deposit’ envia uma InvokeScriptTransaction para a rede, ativando a função deposit() para cada uma das duas contas.
‘Can’t withdraw more than was deposited’ testa que ninguém pode roubar os tokens dos outros.
‘Can deposit’ verifica que os saques são processados corretamente.

Executando testes com Surfboard e analisando os resultados no Waves Explorer

Para executar o teste, execute

surfboard test

Se você tem vários cenários (por exemplo, precisa de um script de deploy separado), pode executar

surfboard test my-scenario.js

O Surfboard irá reunir arquivos de teste na pasta .\/test\/ e executará o script no nó que está configurado no surfboard.config.json. Após alguns segundos, você verá algo como:

wallet test suite
Gerando contas com nonce: ce8d86ee
Conta gerada: foofoofoofoofoofoofoofoofoofoofoo#ce8d86ee - 3M763WgwDhmry95XzafZedf7WoBf5ixMwhX
Conta gerada: barbarbarbarbarbarbarbarbarbar#ce8d86ee - 3MAi9KhwnaAk5HSHmYPjLRdpCAnsSFpoY2v
Conta gerada: wallet#ce8d86ee - 3M5r6XYMZPUsRhxbwYf1ypaTB6MNs2Yo1Gb
Contas financiadas com sucesso
Script foi definido
   √ Pode depositar (4385ms)
   √ Não pode retirar mais do que foi depositado
   √ Pode retirar (108ms)
3 passando (15s)

Uhul! Os testes foram aprovados. Agora vamos dar uma olhada no que acontece ao usar o Waves Explorer: vamos visualizar os blocos ou colar um dos endereços acima na busca (por exemplo, correspondente wallet#. Lá, você pode encontrar o histórico de transações, o estado do dApp, o binário decompilado.

Waves Explorer. Um aplicativo que acaba de ser implantado.

Algumas dicas sobre o Surfboard:

1. Para testar no ambiente testnet, use:

surfboard test --env=testnet

Obter tokens de teste

2. Se quiser ver as versões JSON das transações e como elas são processadas pelo nó, execute o teste com -v (significa 'verbose'):

surfboard test -v

Usando aplicativos com o Waves Keeper

1. Configure o Waves Keeper para funcionar: http://localhost:6869

Configuração do Waves Keeper para trabalhar com um nó local

2. Importar uma frase secreta com tokens para a rede? Para facilidade, use o seed inicial do seu nó: waves private node seed with waves tokens. Endereço: 3M4qwDomRabJKLZxuXhwfqLApQkU592nWxF.

3. Você pode executar um aplicativo sem servidor em página única por conta própria, usando npm. Ou vá para um existente: chrome-ext.wvservices.com\/dapp-wallet.html

4. Cole o endereço da carteira da execução de teste (sublinhado acima) no campo de texto do endereço dApp

5. Digite um pequeno valor no campo 'Deposit' e clique no botão:

O Waves Keeper solicita permissão para assinar a InvokeScriptTransaction com um pagamento de 10 WAVES.