ვისწავლეთ Waves ჭკვიანი კონტრაქტების დაწერა RIDE-ზე და RIDE4DAPPS-ზე. ნაწილი 2 (DAO - დეცენტრალიზებული ავტონომიური ორგანიზაცია)

გაუმარჯოს ყველას!

В პირველი ნაწილი, ჩვენ დეტალურად განვიხილეთ, თუ როგორ უნდა შევქმნათ და ვიმუშაოთ dApp-ში (დეცენტრალიზებული აპლიკაცია). Waves RIDE IDE.

ახლა ცოტა გავსინჯოთ დაშლილი მაგალითად.

ეტაპი 3. dApp ანგარიშის ტესტირება

რა პრობლემები შეგექმნათ მაშინვე ალისასთან? დოპ ანგარიში?
პირველ რიგში:
Boob-მა და Cooper-მა შეიძლება შემთხვევით გაგზავნონ თანხები dApp-ის მისამართზე რეგულარული გამოყენებით გადარიცხვა ტრანზაქციები და, შესაბამისად, ვერ შეძლებთ მათზე წვდომას.

მეორე:
ჩვენ არანაირად არ ვზღუდავთ ალისას თანხების გამოტანას ბუბის და/ან კუპერის თანხმობის გარეშე. ვინაიდან, ყურადღება მიაქციეთ გადამოწმებას, ალისიდან ყველა ტრანზაქცია შესრულდება.

გამოვასწოროთ მე-2 ალისის აკრძალვით გადარიცხვა გარიგებები. მოდით განვათავსოთ შესწორებული სკრიპტი:


ჩვენ ვცდილობთ გამოვიტანოთ მონეტები dApp Alice-დან და მისი ხელმოწერიდან. ჩვენ ვიღებთ შეცდომას:

შევეცადოთ გაყვანა გაყვანის გზით:

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

სცენარი მუშაობს და ჩვენ გავარკვიეთ მე-2 წერტილი!

ეტაპი 4. შექმენით DAO ხმის მიცემით

სამწუხაროდ, RIDE ენა ჯერ კიდევ არ იძლევა კოლექციებთან მუშაობის შესაძლებლობას (ლექსიკონების ლექსიკონები, იტერატორები, რედუქტორები და ა.შ.). თუმცა, ნებისმიერი ოპერაციებისთვის ბრტყელი კოლექციებით საკვანძო მნიშვნელობა ჩვენ შეგვიძლია შევქმნათ სისტემა სტრიქონებთან მუშაობისთვის, შესაბამისად გასაღებებით და მათი გაშიფვრით.

სტრიქონების შეერთება ძალიან ადვილია; სტრიქონები შეიძლება გამოიყოს ინდექსებით.
მოდით შევაგროვოთ და გავაანალიზოთ სტრიქონი, როგორც სატესტო მაგალითი და შევამოწმოთ, როგორ იმოქმედებს ეს გარიგების შედეგზე.
ჩვენ დავთანხმდით იმ ფაქტზე, რომ ალისამ ვერ მოაწერა ხელი გადაცემის ტრანზაქციას, რადგან ეს შესაძლებლობა დაბლოკილი იყო @verifier-ში ამ ტიპის ტრანზაქციისთვის.

მოდით ვივარჯიშოთ სტრიქონებით და შემდეგ მოვაგვაროთ ეს.

RIDE სიმები

ტრანზაქცია ისევ შესაძლებელია, ჩვენ ვიცით როგორ ვიმუშაოთ სტრიქონებთან.


საერთო ჯამში ყველაფერი გვაქვს რთული ლოგიკის დასაწერად DAO dApp.

მონაცემთა ტრანზაქციები

მონაცემთა ტრანზაქციები:
„გასაღების მაქსიმალური ზომა არის 100 სიმბოლო და გასაღები შეიძლება შეიცავდეს თვითნებურ უნიკოდის კოდის წერტილებს, მათ შორის სივრცეებს ​​და სხვა დაუბეჭდავ სიმბოლოებს. სტრიქონების მნიშვნელობებს აქვთ 32,768 ბაიტის ლიმიტი და მონაცემთა ტრანზაქციაში შესაძლო ჩანაწერების მაქსიმალური რაოდენობაა 100. საერთო ჯამში, მონაცემთა ტრანზაქციის მაქსიმალური ზომაა დაახლოებით 140 კბ - ცნობისთვის, თითქმის ზუსტად შექსპირის პიესის "რომეო და ჯულიეტა" სიგრძე. ''.

ჩვენ ვქმნით DAO-ს შემდეგი პირობებით:
იმისათვის, რომ სტარტაპმა მიიღოს დაფინანსება დარეკვით getFunds () საჭიროა მინიმუმ 2 მონაწილის - DAO ინვესტორების მხარდაჭერა. გაყვანა შესაძლებელი იქნება ზუსტად იმდენი, რამდენიც მითითებულია ხმის მიცემა DAO-ს მფლობელები.

მოდით გავაკეთოთ 3 ტიპის გასაღები და დავამატოთ ლოგიკა ნაშთებთან მუშაობისთვის 2 ახალ ფუნქციაში ხმის მიცემა და მიიღეთFunds:
xx…xx_ია = ინვესტორები, ხელმისაწვდომი ბალანსი (ხმის მიცემა, დეპოზიტი, გატანა)
xx…xx_სვ = სტარტაპები, ხმების რაოდენობა (ხმის მიცემა, მიიღეთ სახსრები)
xx…xx_სფ = სტარტაპები, ხმების რაოდენობა (ხმის მიცემა, მიიღეთ სახსრები)
xx…xx = საჯარო მისამართი (35 სიმბოლო)

გთხოვთ, გაითვალისწინოთ, რომ Vote-ში გვჭირდებოდა ერთდროულად რამდენიმე ველის განახლება:

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

WriteSet საშუალებას გვაძლევს გავაკეთოთ რამდენიმე ჩანაწერი ერთდროულად ერთში invokeScript გარიგებები.

ასე გამოიყურება DAO dApp-ის გასაღების მნიშვნელობის საცავში, მას შემდეგ, რაც ბობ და კუპერი შეავსეს ia- დეპოზიტები:

ჩვენი ანაბრის ფუნქცია ოდნავ შეიცვალა:

ახლა მოდის ყველაზე მნიშვნელოვანი მომენტი DAO-ს საქმიანობაში - ხმის მიცემა დასაფინანსებელი პროექტებისთვის.

ბობ ხმას აძლევს ნელის 500000 ტალღის პროექტს:

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

მონაცემთა მაღაზიაში ჩვენ ვხედავთ ყველა საჭირო ჩანაწერს ნელის მისამართისთვის:

კუპერმა ასევე ხმა მისცა ნელის პროექტს.

მოდით შევხედოთ ფუნქციის კოდს მიიღეთ ფონდები. ნელიმ უნდა შეაგროვოს მინიმუმ 2 ხმა, რომ შეძლოს თანხების ამოღება DAO-დან.

ნელი აპირებს მისთვის მინდობილი თანხის ნახევრის ამოღებას:

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

ის წარმატებას მიაღწევს, ანუ DAO მუშაობს!

ჩვენ გადავხედეთ ენაზე DAO-ს შექმნის პროცესს RIDE4DAPPS.
შემდეგ ნაწილებში ჩვენ უფრო დეტალურად განვიხილავთ კოდის რეფაქტორირებას და შემთხვევის ტესტირებას.

კოდის სრული ვერსია 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
    }
}

პირველი ნაწილი
კოდი GitHub-ზე
Waves RIDE IDE
საგრანტო პროგრამის განცხადება

წყარო: www.habr.com