Utumiaji wa akaunti smart za Waves: kutoka kwa minada hadi programu za bonasi

Blockchain mara nyingi huhusishwa tu na fedha za crypto, lakini maeneo ya matumizi ya teknolojia ya DLT ni pana zaidi. Moja ya maeneo ya kuahidi zaidi kwa utumiaji wa blockchain ni mkataba mzuri ambao unatekelezwa kiotomatiki na hauitaji uaminifu kati ya wahusika walioingia.

RIDE – lugha ya kandarasi mahiri

Mawimbi yametengeneza lugha maalum kwa kandarasi mahiri - RIDE. Nyaraka zake kamili ziko hapa. Na hapa - makala juu ya mada hii juu ya Habr.

Mkataba wa RIDE ni kiima na hurejesha "kweli" au "uongo" kama pato. Ipasavyo, shughuli hiyo inarekodiwa kwenye blockchain au kukataliwa. Mkataba mzuri unahakikisha utimilifu wa masharti maalum. Kuzalisha miamala kutoka kwa mkataba katika RIDE kwa sasa haiwezekani.

Leo kuna aina mbili za mikataba mahiri ya Waves: akaunti mahiri na mali mahiri. Akaunti mahiri ni akaunti ya kawaida ya mtumiaji, lakini hati imewekwa kwa ajili yake ambayo inadhibiti shughuli zote. Hati ya akaunti smart inaweza kuonekana kama hii, kwa mfano:

match tx {
  case t: TransferTransaction | MassTransferTransaction => false
  case _ => true
}

tx ni shughuli inayochakatwa ambayo tunaruhusu kutumia utaratibu wa kulinganisha muundo ikiwa tu sio shughuli ya uhamishaji. Ulinganishaji wa ruwaza katika RIDE hutumika kuangalia aina ya muamala. Akaunti zote zilizopo zinaweza kuchakatwa katika hati ya akaunti mahiri aina za shughuli.

Hati pia inaweza kutangaza vigeu, kutumia miundo ya "ikiwa-basi-ingine" na mbinu zingine kwa kuangalia hali kikamilifu. Ili kuhakikisha kuwa mikataba ina ukamilifu na utata unaoweza kuthibitishwa (gharama) ambayo ni rahisi kutabiri kabla ya utekelezaji wa mkataba kuanza, RIDE haina misururu au taarifa za kuruka.

Vipengele vingine vya akaunti za Waves ni pamoja na uwepo wa "hali," yaani, hali ya akaunti. Unaweza kuandika idadi isiyo na kikomo ya jozi (ufunguo, thamani) kwa hali ya akaunti kwa kutumia shughuli za data (DataTransaction). Maelezo haya yanaweza kuchakatwa kupitia API ya REST na moja kwa moja kwenye mkataba mzuri.

Kila shughuli inaweza kuwa na safu ya uthibitisho, ambayo saini ya mshiriki, kitambulisho cha shughuli inayohitajika, nk inaweza kuingizwa.

Kufanya kazi na RIDE kupitia IDE inakuwezesha kuona mtazamo uliokusanywa wa mkataba (ikiwa umeundwa), unda akaunti mpya na uweke maandiko kwa ajili yake, na pia kutuma shughuli kupitia mstari wa amri.

Kwa mzunguko kamili, ikiwa ni pamoja na kuunda akaunti, kusakinisha mkataba mahiri juu yake na kutuma miamala, unaweza pia kutumia maktaba kuingiliana na API ya REST (kwa mfano, C#, C, Java, JavaScript, Python, Rust, Elixir) . Ili kuanza kufanya kazi na IDE, bonyeza tu kitufe MPYA.

Uwezekano wa kutumia kandarasi mahiri ni pana: kutoka kwa kukataza miamala hadi anwani fulani ("orodha nyeusi") hadi dApps changamano.

Sasa hebu tuangalie mifano maalum ya matumizi ya mikataba ya smart katika biashara: wakati wa kufanya minada, bima, na kuunda programu za uaminifu.

Minada

Moja ya masharti ya mnada uliofanikiwa ni uwazi: washiriki lazima wawe na hakika kwamba haiwezekani kudanganya zabuni. Hii inaweza kupatikana kutokana na blockchain, ambapo data isiyoweza kubadilika kuhusu dau zote na wakati ambapo zilifanywa zitapatikana kwa washiriki wote.

Kwenye blockchain ya Waves, zabuni zinaweza kurekodiwa katika hali ya akaunti ya mnada kupitia DataTransaction.

Unaweza pia kuweka wakati wa kuanza na mwisho wa mnada kwa kutumia nambari za kuzuia: frequency ya utengenezaji wa block katika blockchain ya Waves ni takriban sawa na 60 sekunde.

1. Mnada wa bei ya kupanda kwa Kiingereza

Washiriki katika mnada wa Kiingereza huweka zabuni katika ushindani wao kwa wao. Kila dau jipya lazima lizidi ile iliyotangulia. Mnada unaisha wakati hakuna wazabuni zaidi wa kuzidi zabuni ya mwisho. Katika hali hii, mzabuni wa juu zaidi lazima atoe kiasi kilichotajwa.

Pia kuna chaguo la mnada ambalo muuzaji huweka bei ya chini kwa kura, na bei ya mwisho lazima izidi. Vinginevyo, kura bado haijauzwa.

Katika mfano huu, tunafanya kazi na akaunti iliyoundwa mahususi kwa mnada. Muda wa mnada ni vitalu 3000, na bei ya kuanzia ya kura ni 0,001 WAVES. Mshiriki anaweza kuweka zabuni kwa kutuma DataTransaction yenye ufunguo wa "bei" na thamani ya zabuni yao.

Bei ya zabuni mpya lazima iwe ya juu kuliko bei ya sasa ya ufunguo huu, na mshiriki lazima awe na angalau tokeni za [new_bid + commission] katika akaunti yake. Anwani ya mzabuni lazima irekodiwe katika sehemu ya "mtumaji" katika DataTransaction, na urefu wa sasa wa kuzuia zabuni lazima uwe ndani ya kipindi cha mnada.

Ikiwa mwishoni mwa mnada mshiriki ameweka bei ya juu zaidi, anaweza kutuma ExchangeTransaction ili kulipia kura inayolingana kwa bei iliyobainishwa na jozi ya sarafu.

let startHeight = 384120
let finishHeight = startHeight + 3000
let startPrice = 100000
 
#извлекаем из транзакции адрес отправителя
let this = extract(tx.sender)
let token = base58'8jfD2JBLe23XtCCSQoTx5eAW5QCU6Mbxi3r78aNQLcNf'
 
match tx {
case d : DataTransaction =>
  #проверяем, задана ли в стейте цена
  let currentPrice = if isDefined(getInteger(this, "price"))
 
                      #извлекаем цену из стейта
                      then extract(getInteger(this, "price"))
                      else startPrice
 
  #извлекаем цену из транзакции
  let newPrice = extract(getInteger(d.data, "price"))
  let priceIsBigger = newPrice > currentPrice
  let fee = 700000
  let hasMoney = wavesBalance(tx.sender) + fee >= newPrice
 
  #убеждаемся, что в текущей транзакции два поля и что отправитель совпадает с указанным в транзакции
  let correctFields = size(d.data) == 2 &&      
      d.sender == addressFromString(extract(getString(d.data,"sender")))
  startHeight <= height && height <= finishHeight && priceIsBigger && hasMoney && correctFields
case e : ExchangeTransaction =>
  let senderIsWinner = e.sender == addressFromString(extract(getString(this, "sender"))) #убеждаемся, что лот обменивает тот, кто его выиграл
  let correctAssetPair = e.sellOrder.assetPair.amountAsset == token && ! isDefined(e.sellOrder.assetPair.priceAsset)
  let correctAmount = e.amount == 1
  let correctPrice = e.price == extract(getInteger(this, "price"))
 
  height > finishHeight && senderIsWinner && correctAssetPair && correctAmount && correctPrice
case _ => false
}

2. Mnada wa Uholanzi wa bei zinazopungua

Katika mnada wa Uholanzi, mengi hutolewa kwa bei ya juu kuliko ile ambayo mnunuzi yuko tayari kulipa. Bei hupungua hatua kwa hatua hadi mmoja wa washiriki akubali kununua kura kwa bei ya sasa.

Katika mfano huu tunatumia viwango sawa na vilivyotangulia, pamoja na hatua ya bei wakati delta inapungua. Hati ya akaunti hukagua ikiwa mshiriki ndiye wa kwanza kuweka dau. Vinginevyo, DataTransaction haikubaliki na blockchain.

let startHeight = 384120
let finishHeight = startHeight + 3000
let startPrice = 100000000
let delta = 100
 
#извлекаем из транзакции адрес отправителя
let this = extract(tx.sender)
let token = base58'8jfD2JBLe23XtCCSQoTx5eAW5QCU6Mbxi3r78aNQLcNf'
match tx {
case d : DataTransaction =>
  let currentPrice = startPrice - delta * (height - startHeight)
 
  #извлекаем из поступившей дата-транзакции поле "price"
  let newPrice = extract(getInteger(d.data, "price"))
 
  #убеждаемся, что в стейте текущего аккаунта не содержится поля "sender"
  let noBetsBefore = !isDefined(getInteger(this, "sender"))
  let fee = 700000
  let hasMoney = wavesBalance(tx.sender) + fee >= newPrice
 
  #убеждаемся, что в текущей транзакции только два поля
  let correctFields = size(d.data) == 2 && newPrice == currentPrice && d.sender == addressFromString(extract(getString(d.data, "sender")))
  startHeight <= height && height <= finishHeight && noBetsBefore && hasMoney && correctFields
case e : ExchangeTransaction =>
 
  #убеждаемся, что отправитель текущей транзакции указан в стейте аккаунта по ключу sender
  let senderIsWinner = e.sender == addressFromString(extract(getString(this, "sender")))
 
  #убеждаемся, что аmount ассета указан корректно, и что прайс-ассет - waves
  let correctAssetPair = e.sellOrder.assetPair.amountAsset == token && ! isDefined(e.sellOrder.assetPair.priceAsset)
  let correctAmount = e.amount == 1
  let correctPrice = e.price == extract(getInteger(this, "price"))
  height > finishHeight && senderIsWinner && correctAssetPair && correctAmount && correctPrice
case _ => false
}

3. Mnada “malipo yote”

"Lipa zote" ni mnada ambao washiriki wote hulipa zabuni, bila kujali nani atashinda kura. Kila mshiriki mpya hulipa zabuni, na mshiriki anayetoa zabuni ya juu zaidi atashinda kura.

Katika mfano wetu, kila mshiriki wa mnada anaweka zabuni kupitia DataTransaction na (ufunguo, thamani)* = ("mshindi", anwani),("bei", bei). DataTransaction kama hiyo inaidhinishwa tu ikiwa mshiriki huyu tayari ana TransferTransaction na sahihi yake na zabuni yake ni kubwa kuliko zote za awali. Mnada unaendelea hadi endHeight kufikiwa.

let startHeight = 1000
let endHeight = 2000
let this = extract(tx.sender)
let token = base58'8jfD2JBLe23XtCCSQoTx5eAW5QCU6Mbxi3r78aNQLcNf'
match tx {
 case d: DataTransaction =>
   #извлекаем из поступившей дата-транзакции поле "price"
   let newPrice = extract(getInteger(d.data, "price"))
 
   #извлекаем из пруфов транзакции публичный ключ аккаунта
   let pk = d.proofs[1]
   let address = addressFromPublicKey(pk)
 
   #извлекаем транзакцию доказательство из пруфов поступившей дата транзакции
   let proofTx = extract(transactionById(d.proofs[2]))
   
   height > startHeight && height < endHeight
   && size(d.data) == 2
   #убеждаемся, что адрес победителя, извлеченный из текущей транзакции, совпадает с адресом, извлеченным из пруфов
   && extract(getString(d.data, "winner")) == toBase58String(address.bytes)
   && newPrice > extract(getInteger(this, "price"))
   #проверяем, что транзакция подписана
   && sigVerify(d.bodyBytes, d.proofs[0], d.proofs[1])
   #проверяем корректность транзакции, указанной в пруфах
   && match proofTx {
     case tr : TransferTransaction =>
       tr.sender == address &&
       tr.amount == newPrice
     case _ => false
   }
 case t: TransferTransaction =>
 sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
 || (
   height > endHeight
   && extract(getString(this, "winner")) == toBase58String((addressFromRecipient(t.recipient)).bytes)
   && t.assetId == token
   && t.amount == 1
 )
 case _ => sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
}

Bima / Ufadhili wa watu wengi

Hebu tuzingatie hali ambapo unahitaji kuhakikisha mali za watumiaji dhidi ya upotevu wa kifedha. Kwa mfano, mtumiaji anataka uhakikisho kwamba ikiwa ishara inapungua, ataweza kurejesha kiasi kamili kilicholipwa kwa ishara hizi, na yuko tayari kulipa kiasi cha kutosha cha bima.

Ili kutekeleza hili, "ishara za bima" zinahitajika kutolewa. Kisha hati husakinishwa kwenye akaunti ya mwenye sera, ikiruhusu tu ExchangeTransactions zinazotimiza masharti fulani kutekelezwa.

Ili kuzuia matumizi maradufu, unahitaji kumwomba mtumiaji kutuma DataTransaction kwa akaunti ya mwenye sera mapema na (ufunguo, thamani) = (purchaseTransactionId, sellOrderId) na kukataza kutuma DataTransactions kwa ufunguo ambao tayari umetumika.

Kwa hiyo, uthibitisho wa mtumiaji lazima uwe na kitambulisho cha shughuli ya ununuzi wa ishara ya bima. Jozi ya sarafu lazima iwe sawa na katika muamala wa ununuzi. Gharama pia lazima iwe sawa na ile iliyowekwa wakati wa ununuzi, ukiondoa bei ya bima.

Inaeleweka kuwa baadaye akaunti ya bima hununua tokeni za bima kutoka kwa mtumiaji kwa bei isiyo ya chini kuliko ile aliyoinunua: akaunti ya bima inaunda ExchangeTransaction, mtumiaji husaini agizo (ikiwa shughuli imekamilika kwa usahihi), akaunti ya bima husaini agizo la pili na shughuli nzima na kuituma kwa blockchain.

Ikiwa hakuna ununuzi hutokea, mtumiaji anaweza kuunda ExchangeTransaction kulingana na sheria zilizoelezwa katika script na kutuma shughuli kwa blockchain. Kwa njia hii mtumiaji anaweza kurudisha pesa zilizotumika kwa ununuzi wa tokeni zenye bima.

let insuranceToken = base58'8jfD2JBLe23XtCCSQoTx5eAW5QCU6Mbxi3r78aNQLcNf'
 
#извлекаем из транзакции адрес отправителя
let this = extract(tx.sender)
let freezePeriod = 150000
let insurancePrice = 10000
match tx {
 
 #убеждаемся, что, если поступила дата-транзакция, то у нее ровно одно поле и в стейте еще нет такого ключа
 case d : DataTransaction => size(d.data) == 1 && !isDefined(getBinary(this, d.data[0].key))
 case e : ExchangeTransaction =>
 
   #если у транзакции нет седьмого пруфа, проверяем корректность подписи
   if !isDefined(e.proofs[7]) then
     sigVerify(e.bodyBytes, e.proofs[0], e.senderPublicKey)
   else
     #если у транзакции есть седьмой пруф, извлекаем из него транзакцию и узнаём её высоту
     let purchaseTx = transactionById(e.proofs[7])
     let purchaseTxHeight = extract(transactionHeightById(e.proofs[7]))
    
     #обрабатываем транзакцию из пруфа
     match purchaseTx {
       case purchase : ExchangeTransaction =>
         let correctSender = purchase.sender == e.sellOrder.sender
         let correctAssetPair = e.sellOrder.assetPair.amountAsset == insuranceToken &&
                                purchase.sellOrder.assetPair.amountAsset == insuranceToken &&
                                e.sellOrder.assetPair.priceAsset == purchase.sellOrder.assetPair.priceAsset
         let correctPrice = e.price == purchase.price - insurancePrice && e.amount == purchase.amount
         let correctHeight = height > purchaseTxHeight + freezePeriod
 
         #убеждаемся, что в транзакции-пруфе указан верный ID текущей транзакции
         let correctProof = extract(getBinary(this, toBase58String(purchase.id))) == e.sellOrder.id
         correctSender && correctAssetPair && correctPrice && correctHeight && correctProof
     case _ => false
   }
 case _ => sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
}

Tokeni ya bima inaweza kufanywa kuwa mali mahiri, kwa mfano, ili kuzuia uhamisho wake kwa wahusika wengine.

Mpango huu pia unaweza kutekelezwa kwa ishara za watu wengi, ambazo zinarejeshwa kwa wamiliki ikiwa kiasi kinachohitajika hakijakusanywa.

Kodi za muamala

Mikataba ya busara inatumika pia katika hali ambapo inahitajika kukusanya ushuru kwa kila shughuli na aina kadhaa za mali. Hii inaweza kufanywa kupitia kipengee kipya kilichosakinishwa udhamini kwa miamala na mali mahiri:

1. Tunatoa FeeCoin, ambayo itatumwa kwa watumiaji kwa bei ya kudumu: 0,01 WAVES = 0,001 FeeCoin.

2. Weka udhamini kwa FeeCoin na kiwango cha ubadilishaji: 0,001 WAVES = 0,001 FeeCoin.

3. Weka hati ifuatayo ya kipengee mahiri:

let feeAssetId = base58'8jfD2JBLe23XtCCSQoTx5eAW5QCU6Mbxi3r78aNQLcNf'
let taxDivisor = 10
 
match tx {
  case t: TransferTransaction =>
    t.feeAssetId == feeAssetId && t.fee == t.amount / taxDivisor
  case e: ExchangeTransaction | MassTransferTransaction => false
  case _ => true
}

Sasa kila wakati mtu anapohamisha N mali mahiri, atakupa FeeCoin kwa kiasi cha N/taxDivisor (ambacho kinaweza kununuliwa kutoka kwako kwa 10 *N/taxDivisor WAVES), na utampa mchimbaji N/taxDivisor WAVES. Kwa hivyo, faida yako (kodi) itakuwa 9*N / taxDivisor WAVES.

Unaweza pia kutoza ushuru kwa kutumia hati mahiri ya mali na MassTransferTransaction:

let taxDivisor = 10
 
match tx {
  case t : MassTransferTransaction =>
    let twoTransfers = size(t.transfers) == 2
    let issuerIsRecipient = t.transfers[0].recipient == addressFromString("3MgkTXzD72BTfYpd9UW42wdqTVg8HqnXEfc")
    let taxesPaid = t.transfers[0].amount >= t.transfers[1].amount / taxDivisor
    twoTransfers && issuerIsRecipient && taxesPaid
  case _ => false
}

Programu za kurejesha pesa na uaminifu

Pesa ni aina ya mpango wa uaminifu ambapo mnunuzi anarudishiwa sehemu ya kiasi kilichotumiwa kwenye bidhaa au huduma.

Wakati wa kutekeleza kesi hii kwa kutumia akaunti mahiri, ni lazima tuangalie uthibitisho kwa njia sawa na tulivyofanya katika kesi ya bima. Ili kuzuia matumizi maradufu, ni lazima mtumiaji atume DataTransaction na (ufunguo, thamani) = (purchaseTransactionId, cashbackTransactionId) kabla ya kupokea pesa taslimu.

Ni lazima pia tuweke marufuku kwa funguo zilizopo kwa kutumia DataTransaction. cashbackDivisor - kitengo kilichogawanywa na sehemu ya kurudishiwa pesa. Wale. ikiwa hisa ya kurejesha pesa ni 0.1, basi cashbackDivisor 1 / 0.1 = 10.

let cashbackToken = base58'8jfD2JBLe23XtCCSQoTx5eAW5QCU6Mbxi3r78aNQLcNf'
 
#извлекаем из транзакции адрес отправителя
let this = extract(tx.sender)
let cashbackDivisor = 10
match tx {
 
 #убеждаемся, что, если поступила дата-транзакция, то у нее ровно одно поле и в стейте еще нет такого ключа
 case d : DataTransaction => size(d.data) == 1 && !isDefined(getBinary(this, d.data[0].key))
 case e : TransferTransaction =>
 
   #если у транзакции нет седьмого пруфа, проверяем корректность подписи
   if !isDefined(e.proofs[7]) then
     sigVerify(e.bodyBytes, e.proofs[0], e.senderPublicKey)
   else
 
     #если у транзакции есть седьмой пруф, извлекаем из него транзакцию и узнаём её высоту
     let purchaseTx = transactionById(e.proofs[7])
     let purchaseTxHeight = extract(transactionHeightById(e.proofs[7]))
    
     #обрабатываем транзакцию из пруфа
     match purchaseTx {
       case purchase : TransferTransaction =>
         let correctSender = purchase.sender == e.sender
         let correctAsset = e.assetId == cashbackToken
         let correctPrice = e.amount == purchase.amount / cashbackDivisor
 
         #убеждаемся, что в транзакции-пруфе указан верный ID текущей транзакции
         let correctProof = extract(getBinary(this, toBase58String(purchase.id))) == e.id
         correctSender && correctAsset && correctPrice && correctProof
     case _ => false
   }
 case _ => sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
}

Kubadilishana kwa atomiki

Kubadilishana kwa atomiki huruhusu watumiaji kubadilishana mali bila usaidizi wa kubadilishana. Kwa ubadilishanaji wa atomiki, washiriki wote wawili katika shughuli hiyo wanatakiwa kuithibitisha ndani ya muda fulani.

Ikiwa angalau mmoja wa washiriki haitoi uthibitisho sahihi wa shughuli ndani ya muda uliowekwa kwa ajili ya shughuli hiyo, shughuli hiyo imefutwa na kubadilishana haifanyiki.

Katika mfano wetu, tutatumia hati ifuatayo ya akaunti mahiri:

let Bob = Address(base58'3NBVqYXrapgJP9atQccdBPAgJPwHDKkh6A8')
let Alice = Address(base58'3PNX6XwMeEXaaP1rf5MCk8weYeF7z2vJZBg')
 
let beforeHeight = 100000
 
let secret = base58'BN6RTYGWcwektQfSFzH8raYo9awaLgQ7pLyWLQY4S4F5'
match tx {
  case t: TransferTransaction =>
    let txToBob = t.recipient == Bob && sha256(t.proofs[0]) == secret && 20 + beforeHeight >= height
    let backToAliceAfterHeight = height >= 21 + beforeHeight && t.recipient == Alice
    txToBob || backToAliceAfterHeight
  case _ => false
}

Katika makala inayofuata tutaangalia matumizi ya akaunti mahiri katika vyombo vya fedha kama vile chaguzi, hatima na bili.

Chanzo: mapenzi.com