RIDE ಮತ್ತು RIDE4DAPPS ನಲ್ಲಿ ವೇವ್ಸ್ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದಗಳನ್ನು ಬರೆಯಲು ಕಲಿಯುವುದು. ಭಾಗ 2 (DAO - ವಿಕೇಂದ್ರೀಕೃತ ಸ್ವಾಯತ್ತ ಸಂಸ್ಥೆ)

ಎಲ್ಲರೂ ಹಲೋ!

В ಮೊದಲನೆಯದು dApp (ವಿಕೇಂದ್ರೀಕೃತ ಅಪ್ಲಿಕೇಶನ್) ಅನ್ನು ಹೇಗೆ ರಚಿಸುವುದು ಮತ್ತು ಕೆಲಸ ಮಾಡುವುದು ಎಂಬುದರ ಕುರಿತು ನಾವು ವಿವರವಾಗಿ ನೋಡಿದ್ದೇವೆ ಅಲೆಗಳು ರೈಡ್ IDE.

ಡಿಸ್ಅಸೆಂಬಲ್ ಮಾಡಿದ ಒಂದನ್ನು ಈಗ ಸ್ವಲ್ಪ ಪರೀಕ್ಷಿಸೋಣ ಉದಾಹರಣೆ.

ಹಂತ 3. dApp ಖಾತೆಯನ್ನು ಪರೀಕ್ಷಿಸಲಾಗುತ್ತಿದೆ

ಆಲಿಸ್‌ನೊಂದಿಗೆ ಯಾವ ಸಮಸ್ಯೆಗಳು ತಕ್ಷಣವೇ ನಿಮ್ಮನ್ನು ಎದುರಿಸುತ್ತವೆ? dApp ಖಾತೆ?
ಮೊದಲಿಗೆ:
ಬೂಬ್ ಮತ್ತು ಕೂಪರ್ ಆಕಸ್ಮಿಕವಾಗಿ ನಿಯಮಿತವಾಗಿ ಬಳಸಿಕೊಂಡು dApp ವಿಳಾಸಕ್ಕೆ ಹಣವನ್ನು ಕಳುಹಿಸಬಹುದು ವರ್ಗಾವಣೆ ವಹಿವಾಟುಗಳು ಮತ್ತು ಹೀಗಾಗಿ ಅವುಗಳನ್ನು ಮರಳಿ ಪ್ರವೇಶಿಸಲು ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ.

ಎರಡನೆಯದಾಗಿ:
ಬೂಬ್ ಮತ್ತು/ಅಥವಾ ಕೂಪರ್‌ನ ಅನುಮೋದನೆಯಿಲ್ಲದೆ ಹಣವನ್ನು ಹಿಂತೆಗೆದುಕೊಳ್ಳುವುದರಿಂದ ನಾವು ಆಲಿಸ್ ಅನ್ನು ಯಾವುದೇ ರೀತಿಯಲ್ಲಿ ನಿರ್ಬಂಧಿಸುವುದಿಲ್ಲ. ಪರಿಶೀಲಿಸಲು ಗಮನ ಕೊಡಿ, ಆಲಿಸ್‌ನಿಂದ ಎಲ್ಲಾ ವಹಿವಾಟುಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ.

ಆಲಿಸ್ ಅವರನ್ನು ನಿಷೇಧಿಸುವ ಮೂಲಕ 2 ನೇದನ್ನು ಸರಿಪಡಿಸೋಣ ವರ್ಗಾವಣೆ ವಹಿವಾಟುಗಳು. ಸರಿಪಡಿಸಿದ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ನಿಯೋಜಿಸೋಣ:


ನಾವು dApp ಆಲಿಸ್ ಮತ್ತು ಅವರ ಸಹಿಯಿಂದ ನಾಣ್ಯಗಳನ್ನು ಹಿಂಪಡೆಯಲು ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದೇವೆ. ನಾವು ದೋಷವನ್ನು ಪಡೆಯುತ್ತೇವೆ:

ಹಿಂತೆಗೆದುಕೊಳ್ಳುವ ಮೂಲಕ ಹಿಂಪಡೆಯಲು ಪ್ರಯತ್ನಿಸೋಣ:

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

ಸ್ಕ್ರಿಪ್ಟ್ ಕೆಲಸ ಮಾಡುತ್ತದೆ ಮತ್ತು ನಾವು 2 ನೇ ಅಂಶವನ್ನು ಕಂಡುಕೊಂಡಿದ್ದೇವೆ!

ಹಂತ 4. ಮತದಾನದೊಂದಿಗೆ DAO ಅನ್ನು ರಚಿಸಿ

ದುರದೃಷ್ಟವಶಾತ್, RIDE ಭಾಷೆಯು ಸಂಗ್ರಹಣೆಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಸಾಮರ್ಥ್ಯವನ್ನು ಇನ್ನೂ ಒದಗಿಸಿಲ್ಲ (ನಿಘಂಟಿನ ನಿಘಂಟುಗಳು, ಪುನರಾವರ್ತಕಗಳು, ಕಡಿತಗೊಳಿಸುವವರು, ಇತ್ಯಾದಿ.). ಆದಾಗ್ಯೂ, ಫ್ಲಾಟ್ ಸಂಗ್ರಹಗಳೊಂದಿಗೆ ಯಾವುದೇ ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ ಕೀ-ಮೌಲ್ಯ ನಾವು ತಂತಿಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ವ್ಯವಸ್ಥೆಯನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸಬಹುದು, ಅದರ ಪ್ರಕಾರ ಕೀಗಳು ಮತ್ತು ಅವುಗಳ ಡೀಕ್ರಿಪ್ಶನ್.

ತಂತಿಗಳನ್ನು ಜೋಡಿಸಲು ತುಂಬಾ ಸುಲಭ; ತಂತಿಗಳನ್ನು ಸೂಚ್ಯಂಕಗಳಿಂದ ಬೇರ್ಪಡಿಸಬಹುದು.
ಪರೀಕ್ಷಾ ಉದಾಹರಣೆಯಾಗಿ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಸಂಗ್ರಹಿಸಿ ಮತ್ತು ಪಾರ್ಸ್ ಮಾಡೋಣ ಮತ್ತು ಇದು ವಹಿವಾಟಿನ ಫಲಿತಾಂಶದ ಮೇಲೆ ಹೇಗೆ ಪರಿಣಾಮ ಬೀರುತ್ತದೆ ಎಂಬುದನ್ನು ಪರಿಶೀಲಿಸೋಣ.
ಈ ರೀತಿಯ ವಹಿವಾಟಿಗಾಗಿ @verifier ನಲ್ಲಿ ಈ ಸಾಮರ್ಥ್ಯವನ್ನು ನಿರ್ಬಂಧಿಸಿರುವುದರಿಂದ ಆಲಿಸ್ ವರ್ಗಾವಣೆ ವಹಿವಾಟಿಗೆ ಸಹಿ ಹಾಕಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ ಎಂಬ ಅಂಶವನ್ನು ನಾವು ಪರಿಹರಿಸಿದ್ದೇವೆ.

ತಂತಿಗಳೊಂದಿಗೆ ಅಭ್ಯಾಸ ಮಾಡೋಣ ಮತ್ತು ನಂತರ ಇದನ್ನು ಪರಿಹರಿಸೋಣ.

ರೈಡ್ ಸ್ಟ್ರಿಂಗ್ಸ್

ವಹಿವಾಟು ಮತ್ತೊಮ್ಮೆ ಸಾಧ್ಯ, ತಂತಿಗಳೊಂದಿಗೆ ಹೇಗೆ ಕೆಲಸ ಮಾಡಬೇಕೆಂದು ನಮಗೆ ತಿಳಿದಿದೆ.


ಒಟ್ಟಾರೆಯಾಗಿ, ಸಂಕೀರ್ಣ ತರ್ಕವನ್ನು ಬರೆಯಲು ಅಗತ್ಯವಿರುವ ಎಲ್ಲವನ್ನೂ ನಾವು ಹೊಂದಿದ್ದೇವೆ DAO dApp.

ಡೇಟಾ ವಹಿವಾಟುಗಳು

ಡೇಟಾ ವಹಿವಾಟುಗಳು:
“ಕೀಲಿಗಾಗಿ ಗರಿಷ್ಠ ಗಾತ್ರವು 100 ಅಕ್ಷರಗಳು, ಮತ್ತು ಕೀಲಿಯು ಸ್ಥಳಗಳು ಮತ್ತು ಇತರ ಮುದ್ರಿಸಲಾಗದ ಚಿಹ್ನೆಗಳನ್ನು ಒಳಗೊಂಡಂತೆ ಅನಿಯಂತ್ರಿತ ಯುನಿಕೋಡ್ ಕೋಡ್ ಪಾಯಿಂಟ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿರಬಹುದು. ಸ್ಟ್ರಿಂಗ್ ಮೌಲ್ಯಗಳು 32,768 ಬೈಟ್‌ಗಳ ಮಿತಿಯನ್ನು ಹೊಂದಿವೆ ಮತ್ತು ಡೇಟಾ ವಹಿವಾಟಿನಲ್ಲಿ ಸಂಭವನೀಯ ನಮೂದುಗಳ ಗರಿಷ್ಠ ಸಂಖ್ಯೆ 100. ಒಟ್ಟಾರೆಯಾಗಿ, ಡೇಟಾ ವಹಿವಾಟಿನ ಗರಿಷ್ಠ ಗಾತ್ರವು ಸುಮಾರು 140kb ಆಗಿದೆ - ಉಲ್ಲೇಖಕ್ಕಾಗಿ, ಷೇಕ್ಸ್‌ಪಿಯರ್‌ನ ನಾಟಕ 'ರೋಮಿಯೋ ಮತ್ತು ಜೂಲಿಯೆಟ್‌ನ ಬಹುತೇಕ ಉದ್ದ '."

ನಾವು ಈ ಕೆಳಗಿನ ಷರತ್ತುಗಳೊಂದಿಗೆ DAO ಅನ್ನು ರಚಿಸುತ್ತೇವೆ:
ಕರೆ ಮಾಡುವ ಮೂಲಕ ನಿಧಿಯನ್ನು ಸ್ವೀಕರಿಸಲು ಪ್ರಾರಂಭಕ್ಕಾಗಿ getFunds() ಕನಿಷ್ಠ 2 ಭಾಗವಹಿಸುವವರ ಬೆಂಬಲ - DAO ಹೂಡಿಕೆದಾರರು - ಅಗತ್ಯವಿದೆ. ಹಿಂತೆಗೆದುಕೊಳ್ಳಿ ಮೇಲೆ ಸೂಚಿಸಿದ ಒಟ್ಟು ಎಷ್ಟು ನಿಖರವಾಗಿ ಸಾಧ್ಯ ಮತದಾನ DAO ಮಾಲೀಕರು.

ನಾವು 3 ರೀತಿಯ ಕೀಗಳನ್ನು ಮಾಡೋಣ ಮತ್ತು 2 ಹೊಸ ಕಾರ್ಯಗಳಲ್ಲಿ ಬ್ಯಾಲೆನ್ಸ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ತರ್ಕವನ್ನು ಸೇರಿಸೋಣ ಮತ ಮತ್ತು ಗೆಟ್‌ಫಂಡ್‌ಗಳು:
xx...xx_ia = ಹೂಡಿಕೆದಾರರು, ಲಭ್ಯವಿರುವ ಬಾಕಿ (ಮತ, ಠೇವಣಿ, ಹಿಂಪಡೆಯುವಿಕೆ)
xx...xx_ಎಸ್ ವಿ = ಸ್ಟಾರ್ಟ್‌ಅಪ್‌ಗಳು, ಮತಗಳ ಸಂಖ್ಯೆ (ಮತ, ಗೆಟ್ ಫಂಡ್‌ಗಳು)
xx...xx_sf = ಸ್ಟಾರ್ಟ್‌ಅಪ್‌ಗಳು, ಮತಗಳ ಸಂಖ್ಯೆ (ಮತ, ಗೆಟ್ ಫಂಡ್‌ಗಳು)
xx…xx = ಸಾರ್ವಜನಿಕ ವಿಳಾಸ (35 ​​ಅಕ್ಷರಗಳು)

ಮತದಲ್ಲಿ ನಾವು ಏಕಕಾಲದಲ್ಲಿ ಹಲವಾರು ಕ್ಷೇತ್ರಗಳನ್ನು ನವೀಕರಿಸಬೇಕಾಗಿದೆ ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ:

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

ರೈಟ್‌ಸೆಟ್ ಒಂದರಲ್ಲಿ ಏಕಕಾಲದಲ್ಲಿ ಹಲವಾರು ದಾಖಲೆಗಳನ್ನು ಮಾಡಲು ನಮಗೆ ಅನುಮತಿಸುತ್ತದೆ ಇನ್ವೋಕ್‌ಸ್ಕ್ರಿಪ್ಟ್ ವಹಿವಾಟುಗಳು.

ಬಾಬ್ ಮತ್ತು ಕೂಪರ್ ಮರುಪೂರಣಗೊಂಡ ನಂತರ 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: []}))

ಡೇಟಾ ಸ್ಟೋರ್‌ನಲ್ಲಿ ನಾವು ನೆಲಿಯ ವಿಳಾಸಕ್ಕೆ ಅಗತ್ಯವಿರುವ ಎಲ್ಲಾ ನಮೂದುಗಳನ್ನು ನೋಡುತ್ತೇವೆ:

ಕೂಪರ್ ಕೂಡ ನೇಲಿ ಯೋಜನೆಗೆ ಮತ ಹಾಕಿದರು.

ಫಂಕ್ಷನ್ ಕೋಡ್ ಅನ್ನು ನೋಡೋಣ getFunds. DAO ನಿಂದ ಹಣವನ್ನು ಹಿಂಪಡೆಯಲು ನೆಲಿ ಕನಿಷ್ಠ 2 ಮತಗಳನ್ನು ಸಂಗ್ರಹಿಸಬೇಕು.

ನೆಲಿ ತನಗೆ ವಹಿಸಿಕೊಟ್ಟ ಮೊತ್ತದ ಅರ್ಧದಷ್ಟು ಹಣವನ್ನು ಹಿಂತೆಗೆದುಕೊಳ್ಳಲಿದ್ದಾಳೆ:

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

ಅವಳು ಯಶಸ್ವಿಯಾಗುತ್ತಾಳೆ, ಅಂದರೆ, DAO ಕೆಲಸ ಮಾಡುತ್ತದೆ!

ಭಾಷೆಯಲ್ಲಿ DAO ರಚಿಸುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ನಾವು ನೋಡಿದ್ದೇವೆ RIDE4DAPPS.
ಕೆಳಗಿನ ಭಾಗಗಳಲ್ಲಿ ನಾವು ಕೋಡ್ ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ಮತ್ತು ಕೇಸ್ ಟೆಸ್ಟಿಂಗ್ ಅನ್ನು ಹತ್ತಿರದಿಂದ ನೋಡುತ್ತೇವೆ.

ಕೋಡ್‌ನ ಪೂರ್ಣ ಆವೃತ್ತಿ ಅಲೆಗಳ ಸವಾರಿ 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 ನಲ್ಲಿ ಕೋಡ್
ಅಲೆಗಳು ರೈಡ್ IDE
ಅನುದಾನ ಕಾರ್ಯಕ್ರಮದ ಘೋಷಣೆ

ಮೂಲ: www.habr.com