Awọn ohun elo ti awọn akọọlẹ smart Waves: lati awọn titaja si awọn eto ajeseku

Blockchain nigbagbogbo ni nkan ṣe pẹlu awọn owo iworo nikan, ṣugbọn awọn agbegbe ti ohun elo ti imọ-ẹrọ DLT jẹ gbooro pupọ. Ọkan ninu awọn agbegbe ti o ni ileri julọ fun lilo blockchain jẹ adehun ti o gbọn ti o ṣiṣẹ laifọwọyi ati pe ko nilo igbẹkẹle laarin awọn ẹgbẹ ti o wọ inu rẹ.

RIDE – ede kan fun smati siwe

Awọn igbi ti ni idagbasoke ede pataki kan fun awọn adehun ọlọgbọn - RIDE. Awọn oniwe-pipe iwe ti wa ni be nibi. Ati nibi - article lori koko yi lori Habr.

Adehun RIDE jẹ asọtẹlẹ ati da pada “otitọ” tabi “eke” bi abajade. Nitorinaa, idunadura naa jẹ boya gbasilẹ ni blockchain tabi kọ. Iwe adehun ọlọgbọn ni kikun ṣe iṣeduro imuse awọn ipo pàtó kan. Ṣiṣẹda awọn iṣowo lati inu adehun ni RIDE ko ṣee ṣe lọwọlọwọ.

Loni awọn oriṣi meji ti awọn adehun smart Waves wa: awọn akọọlẹ ọlọgbọn ati awọn ohun-ini ọlọgbọn. Akọọlẹ ọlọgbọn jẹ akọọlẹ olumulo deede, ṣugbọn a ṣeto iwe afọwọkọ kan ti o ṣakoso gbogbo awọn iṣowo. Iwe afọwọkọ akọọlẹ ọlọgbọn le dabi eyi, fun apẹẹrẹ:

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

tx jẹ iṣowo ti n ṣiṣẹ ti a gba laaye ni lilo ilana ibaramu ilana nikan ti kii ṣe idunadura gbigbe kan. Ibamu apẹrẹ ni RIDE ni a lo lati ṣayẹwo iru idunadura naa. Gbogbo awọn akọọlẹ ti o wa tẹlẹ le ṣe ilọsiwaju ni iwe afọwọkọ akọọlẹ smart idunadura orisi.

Iwe afọwọkọ naa tun le sọ awọn oniyipada, lo awọn itumọ “ti o ba jẹ lẹhinna-miiran” ati awọn ọna miiran fun ṣayẹwo awọn ipo ni kikun. Lati rii daju pe awọn adehun ni pipe ati idiju (iye owo) ti o rọrun lati ṣe asọtẹlẹ ṣaaju ṣiṣe ṣiṣe adehun, RIDE ko ni awọn losiwajulosehin tabi awọn alaye fo.

Awọn ẹya miiran ti awọn iroyin Waves pẹlu wiwa ti “ipinle,” iyẹn ni, ipo akọọlẹ naa. O le kọ nọmba ailopin ti awọn orisii (bọtini, iye) si ipo akọọlẹ nipa lilo awọn iṣowo data (DataTransaction). Alaye yii le ṣe ilọsiwaju mejeeji nipasẹ REST API ati taara ninu adehun ọlọgbọn.

Idunadura kọọkan le ni ọpọlọpọ awọn ẹri, sinu eyiti ibuwọlu ti alabaṣe, ID ti idunadura ti o nilo, ati bẹbẹ lọ le wa ni titẹ sii.

Nṣiṣẹ pẹlu RIDE nipasẹ nibi gba ọ laaye lati wo wiwo ti o ṣajọpọ ti adehun naa (ti o ba ṣajọ), ṣẹda awọn akọọlẹ tuntun ati ṣeto awọn iwe afọwọkọ fun rẹ, ati firanṣẹ awọn iṣowo nipasẹ laini aṣẹ.

Fun yiyi ni kikun, pẹlu ṣiṣẹda akọọlẹ kan, fifiwe adehun ọlọgbọn sori rẹ ati fifiranṣẹ awọn iṣowo, o tun le lo ile-ikawe kan fun ibaraenisọrọ pẹlu API REST (fun apẹẹrẹ, C #, C, Java, JavaScript, Python, Rust, Elixir) . Lati bẹrẹ ṣiṣẹ pẹlu IDE, kan tẹ bọtini TITUN.

Awọn aye ti o ṣeeṣe fun lilo awọn ifowo siwe ti o gbọngbọn jẹ: lati idinamọ awọn iṣowo si awọn adirẹsi kan (“akojọ dudu”) si dApps eka.

Bayi jẹ ki a wo awọn apẹẹrẹ kan pato ti lilo awọn adehun ọlọgbọn ni iṣowo: nigba ṣiṣe awọn titaja, iṣeduro, ati ṣiṣẹda awọn eto iṣootọ.

Awọn titaja

Ọkan ninu awọn ipo fun titaja aṣeyọri jẹ akoyawo: awọn olukopa gbọdọ ni igboya pe ko ṣee ṣe lati ṣe afọwọyi awọn idu. Eyi le ṣe aṣeyọri ọpẹ si blockchain, nibiti data ti ko yipada nipa gbogbo awọn tẹtẹ ati akoko ti wọn ṣe yoo wa fun gbogbo awọn olukopa.

Lori blockchain Waves, awọn idu le ṣe igbasilẹ ni ipo akọọlẹ titaja nipasẹ DataTransaction.

O tun le ṣeto akoko ibẹrẹ ati ipari ti titaja nipa lilo awọn nọmba idilọwọ: igbohunsafẹfẹ ti iran idina ninu blockchain Waves jẹ isunmọ dogba si 60 iṣẹju-aaya.

1. English gòke owo auction

Awọn olukopa ninu ohun English auction ibi idu ni idije pẹlu kọọkan miiran. Kọọkan titun tẹtẹ gbọdọ koja ti tẹlẹ. Awọn titaja dopin nigbati ko si awọn onifowole diẹ sii lati kọja idu ti o kẹhin. Ni idi eyi, olufowole ti o ga julọ gbọdọ pese iye ti a sọ.

Aṣayan titaja tun wa ninu eyiti olutaja ṣeto idiyele ti o kere ju fun pupọ, ati idiyele ipari gbọdọ kọja rẹ. Bibẹẹkọ, pupọ yoo wa lai ta.

Ninu apẹẹrẹ yii, a n ṣiṣẹ pẹlu akọọlẹ kan ti a ṣẹda ni pataki fun titaja naa. Iye akoko titaja jẹ awọn bulọọki 3000, ati idiyele ibẹrẹ ti pupọ jẹ 0,001 WAVES. Olukopa kan le gbe idu kan nipa fifiranṣẹ DataTransaction pẹlu bọtini "owo" ati iye ti idu wọn.

Iye idiyele tuntun gbọdọ jẹ ti o ga ju idiyele lọwọlọwọ fun bọtini yii, ati pe alabaṣe gbọdọ ni o kere ju awọn ami [new_bid + Commission] ninu akọọlẹ rẹ. Adirẹsi onifowole gbọdọ wa ni igbasilẹ ni aaye “olufiranṣẹ” ni DataTransaction, ati pe iga idinaduro lọwọlọwọ gbọdọ wa laarin akoko titaja.

Ti o ba ti ni opin ti awọn titaja alabaṣe ti ṣeto awọn ga owo, o le fi ohun ExchangeTransaction lati san fun awọn ti o baamu pupo ni pato owo ati owo bata.

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. Dutch titaja ti dinku owo

Ninu titaja Dutch kan, ọpọlọpọ ni akọkọ funni ni idiyele ti o ga ju ohun ti olura fẹ lati san. Iye owo naa dinku ni igbese nipasẹ igbese titi ọkan ninu awọn olukopa gba lati ra pupọ ni idiyele lọwọlọwọ.

Ninu apẹẹrẹ yii a lo awọn iwọn kanna bi ti iṣaaju, bakanna bi igbesẹ idiyele nigbati delta dinku. Iwe afọwọkọ akọọlẹ ṣayẹwo boya alabaṣe jẹ otitọ ni akọkọ lati tẹtẹ. Bibẹẹkọ, DataTransaction ko gba nipasẹ 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. Titaja “gbogbo-sanwo”

"Gbogbo-sanwo" jẹ titaja kan ninu eyiti gbogbo awọn olukopa san owo naa, laibikita ẹniti o ṣẹgun pupọ. Olukopa tuntun kọọkan n san owo kan, ati alabaṣe ti o ṣe idiyele ti o pọju gba ọpọlọpọ.

Ninu apẹẹrẹ wa, alabaṣe titaja kọọkan n gbe idu kan nipasẹ DataTransaction pẹlu (bọtini, iye)* = (“olubori”, adirẹsi), (“owo”, idiyele). Iru DataTransaction ni a fọwọsi nikan ti alabaṣe yii ti ni TransferTransaction tẹlẹ pẹlu ibuwọlu rẹ ati pe idu rẹ ga ju gbogbo awọn iṣaaju lọ. Titaja naa tẹsiwaju titi ti opin Height yoo fi de.

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

Insurance / Crowdfunding

Jẹ ki a gbero ipo kan nibiti o nilo lati rii daju awọn ohun-ini olumulo lodi si awọn adanu inawo. Fun apẹẹrẹ, olumulo kan fẹ ẹri pe ti ami kan ba dinku, yoo ni anfani lati gba iye kikun ti o san fun awọn ami-ami wọnyi pada, ati pe o fẹ lati san iye owo iṣeduro ti o tọ.

Lati ṣe eyi, “awọn ami iṣeduro” nilo lati gbejade. Lẹhinna a ti fi iwe afọwọkọ sori akọọlẹ oluṣeto imulo, gbigba laaye nikan Awọn Iyipada Iṣowo ti o pade awọn ipo kan lati ṣiṣẹ.

Lati ṣe idiwọ inawo ilọpo meji, o nilo lati beere lọwọ olumulo lati fi DataTransaction ranṣẹ si akọọlẹ oniwun tẹlẹ pẹlu (bọtini, iye) = (purchaseTransactionId, sellOrderId) ati fi ofin de fifiranṣẹ DataTransactions pẹlu bọtini kan ti o ti lo tẹlẹ.

Nitorina, awọn ẹri olumulo gbọdọ ni ID idunadura ti rira ami iṣeduro. Awọn bata owo gbọdọ jẹ kanna bi ninu idunadura rira. Iye owo naa gbọdọ tun jẹ deede si ti o wa titi ni akoko rira, iyokuro idiyele ti iṣeduro.

O gbọye pe lẹhinna akọọlẹ iṣeduro ra awọn ami iṣeduro lati ọdọ olumulo ni idiyele ti ko kere ju eyiti o ti ra wọn: akọọlẹ iṣeduro ṣẹda ExchangeTransaction, olumulo naa fowo si aṣẹ naa (ti idunadura naa ba pari ni deede), akọọlẹ iṣeduro ṣe ami aṣẹ keji ati gbogbo idunadura ati firanṣẹ si blockchain.

Ti ko ba si rira waye, olumulo le ṣẹda ExchangeTransaction ni ibamu si awọn ofin ti a ṣalaye ninu iwe afọwọkọ ati firanṣẹ idunadura naa si blockchain. Ni ọna yii olumulo le da owo ti o lo lori rira awọn ami idaniloju pada.

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

Aami iṣeduro le ṣe dukia ọlọgbọn, fun apẹẹrẹ, lati ṣe idiwọ gbigbe rẹ si awọn ẹgbẹ kẹta.

Ilana yii tun le ṣe imuse fun awọn ami-ifunni owo, eyiti o pada si awọn oniwun ti iye ti a beere ko ba ti gba.

Owo-ori idunadura

Awọn adehun Smart tun wulo ni awọn ọran nibiti o jẹ dandan lati gba owo-ori lori idunadura kọọkan pẹlu awọn iru ohun-ini pupọ. Eyi le ṣee ṣe nipasẹ dukia tuntun pẹlu fifi sori ẹrọ igbowo fun awọn iṣowo pẹlu awọn ohun-ini ọlọgbọn:

1. A fun FeeCoin, eyi ti yoo firanṣẹ si awọn olumulo ni iye owo ti o wa titi: 0,01 WAVES = 0,001 FeeCoin.

2. Ṣeto igbowo fun FeeCoin ati oṣuwọn paṣipaarọ: 0,001 WAVES = 0,001 FeeCoin.

3. Ṣeto iwe afọwọkọ atẹle fun dukia ọlọgbọn:

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
}

Nisisiyi ni gbogbo igba ti ẹnikan ba n gbe awọn ohun-ini ọlọgbọn N, wọn yoo fun ọ ni FeeCoin ni iye N / TaxDivisor (eyi ti o le ra lati ọdọ rẹ ni 10 * N / TaxDivisor WAVES), ati pe iwọ yoo fun miner N / TaxDivisor WAVES. Bi abajade, èrè rẹ (ori) yoo jẹ 9 * N / taxDivisor WAVES.

O tun le ṣe owo-ori nipa lilo iwe afọwọkọ dukia ọlọgbọn ati 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
}

Cashback ati iṣootọ eto

Cashback jẹ iru eto iṣootọ ninu eyiti olura pada gba apakan ti iye ti o lo lori ọja tabi iṣẹ kan.

Nigbati o ba nlo ọran yii nipa lilo akọọlẹ ọlọgbọn, a gbọdọ ṣayẹwo awọn ẹri ni ọna kanna bi a ti ṣe ninu ọran iṣeduro. Lati ṣe idiwọ inawo ilọpo meji, olumulo gbọdọ fi DataTransaction ranṣẹ pẹlu (bọtini, iye) = (purchaseTransactionId, cashbackTransactionId) ṣaaju gbigba cashback.

A tun gbọdọ ṣeto wiwọle si awọn bọtini to wa tẹlẹ nipa lilo DataTransaction. cashbackDivisor - ẹyọkan ti o pin nipasẹ ipin cashback. Awon. Ti ipin cashback ba jẹ 0.1, lẹhinna 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)
}

Atomic siwopu

Atomic swap gba awọn olumulo laaye lati paarọ awọn ohun-ini laisi iranlọwọ ti paṣipaarọ. Pẹlu swap atomiki, awọn olukopa mejeeji ni idunadura naa nilo lati jẹrisi laarin akoko kan.

Ti o ba jẹ pe o kere ju ọkan ninu awọn olukopa ko pese iṣeduro ti o tọ ti idunadura laarin akoko ti a pin fun idunadura naa, idunadura naa ti fagile ati paṣipaarọ naa ko waye.

Ninu apẹẹrẹ wa, a yoo lo iwe afọwọkọ akọọlẹ smart atẹle yii:

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
}

Ninu nkan ti o tẹle a yoo wo lilo awọn akọọlẹ smart ni awọn ohun elo inawo gẹgẹbi awọn aṣayan, ọjọ iwaju ati awọn owo-owo.

orisun: www.habr.com