Discens scribere undas captiosas contractus in RITE et RIDE4DAPPS. Pars II (DAO - Decentralized sui iuris)

Всем привет!

В primus parte perspeximus singillatim quomodo creare et opus cum dApp (decentralized application) in Fluctus EO IDE.

Experiamur paulo disassembled nunc exempli gratia.

Testis 3. scaena propter dApp

Quae problemata statim prosiliunt ad te cum Alicia? Dapp Ideo?
Uno modo,
Boob et Cooper accidens mittere pecunia ad dApp oratio uti regularis translatio transactiones et sic ad eas accedere non poterunt.

Secundo:
Alicie nullo modo restringere debemus a pecunia recedere sine approbatione Boob et/vel Cooperis. Cum verificandum attendere, omnes res ab Alicia exsecutae erunt.

Sit scriptor fix 2 prohibendo Alice translatio geruntur. Lets scriptor emendatior explicandam:


Denarios ab dApp Alicie et subscriptione eius retrahere conamur. Errorem dabimus:

Recedere per experimentum est recedere:

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

Scriptum opera et punctum alterum figuravimus!

Scaena 4. crea in DAO cum suffragiis

Infeliciter, lingua vehi nondum facultatem praebet ad operandum cum collectionibus (dictionariis dictionariis, iteratoribus, reductoribus, etc.). Sed pro quibusvis operationibus in collectionibus planis key-valorem chordarum operandi rationem possumus designare, proinde cum clavibus eorumque decryption.

Fila facillime concatenata sunt, chordae indicibus separari possunt.
Filum in exemplum experiendi colligam et parse et inspicias quomodo hoc eventum rei gerendae afficiat.
Constituimus in eo quod Alicia translationem transactionis subscribere non potuit, cum haec facultas in @verifier ob huiusmodi transactionis clausus esset.

Cum chordis exerceamus et deinde hoc componamus.

EQUES Gloria

Rei iterum fieri potest, scimus quomodo cum chordis laborare possit.


In summa omnia habemus necessaria ad logicam scribendam DAO dApp.

Data Transactions

Data Acta:
“Maximae magnitudinis clavis est 100 characteres, et clavis arbitraria Unicode puncta inclusa spatia et alia symbola non printable continere possunt. Valores chordae limes habent 32,768 bytes et numerus maximus introitus in notitia transactionis possibiles est 100. Super, maxima amplitudo transactionis datae circa 140kb est - nam relatio, fere longitudo Shakespeare fabulae 'Romaeo et Iuliae'. ".

DAO creamus cum sequentibus conditionibus:
Ut a satus funding accipere per vocantem getFunds () auxilium saltem 2 participantium - DAO investorsorum requiritur -. recedere fiet prorsus ut summa indicata est suffragatio DAO dominis.

3 genera clavium faciamus et logicam adiiciamus ad operandum cum statera in 2 novis functionibus suffragio et getFunds:
xx_ia = investors, praesto statera (suffragium, depositum, detractio)
xx_sv = satus, numerus suffragiorum (suffragium, getFunds)
xx_sf = satus, numerus suffragiorum (suffragium, getFunds)
xx…xx = oratio publica (35 characters)

Nota quaeso quod in Suffragio ad plures simul agros renovandos opus erat:

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

WriteSet nos permittit ut plura simul in uno monumenta facere invokeScript geruntur.

Hoc est quod spectat sicut in repositione clavem-pretii DAO dApp, postquam Bob et Cooper repleti sunt ia-deposits:

Munus depositi nostri leviter mutata:

Nunc maxime momenti in operationibus DAO - suffragium ad consilia dotatae.

Bob suffragiorum Neli 500000 undis project:

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

In notitia copia cernimus omnes introitus necessarii pro inscriptione Neli:

Cooper etiam in Neli consilium suffragatus est.

Vide munus sit in codice getFunds. Neli debet minimum 2 suffragiorum colligere quod pecunia a DAO recedere possit.

Neli recederet medietatem pecuniae sibi commissae;

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

Successit, id est, DAO opera!

Processum in lingua creandi DAO inspeximus RIDE4DAPPS.
In sequentibus partibus propius inspiciamus codicem reformationis et casus probationis.

Plena versio codicis in UNDA EO 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
    }
}

In prima parte,
Code in GitHub
Fluctus EO IDE
Nuntius progressio concessionis

Source: www.habr.com