Lär dig skriva Waves smarta kontrakt på RIDE och RIDE4DAPPS. Del 2 (DAO - Decentraliserad autonom organisation)

Hej alla!

В först del tittade vi i detalj på hur man skapar och arbetar med dApp (decentraliserad applikation) i Waves RIDE IDE.

Låt oss testa den demonterade lite nu exempel.

Steg 3. Testa dApp-kontot

Vilka problem drabbar dig omedelbart med Alice? Dapp Konto?
För det första:
Boob och Cooper kan av misstag skicka pengar till dApp-adressen med vanliga överföring transaktioner och kommer därför inte att kunna komma åt dem tillbaka.

För det andra:
Vi hindrar inte Alice på något sätt från att ta ut pengar utan godkännande av Boob och/eller Cooper. Eftersom, var uppmärksam på att verifiera, kommer alla transaktioner från Alice att utföras.

Låt oss fixa 2:an genom att förbjuda Alice överföring transaktioner. Låt oss distribuera det korrigerade skriptet:


Vi försöker ta ut mynt från dApp Alice och hennes signatur. Vi får ett felmeddelande:

Låt oss försöka dra tillbaka via dra ut:

broadcast(invokeScript({dappAddress: address(env.accounts[1]), call:{function:"withdraw",args:[{type:"integer", value: 1000000}]}, payment: []}))

Manuset fungerar och vi kom på den andra punkten!

Steg 4. Skapa en DAO med röstning

Tyvärr ger RIDE-språket ännu inte möjligheten att arbeta med samlingar (ordboksordböcker, iteratorer, reducerare, etc.). Dock för alla operationer med platta samlingar nyckelvärde vi kan designa ett system för att arbeta med strängar, i enlighet därmed med nycklar och deras dekryptering.

Strängar är mycket lätta att sammanfoga; strängar kan separeras med index.
Låt oss samla och analysera en sträng som ett testexempel och kontrollera hur detta påverkar resultatet av transaktionen.
Vi bestämde oss för att Alice inte kunde underteckna överföringstransaktionen, eftersom denna möjlighet var blockerad i @verifier för denna typ av transaktion.

Låt oss öva med strängar och sedan lösa detta.

RIDE Strings

Transaktionen är möjlig igen, vi vet hur man arbetar med strängar.


Totalt har vi allt som behövs för att skriva komplex logik DAO dApp.

Datatransaktioner

Datatransaktioner:
"Den maximala storleken för en nyckel är 100 tecken, och en nyckel kan innehålla godtyckliga Unicode-kodpunkter inklusive mellanslag och andra icke-utskrivbara symboler. Strängvärden har en gräns på 32,768 100 byte och det maximala antalet möjliga poster i datatransaktionen är 140. Totalt sett är den maximala storleken på en datatransaktion cirka XNUMX kb - för referens, nästan exakt längden på Shakespeares pjäs 'Romeo och Julia' '.

Vi skapar en DAO med följande villkor:
För att en startup ska få finansiering genom att ringa getFunds() stöd från minst 2 deltagare - DAO-investerare - krävs. dra tillbaka det kommer att vara möjligt exakt så mycket som summan som anges på röstning DAO-ägare.

Låt oss skapa 3 typer av nycklar och lägga till logik för att arbeta med saldon i 2 nya funktioner rösta och getFunds:
xx…xx_ia = investerare, tillgängligt saldo (rösta, insättning, uttag)
xx…xx_sv = startups, antal röster (rösta, getFunds)
xx…xx_sf = startups, antal röster (rösta, getFunds)
xx…xx = offentlig adress (35 tecken)

Observera att vi i Vote behövde uppdatera flera fält samtidigt:

WriteSet([DataEntry(key1, value1), DataEntry(key2, value2)]),

WriteSet tillåter oss att göra flera poster samtidigt inom en invokeScript transaktioner.

Så här ser det ut i nyckel-värde-lagringen av DAO dApp, efter att Bob och Cooper fyllt på ia-insättningar:

Vår insättningsfunktion har ändrats något:

Nu kommer det viktigaste ögonblicket i DAO:s verksamhet - rösta för projekt som ska finansieras.

Bob röstar på Nelis 500000 XNUMX wavelets-projekt:

broadcast(invokeScript({dappAddress: address(env.accounts[1]), call:{function:"vote",args:[{type:"integer", value: 500000}, {type:"string", value: "3MrXEKJr9nDLNyVZ1d12Mq4jjeUYwxNjMsH"}]}, payment: []}))

I datalagret ser vi alla nödvändiga poster för Nelis adress:

Cooper röstade också på Neli-projektet.

Låt oss ta en titt på funktionskoden getFunds. Neli måste samla minst 2 röster för att kunna ta ut pengar från DAO.

Neli kommer att ta ut hälften av det belopp som hon anförtrotts:

broadcast(invokeScript({dappAddress: address(env.accounts[1]), call:{function:"getFunds",args:[{type:"integer", value: 500000}]}, payment: []}))

Hon lyckas, det vill säga DAO fungerar!

Vi tittade på processen att skapa en DAO på språket RIDE4DAPPS.
I de följande delarna kommer vi att titta närmare på kodrefaktorering och falltestning.

Den fullständiga versionen av koden i Waves RIDE IDE:

# In this example multiple accounts can deposit their funds to DAO and safely take them back, no one can interfere with this.
# DAO participants can also vote for particular addresses and let them withdraw invested funds then quorum has reached.
# An inner state is maintained as mapping `address=>waves`.
# https://medium.com/waves-lab/waves-announces-funding-for-ride-for-dapps-developers-f724095fdbe1

# You can try this contract by following commands in the IDE (ide.wavesplatform.com)
# Run commands as listed below
# From account #0:
#      deploy()
# From account #1: deposit funds
#      broadcast(invokeScript({dappAddress: address(env.accounts[1]), call:{function:"deposit",args:[]}, payment: [{amount: 100000000, asset:null }]}))
# From account #2: deposit funds
#      broadcast(invokeScript({dappAddress: address(env.accounts[1]), call:{function:"deposit",args:[]}, payment: [{amount: 100000000, asset:null }]}))
# From account #1: vote for startup
#      broadcast(invokeScript({dappAddress: address(env.accounts[1]), call:{function:"vote",args:[{type:"integer", value: 500000}, {type:"string", value: "3MrXEKJr9nDLNyVZ1d12Mq4jjeUYwxNjMsH"}]}, payment: []}))
# From account #2: vote for startup
#      broadcast(invokeScript({dappAddress: address(env.accounts[1]), call:{function:"vote",args:[{type:"integer", value: 500000}, {type:"string", value: "3MrXEKJr9nDLNyVZ1d12Mq4jjeUYwxNjMsH"}]}, payment: []}))
# From account #3: get invested funds
#      broadcast(invokeScript({dappAddress: address(env.accounts[1]), call:{function:"getFunds",args:[{type:"integer", value: 500000}]}, payment: []}))

{-# STDLIB_VERSION 3 #-}
{-# CONTENT_TYPE DAPP #-}
{-# SCRIPT_TYPE ACCOUNT #-}

@Callable(i)
func deposit() = {
   let pmt = extract(i.payment)
   if (isDefined(pmt.assetId)) then throw("can hodl waves only at the moment")
   else {
        let currentKey = toBase58String(i.caller.bytes)
        let xxxInvestorBalance = currentKey + "_" + "ib"
        let currentAmount = match getInteger(this, xxxInvestorBalance) {
            case a:Int => a
            case _ => 0
        }
        let newAmount = currentAmount + pmt.amount
        WriteSet([DataEntry(xxxInvestorBalance, newAmount)])
   }
}
@Callable(i)
func withdraw(amount: Int) = {
        let currentKey = toBase58String(i.caller.bytes)
        let xxxInvestorBalance = currentKey + "_" + "ib"
        let currentAmount = match getInteger(this, xxxInvestorBalance) {
            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(xxxInvestorBalance, newAmount)]),
                    TransferSet([ScriptTransfer(i.caller, amount, unit)])
                )
    }
@Callable(i)
func getFunds(amount: Int) = {
        let quorum = 2
        let currentKey = toBase58String(i.caller.bytes)
        let xxxStartupFund = currentKey + "_" + "sf"
        let xxxStartupVotes = currentKey + "_" + "sv"
        let currentAmount = match getInteger(this, xxxStartupFund) {
            case a:Int => a
            case _ => 0
        }
        let totalVotes = match getInteger(this, xxxStartupVotes) {
            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 if (totalVotes < quorum)
            then throw("Not enough votes. At least 2 votes required!")
    else ScriptResult(
                    WriteSet([
                        DataEntry(xxxStartupFund, newAmount)
                        ]),
                    TransferSet([ScriptTransfer(i.caller, amount, unit)])
                )
    }
@Callable(i)
func vote(amount: Int, address: String) = {
        let currentKey = toBase58String(i.caller.bytes)
        let xxxInvestorBalance = currentKey + "_" + "ib"
        let xxxStartupFund = address + "_" + "sf"
        let xxxStartupVotes = address + "_" + "sv"
        let currentAmount = match getInteger(this, xxxInvestorBalance) {
            case a:Int => a
            case _ => 0
        }
        let currentVotes = match getInteger(this, xxxStartupVotes) {
            case a:Int => a
            case _ => 0
        }
        let currentFund = match getInteger(this, xxxStartupFund) {
            case a:Int => a
            case _ => 0
        }
    if (amount <= 0)
            then throw("Can't withdraw negative amount")
    else if (amount > currentAmount)
            then throw("Not enough balance")
    else ScriptResult(
                    WriteSet([
                        DataEntry(xxxInvestorBalance, currentAmount - amount),
                        DataEntry(xxxStartupVotes, currentVotes + 1),
                        DataEntry(xxxStartupFund, currentFund + amount)
                        ]),
                    TransferSet([ScriptTransfer(i.caller, amount, unit)])
            )
    }
@Verifier(tx)
func verify() = {
    match tx {
        case t: TransferTransaction =>false
        case _ => true
    }
}

Den första delen
Kod på GitHub
Waves RIDE IDE
Tillkännagivande av bidragsprogrammet

Källa: will.com