Usetyenziso lwee-akhawunti ze-Waves smart: ukusuka kwiifandesi ukuya kwiinkqubo zebhonasi

I-Blockchain ihlala idityaniswa kuphela kunye ne-cryptocurrencies, kodwa iindawo zokusetyenziswa kweteknoloji ye-DLT zibanzi kakhulu. Enye yezona ndawo zithembisayo zokusetyenziswa kwe-blockchain yinkontileka ehlakaniphile eyenziwa ngokuzenzekelayo kwaye ayifuni ukuthembana phakathi kwamaqela angenayo.

RIDE - ulwimi lweekontraki ezihlakaniphile

Amaza aphuhlise ulwimi olukhethekileyo kwiikontraki ezihlakaniphile - RIDE. Amaxwebhu apheleleyo akhoyo apha. Kwaye apha- inqaku ngalo mxholo kuHabr.

Ikhontrakthi ye-RIDE sisivisa kwaye ibuyisela "inyani" okanye "ubuxoki" njengemveliso. Ngokufanelekileyo, intengiselwano irekhodwa kwi-blockchain okanye yaliwe. Ikhontrakthi ehlakaniphile iqinisekisa ngokupheleleyo ukuzaliseka kweemeko ezichaziweyo. Ukuvelisa iitransekshini kwikhontrakthi kwi-RIDE okwangoku akunakwenzeka.

Namhlanje kukho iindidi ezimbini zeekhontrakthi ze-Waves smart: ii-akhawunti ezihlakaniphile kunye ne-smart assets. I-akhawunti ehlakaniphile yi-akhawunti yomsebenzisi eqhelekileyo, kodwa iskripthi simiselwe sona esilawula zonke iintengiselwano. Iskripthi seakhawunti ehlakaniphile sinokujongeka ngolu hlobo, umzekelo:

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

I-tx yintengiselwano eyenziwayo esiyivumelayo ukusebenzisa indlela yokulinganisa ipateni kuphela ukuba ayiludluliselo lwentengiselwano. Ipateni ehambelanayo kwi-RIDE isetyenziselwa ukujonga uhlobo lwentengiselwano. Zonke ii-akhawunti ezikhoyo zinokucutshungulwa kwiskripthi se-akhawunti ehlakaniphile iintlobo zentengiselwano.

Iskripthi sinokuphinda sibhengeze izinto eziguquguqukayo, sebenzisa "ukuba-ke-enye" ​​ukwakha kunye nezinye iindlela zokujonga ngokupheleleyo iimeko. Ukuqinisekisa ukuba iikhontrakthi zinokugqibelela okungqinwayo kunye nokuntsonkotha (iindleko) ekulula ukuqikelela phambi kokuba kuqaliswe ukuphunyezwa kwekhontrakthi, i-RIDE ayiqulathanga i-loops okanye i- jump statements.

Ezinye iimpawu zeeakhawunti ze-Waves ziquka ubukho be "state," oko kukuthi, imeko ye-akhawunti. Ungabhala inani elingapheliyo lamabini (isitshixo, ixabiso) kwisimo se-akhawunti usebenzisa ukuthengiselana kwedatha (DataTransaction). Olu lwazi lunokuthi luqhutywe zombini nge-REST API kwaye ngokuthe ngqo kwinkontileka ehlakaniphile.

Intengiselwano nganye inokuqulatha uluhlu lobungqina, apho utyikityo lomthathi-nxaxheba, i-ID yetransekshini efunekayo, njl.njl.

Ukusebenza nge-RIDE nge APHA ikuvumela ukuba ubone imbono ehlanganisiweyo yekhontrakthi (ukuba ihlanganiswe), yenza ii-akhawunti ezintsha kwaye usete izikripthi kuyo, kunye nokuthumela ukuthengiselana ngomgca womyalelo.

Ngomjikelezo opheleleyo, kubandakanywa ukudala i-akhawunti, ukufaka inkontileka ehlakaniphile kuyo kunye nokuthumela ukuthengiselana, ungasebenzisa kwakhona ilayibrari ngokusebenzisana ne-REST API (umzekelo, C #, C, Java, JavaScript, Python, Rust, Elixir) . Ukuqala ukusebenza nge-IDE, nqakraza nje iqhosha ENTSHA.

Amathuba okusebenzisa iikhontrakthi ezihlakaniphile zibanzi: ukusuka ekunqandeni ukuthengiselana ukuya kwiidilesi ezithile ("uluhlu olumnyama") ukuya kwii-dApps ezinzima.

Ngoku makhe sijonge imizekelo ethile yokusetyenziswa kwezivumelwano ezihlakaniphile kwishishini: xa uqhuba iifandesi, i-inshurensi, kunye nokudala iinkqubo zokunyaniseka.

Iifandesi

Enye yeemeko zefandesi eyimpumelelo kukwenza izinto elubala: abathathi-nxaxheba kufuneka baqiniseke ukuba akunakwenzeka ukukhohlisa iibhidi. Oku kunokufezekiswa ngokubonga kwi-blockchain, apho idatha engenakuguquguquka malunga nayo yonke ibheji kunye nexesha apho zenziwe khona ziya kufumaneka kubo bonke abathathi-nxaxheba.

Kwi-Waves blockchain, iibhidi zinokurekhodwa kwi-akhawunti ye-auction state nge-DataTransaction.

Ungaseta kwakhona ixesha lokuqala kunye nokuphela kwefandesi usebenzisa amanani ebhloko: ukuphindaphindwa kokuveliswa kwebhloko kwi-Waves blockchain iphantse ilingane 60 imizuzwana.

1. Ifandesi yexabiso yokunyuka kwesiNgesi

Abathathi-nxaxheba kwifandesi yesiNgesi babeka iibhidi kukhuphiswano omnye nomnye. Ubhejo olutsha ngalunye kufuneka lugqithe koludlulileyo. Ifandesi iyaphela xa kungekho baniki maxabiso abangakumbi ukuba bagqithise kwibhidi yokugqibela. Kule meko, oyena mntu uthengisa ngexabiso eliphezulu kufuneka abonelele ngesixa-mali esichaziweyo.

Kukho nenketho yefandesi apho umthengisi abeka ixabiso elincinci kwiqashiso, kwaye ixabiso lokugqibela kufuneka lidlule. Kungenjalo, iqashiso lihlala lingathengiswanga.

Kulo mzekelo, sisebenza ngeakhawunti eyenzelwe ngokukodwa ifandesi. Ubude befandesi yi-3000 iibhloko, kwaye ixabiso lokuqala leqashiso yi-0,001 WAVES. Umthathi-nxaxheba unokubeka ibhidi ngokuthumela iDathaTransaction kunye "nexabiso" eliphambili kunye nexabiso lebhidi yabo.

Ixabiso lebhidi elitsha kufuneka libe phezulu kunexabiso langoku lesi sitshixo, kwaye umthathi-nxaxheba kufuneka abe ubuncinane [i-new_bid + commission] amathokheni kwi-akhawunti yakhe. Idilesi yomthengisi kufuneka irekhodwe kwibala elithi "umthumeli" kwiDathaTransaction, kwaye ukuphakama kwebhloko yebhidi yangoku kufuneka kube ngaphakathi kwexesha lefandesi.

Ukuba ekupheleni kwefandesi umthathi-nxaxheba ubeke ixabiso eliphezulu, unokuthumela i-ExchangeTransaction ukuhlawula iqashiso elihambelanayo kwixabiso elichaziweyo kunye nesibini semali.

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. Ifandesi yamaDatshi yamaxabiso ahlayo

Kwifandesi yaseDatshi, kuninzi kuqala kunikezelwa ngexabiso eliphezulu kunelo umthengi azimisele ukulihlawula. Ixabiso liyancipha inyathelo ngenyathelo de omnye wabathathi-nxaxheba avume ukuthenga iqashiso ngexabiso langoku.

Kulo mzekelo sisebenzisa i-constants efanayo naleyo yangaphambili, kunye nesinyathelo sexabiso xa i-delta iyancipha. Iskripthi se-akhawunti sijonga ukuba ngaba umthathi-nxaxheba ngokwenene ungowokuqala ukubeka ukubheja. Ngaphandle koko, i-DataTransaction ayimkelwanga yi-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. Ifandesi “intlawulo yonke”

“Yonke-intlawulo” yifandesi apho bonke abathathi-nxaxheba bahlawula ibhidi, nokuba ngubani ophumelele iqashiso. Umthathi-nxaxheba ngamnye omtsha uhlawula ibhidi, kwaye umthathi-nxaxheba owenza ibhidi ephezulu uya kuphumelela iqashiso.

Kumzekelo wethu, umthathi-nxaxheba ngamnye wefandesi ubeka ibhidi ngeDathaTransaction kunye (isitshixo, ixabiso) * = ("ophumeleleyo", idilesi), ("ixabiso", ixabiso). I-DataTransaction enjalo ivunyiwe kuphela ukuba lo mthathi-nxaxheba sele sele eneTransferTransaction kunye nesignesha yakhe kwaye ibhidi yakhe iphezulu kunazo zonke zangaphambili. Ifandesi iyaqhubeka de i-endHeight ifikelelwe.

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)
}

I-inshurensi / Ukuxhaswa ngemali ngabantu abaninzi

Masithathele ingqalelo imeko apho kufuneka ukhusele ii-asethi zabasebenzisi ngokuchasene nelahleko yemali. Ngokomzekelo, umsebenzisi ufuna isiqinisekiso sokuba ukuba ithokheni iyancipha, uya kukwazi ukubuyisela imali epheleleyo ehlawulwe la mathokheni, kwaye uzimisele ukuhlawula imali efanelekileyo yomshuwalense.

Ukuphumeza oku, "iithokheni ze-inshurensi" kufuneka zikhutshwe. Emva koko iskripthi sifakwe kwi-akhawunti yomnini-polisi, ukuvumela kuphela ezo ExchangeTransactions ezihlangabezana neemeko ezithile ukuba zenziwe.

Ukuthintela inkcitho ephindwe kabini, kufuneka ucele umsebenzisi ukuba athumele i-DataTransaction kwi-akhawunti yomnini-polisi kwangaphambili kunye (isitshixo, ixabiso) = (purchaseTransactionId, sellOrderId) kwaye unqabele ukuthumela i-DataTransactions ngesitshixo esele sisetyenzisiwe.

Ke ngoko, ubungqina bomsebenzisi kufuneka buqulathe i-ID yokuthengiselana yokuthenga ithokheni ye-inshurensi. Isibini semali kufuneka sifane nakwintengiselwano yokuthenga. Iindleko kufuneka zilingane naleyo imiselweyo ngexesha lokuthenga, kuthatyathwe ixabiso le-inshorensi.

Kuyaqondwa ukuba emva koko i-akhawunti ye-inshorensi ithenga amathokheni e-inshurensi kumsebenzisi ngexabiso elingekho ngaphantsi kwelo athenge ngalo: i-akhawunti ye-inshurensi idala i-ExchangeTransaction, umsebenzisi usayine umyalelo (ukuba ukuthengiselana kugqitywe ngokuchanekileyo), I-akhawunti ye-inshurensi isayina umyalelo wesibini kunye nentengiselwano yonke kwaye uyithumele kwi-blockchain.

Ukuba akukho kuthengwa kwenzekayo, umsebenzisi unokudala i-ExchangeTransaction ngokwemigaqo echazwe kwiskripthi kwaye uthumele ukuthengiselana kwi-blockchain. Ngale ndlela umsebenzisi unokubuyisela imali echithwe ekuthengeni amathokheni e-inshorensi.

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)
}

Ithokheni ye-inshurensi inokwenziwa i-asethi ehlakaniphile, umzekelo, ukunqanda ukudluliselwa kwayo kubantu besithathu.

Esi sikimu sinokuphunyezwa kwiithokheni ze-crowdfunding, ezibuyiselwa kubanini ukuba isixa esifunekayo asiqokelelwanga.

Iirhafu zentengiselwano

Iikhontrakthi ze-Smart nazo ziyasebenza kwiimeko apho kuyimfuneko ukuqokelela irhafu kwintengiselwano nganye kunye neentlobo ezininzi zee-asethi. Oku kunokwenziwa nge-asethi entsha efakiweyo inkxaso kwintengiselwano ngee-asethi ezihlakaniphile:

1. Sikhupha i-FeeCoin, eya kuthunyelwa kubasebenzisi ngexabiso elimiselweyo: 0,01 WAVES = 0,001 FeeCoin.

2. Beka inkxaso ye-FeeCoin kunye nezinga lokutshintshiselana: 0,001 WAVES = 0,001 FeeCoin.

3. Seta esi script silandelayo se-smart asset:

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
}

Ngoku ngalo lonke ixesha umntu ehambisa i-N smart assets, uya kukunika i-FeeCoin kwisixa se-N/taxDivisor (enokuthengwa kuwe kwi-10 * N/taxDivisor WAVES), kwaye uya kunika umvukuzi N/taxDivisor WAVES. Ngenxa yoko, inzuzo yakho (irhafu) iya kuba yi-9*N / taxDivisor WAVES.

Unokwenza irhafu usebenzisa iskripthi se-asethi ehlakaniphile kunye ne-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
}

Ukubuyisela imali kunye neenkqubo zokunyaniseka

I-Cashback luhlobo lwenkqubo yokunyaniseka apho umthengi afumana inxalenye yemali echithwe kwimveliso okanye inkonzo.

Xa ukuphumeza le meko usebenzisa i-akhawunti ehlakaniphile, kufuneka sihlolisise ubungqina ngendlela efanayo njengoko senzayo kwimeko ye-inshurensi. Ukuthintela inkcitho ephindwe kabini, umsebenzisi kufuneka athumele iDathaTransaction kunye (isitshixo, ixabiso) = (purchaseTransactionId, cashbackTransactionId) ngaphambi kokufumana i-cashback.

Kufuneka kwakhona simise ukuvinjelwa kwezitshixo ezikhoyo usebenzisa i-DataTransaction. cashbackDivisor - iyunithi eyahlulwe ngesabelo semali ebuyisiweyo. Ezo. ukuba i-cashback share yi-0.1, ngoko ke 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)
}

Ukutshintsha kweAtomic

Ukutshintsha kwe-atomic kuvumela abasebenzisi ukuba batshintshiselane ngempahla ngaphandle koncedo lotshintshiselwano. Ngokutshintshwa kwe-athomu, bobabini abathathi-nxaxheba kwintengiselwano bayafuneka ukuba bayiqinisekise ngexesha elithile.

Ukuba ubuncinci omnye wabathathi-nxaxheba akaboneleli ngokuchanekileyo kwintengiselwano ngexesha elibekelwe ukuthengiselana, ukuthengiselana kucinyiwe kwaye utshintshiselwano alukwenzeka.

Kumzekelo wethu, siya kusebenzisa i-akhawunti yeskripthi elandelayo:

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
}

Kwinqaku elilandelayo siza kujonga ukusetyenziswa kweeakhawunti ezihlakaniphile kwizixhobo zemali ezifana nokhetho, ikusasa kunye neebhilikhwe.

umthombo: www.habr.com