Õpime kirjutama Waves’i nutilepinguid RIDE ja RIDE4DAPPS keeles. 2. osa (DAO – detsentraliseeritud autonoomne organisatsioon)

Tere kõigile!

Uues esimene osa, me käsitleme üksikasjalikult, kuidas luua ja töötada dApp-i (detsentraliseeritud rakenduse) juures Waves RIDE IDE.

Testime nüüd veidi lahti võetud näide.

Etapp 3. dApp konto testimine

Millised probleemid esmapilgul Alice'i juures silma hakkavad dApp Konto?
Esiteks:
Boob ja Cooper võivad juhuslikult saata dApp aadressile raha tavalise ülekandmine tehingu kaudu ja seega ei pääse nad sellele enam juurde.

Teiseks:
Me ei piira Alice'i raha väljavõtmist Boobi või Cooperiga kooskõlastamise nõudmisest. Pidage meeles, et kõik Alice'i tehingud täidetakse.

Parandame teise, keelates Alice'il ülekandmine tehingud. Rakendame parandatud skripti:


Proovime väljavõtteid Alice'i dAppist ja tema allkirjast. Saame vea:

Proovime väljavõttes:

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

Skript töötab ja 2. punkt on selge!

Etapp 4. Loome DAO häältega

Kahjuks ei saa RIDE keeles praegu töötada kollektsioonidega (sõnastikud, iteratorid, vähendajad jne). Siiski, kõiki operatsioone tasapinnaliste kollektsioonidega key-value saame planeerida süstemaatika stringide, vastavalt võtmete ja nende dešifreerimisega.

Stringe on väga lihtne konkateneerida, stringe saab jagada indeksite järgi.
Kogume ja analüüsime stringi testnäitena ning kontrollime, kuidas see mõjutab tehingu tulemust.
Keskendume sellele, et Alice ei saanud Transfer tehingut allkirjastada, kuna see võimalus oli @verifieris blokeeritud selliste tehingute jaoks.

Haarame stringide kasutamisega ja seejärel lubame selle.

RIDE stringid

Tehing on taas võimalik, oskame töötada stringidega.


Kokkuvõttes on meil kõik vajalik keerulise loogika kirjutamiseks DAO dApp.

Andmete tehingud

Andmete tehingud:
„Võtme maksimaalne suurus on 100 tähemärki, ja võtmel võivad olla juhuslikud Unicode koodipunktid, sealhulgas tühikud ja muud mitteprinditavad sümbolid. Stringi väärtustel on piirang 32 768 baiti ja andmete tehingus on maksimaalne sisestuste arv 100. Üldiselt on andmete tehingu maksimaalne suurus umbes 140 kb — viiteks, justkui William Shakespeare'i näidend 'Romeo ja Julia' pikkus.”

Loome DAO järgmiste tingimustega:
Et startup saaks rahastust, kutsudes esile getFunds() on vajalik vähemalt 2 DAO osalise – investorite toetust. Väljasta saab olema täpselt nii palju, kui kokku hääletati DAO omanike poolt. владельцы DAO.

Teeme 3 tüüpi võtmeid ja lisame tasakaalude haldamise loogika kahe uue funktsiooni, vote ja getFunds, kaudu:
xx…xx_ia = investorid, saadaval tasakaal (vote, deposit, withdrawal)
xx…xx_sv = startupid, häälte arv (vote, getFunds)
xx…xx_sf = startupid, häälte arv (vote, getFunds)
xx…xx = avalik aadress (35 tähte)

Pange tähele, et Vote'is pidi me värskendama korraga mitmeid välju:

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

WriteSet võimaldab meil teha korraga mitu kirjet ühe invokeScript tehingu raames.

Nii see välja näeb DAO dApp key-value salvestuses, pärast seda, kui Bob ja Cooper on fondi täiendanud ia-deposiid:

Deposiidi funktsioon on meil pisut muutunud:

Nüüd on käes kõige olulisem moment DAO tegevuses — hääletamine projektide rahastamise poolt.

Bob hääletab projekti Neli poolt 500000 waveletiga:

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

Andmehoidlas näeme kõik vajalikud kirjed Neli aadressi jaoks:

Cooper hääletas samuti projekti Neli poolt.

Vaatame koodi funktsioonist getFunds. Neli peab koguma vähemalt 2 häält, et saada võimalus eraldada vahendeid DAO-st.

Neli kavatseb välja võtta poole talle usaldatud summast:

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

Tal õnnestub see, mis tähendab, et DAO töötab!

Me käsitlesime DAO loomise protsessi keeles RIDE4DAPPS.
Järgmistes osades käsitleme koodi refaktoreerimist ja testimist.

Koodi täisversioon 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
    }
}

Esimene osa
Kood GitHubis
Waves RIDE IDE
Grantide programmi teadaanne

Allikas: habr.com