Waves ස්මාර්ට් ගිණුම් වල යෙදුම්: වෙන්දේසියේ සිට ප්‍රසාද වැඩසටහන් දක්වා

Blockchain බොහෝ විට සම්බන්ධ වන්නේ cryptocurrencies සමඟ පමණි, නමුත් DLT තාක්ෂණය භාවිතා කිරීමේ ක්ෂේත්‍ර වඩා පුළුල් වේ. බ්ලොක්චේන් භාවිතය සඳහා වඩාත්ම පොරොන්දු වූ ක්ෂේත්‍රවලින් එකක් වන්නේ ස්වයංක්‍රීයව ක්‍රියාත්මක වන ස්මාර්ට් කොන්ත්‍රාත්තුවක් වන අතර එයට ඇතුළු වූ පාර්ශ්වයන් අතර විශ්වාසයක් අවශ්‍ය නොවේ.

RIDE - ස්මාර්ට් ගිවිසුම් සඳහා භාෂාවක්

තරංග විසින් ස්මාර්ට් ගිවිසුම් සඳහා විශේෂ භාෂාවක් සංවර්ධනය කර ඇත - RIDE. එහි සම්පූර්ණ ලියකියවිලි පිහිටා ඇත මෙහි. මෙහි - මෙම මාතෘකාව පිළිබඳ ලිපිය Habr මත.

RIDE ගිවිසුම පුරෝකථනයක් වන අතර ප්‍රතිදානය ලෙස "සත්‍ය" හෝ "අසත්‍ය" ලබා දෙයි. ඒ අනුව, ගනුදෙනුව බ්ලොක්චේන් හි සටහන් කර හෝ ප්රතික්ෂේප කරනු ලැබේ. ස්මාර්ට් කොන්ත්රාත්තුව නිශ්චිත කොන්දේසි සපුරාලීම සම්පූර්ණයෙන්ම සහතික කරයි. RIDE හි ගිවිසුමකින් ගනුදෙනු උත්පාදනය කිරීම දැනට කළ නොහැක.

අද වන විට තරංග ස්මාර්ට් කොන්ත්‍රාත්තු වර්ග දෙකක් තිබේ: ස්මාර්ට් ගිණුම් සහ ස්මාර්ට් වත්කම්. ස්මාර්ට් ගිණුමක් යනු සාමාන්‍ය පරිශීලක ගිණුමකි, නමුත් සියලුම ගනුදෙනු පාලනය කරන ස්ක්‍රිප්ට් එකක් ඒ සඳහා සකසා ඇත. ස්මාර්ට් ගිණුම් ස්ක්‍රිප්ට් එකක් මේ වගේ විය හැක, උදාහරණයක් ලෙස:

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

tx යනු හුවමාරු ගනුදෙනුවක් නොවේ නම් පමණක් රටා ගැලපුම් යාන්ත්‍රණය භාවිතා කිරීමට ඉඩ දෙන ගනුදෙනුවක් සකසනු ලැබේ. ගනුදෙනු වර්ගය පරීක්ෂා කිරීමට RIDE හි රටා ගැලපීම භාවිතා කරයි. පවතින සියලුම ගිණුම් ස්මාර්ට් ගිණුම් ස්ක්‍රිප්ටය තුළ සැකසිය හැක ගනුදෙනු වර්ග.

ස්ක්‍රිප්ටයට විචල්‍ය ප්‍රකාශ කළ හැකිය, කොන්දේසි සම්පූර්ණයෙන් පරීක්ෂා කිරීම සඳහා “if-then-else” ඉදිකිරීම් සහ වෙනත් ක්‍රම භාවිතා කරන්න. කොන්ත්‍රාත්තු ක්‍රියාත්මක කිරීම ආරම්භ වීමට පෙර පුරෝකථනය කිරීමට පහසු කොන්ත්‍රාත්තු ඔප්පු කළ හැකි සම්පූර්ණත්වය සහ සංකීර්ණත්වය (පිරිවැය) ඇති බව සහතික කිරීම සඳහා, RIDE හි ලූප හෝ පැනීමේ ප්‍රකාශ අඩංගු නොවේ.

Waves ගිණුම් වල අනෙකුත් ලක්ෂණ "තත්ත්වය" තිබීම, එනම් ගිණුමේ තත්වය ඇතුළත් වේ. දත්ත ගණුදෙණු (DataTransaction) භාවිතයෙන් ඔබට ගිණුමේ තත්වයට අනන්ත යුගල (යතුර, අගය) ලිවිය හැක. මෙම තොරතුරු REST API හරහා සහ සෘජුවම ස්මාර්ට් කොන්ත්‍රාත්තුවෙන් සැකසිය හැක.

සෑම ගනුදෙනුවකටම සහභාගිවන්නාගේ අත්සන, අවශ්‍ය ගනුදෙනුවේ හැඳුනුම්පත යනාදිය ඇතුළත් කළ හැකි සාක්ෂි මාලාවක් අඩංගු විය හැකිය.

RIDE සමඟ වැඩ කිරීම හරහා මුල් කොන්ත්රාත්තුවේ සම්පාදනය කළ දර්ශනය (එය සම්පාදනය කර ඇත්නම්), නව ගිණුම් නිර්මාණය කිරීම සහ ඒ සඳහා ස්ක්‍රිප්ට් සැකසීම මෙන්ම විධාන රේඛාව හරහා ගනුදෙනු යැවීමට ඔබට ඉඩ සලසයි.

ගිණුමක් සෑදීම, එය මත ස්මාර්ට් කොන්ත්‍රාත්තුවක් ස්ථාපනය කිරීම සහ ගනුදෙනු යැවීම ඇතුළු සම්පූර්ණ චක්‍රයක් සඳහා, ඔබට REST API සමඟ අන්තර් ක්‍රියා කිරීම සඳහා පුස්තකාලයක් ද භාවිතා කළ හැකිය (උදාහරණයක් ලෙස, C#, C, Java, JavaScript, Python, Rust, Elixir) . IDE සමඟ වැඩ කිරීම ආරම්භ කිරීමට, නව බොත්තම ක්ලික් කරන්න.

ස්මාර්ට් කොන්ත්‍රාත්තු භාවිතා කිරීමේ හැකියාව පුළුල් ය: ගනුදෙනු තහනම් කිරීමේ සිට ඇතැම් ලිපින ("කළු ලැයිස්තුව") දක්වා සංකීර්ණ dApps දක්වා.

දැන් අපි ව්‍යාපාරයේ ස්මාර්ට් කොන්ත්‍රාත්තු භාවිතය පිළිබඳ නිශ්චිත උදාහරණ දෙස බලමු: වෙන්දේසි පැවැත්වීම, රක්ෂණය සහ පක්ෂපාතී වැඩසටහන් නිර්මාණය කිරීමේදී.

වෙන්දේසි

සාර්ථක වෙන්දේසියක් සඳහා වන එක් කොන්දේසියක් වන්නේ විනිවිදභාවයයි: ලංසු හැසිරවීමට නොහැකි බව සහභාගිවන්නන් විශ්වාස කළ යුතුය. බ්ලොක්චේන් වලට ස්තූතිවන්ත වන පරිදි මෙය සාක්ෂාත් කරගත හැකිය, එහිදී සියලුම ඔට්ටු ඇල්ලීම සහ ඒවා සාදන ලද කාලය පිළිබඳ වෙනස් කළ නොහැකි දත්ත සියලුම සහභාගිවන්නන්ට ලබා ගත හැකිය.

Waves blockchain මත, DataTransaction හරහා වෙන්දේසි ගිණුම් තත්ත්වය තුළ ලංසු සටහන් කළ හැක.

ඔබට බ්ලොක් අංක භාවිතයෙන් වෙන්දේසියේ ආරම්භක සහ අවසන් වේලාවද සැකසිය හැක: Waves blockchain හි වාරණ උත්පාදනයේ සංඛ්‍යාතය ආසන්න වශයෙන් සමාන වේ 60 තත්පර.

1. ඉංග්‍රීසි ඉහළ යන මිල වෙන්දේසිය

ඉංග්‍රීසි වෙන්දේසියක සහභාගිවන්නන් එකිනෙකා සමඟ තරඟකාරී ලෙස ලංසු ඉදිරිපත් කරයි. සෑම නව ඔට්ටුවක්ම පෙර එක ඉක්මවිය යුතුය. අවසන් ලංසුව ඉක්මවීමට තවත් ලංසුකරුවන් නොමැති විට වෙන්දේසිය අවසන් වේ. මෙම අවස්ථාවේදී, වැඩිම ලංසුකරු විසින් ප්රකාශිත මුදල ලබා දිය යුතුය.

විකුණුම්කරු විසින් කැබලි අක්ෂර සඳහා අවම මිලක් නියම කරන වෙන්දේසි විකල්පයක් ද ඇත, අවසාන මිල එය ඉක්මවා යා යුතුය. එසේ නොමැති නම්, කැබලි අක්ෂරය අලෙවි නොවී පවතී.

මෙම උදාහරණයේ දී, අපි වෙන්දේසිය සඳහා විශේෂයෙන් නිර්මාණය කරන ලද ගිණුමක් සමඟ වැඩ කරන්නෙමු. වෙන්දේසි කාලසීමාව කුට්ටි 3000 ක් වන අතර, කැබලි අක්ෂරයේ ආරම්භක මිල තරංග 0,001 කි. සහභාගිවන්නෙකුට "මිල" යතුර සහ ඔවුන්ගේ ලංසුවේ වටිනාකම සමඟ දත්ත ගනුදෙනුවක් යැවීමෙන් ලංසුවක් තැබිය හැකිය.

නව ලංසුවේ මිල මෙම යතුර සඳහා වත්මන් මිලට වඩා වැඩි විය යුතු අතර, සහභාගිවන්නාගේ ගිණුමේ අවම වශයෙන් [new_bid + commission] ටෝකන තිබිය යුතුය. ලංසුකරුගේ ලිපිනය DataTransaction හි "යවන්නා" ක්ෂේත්‍රයේ සටහන් කළ යුතු අතර, වත්මන් ලංසු වාරණ උස වෙන්දේසි කාල සීමාව තුළ විය යුතුය.

වෙන්දේසිය අවසානයේ සහභාගිවන්නා ඉහළම මිල නියම කර තිබේ නම්, ඔහුට නියමිත මිලට සහ මුදල් යුගලයට අදාළ කොටස සඳහා ගෙවීමට ExchangeTransaction යැවිය හැක.

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. අඩුවන මිල ලන්දේසි වෙන්දේසිය

ලන්දේසි වෙන්දේසියකදී, ගැනුම්කරු ගෙවීමට කැමති මුදලට වඩා වැඩි මිලකට මුලින් බොහෝ දේ පිරිනමනු ලැබේ. සහභාගිවන්නන්ගෙන් එක් අයෙකු වත්මන් මිලට ඉඩම මිලදී ගැනීමට එකඟ වන තෙක් මිල පියවරෙන් පියවර අඩු කරනු ලැබේ.

මෙම උදාහරණයේ දී අපි පෙර එකෙහි මෙන් එකම නියතයන් මෙන්ම ඩෙල්ටා අඩු වන විට මිල පියවර භාවිතා කරමු. ගිණුම් ස්ක්‍රිප්ට් එක ඔට්ටුවක් තැබූ පළමු පුද්ගලයාද යන්න පරීක්ෂා කරයි. එසේ නොමැති නම්, බ්ලොක්චේන් විසින් DataTransaction පිළිගනු නොලැබේ.

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. වෙන්දේසිය "සියලු වැටුප්"

"සියලු ගෙවීම්" යනු ලොට් එක දිනන්නේ කවුරුන්ද යන්න නොසලකා සියලුම සහභාගිවන්නන් ලංසුව ගෙවන වෙන්දේසියකි. සෑම නව සහභාගිවන්නෙකුම ලංසුවක් ගෙවන අතර, උපරිම ලංසුව ඉදිරිපත් කරන සහභාගිකයා ලොට් එක දිනා ගනී.

අපගේ උදාහරණයේ දී, එක් එක් වෙන්දේසි සහභාගිවන්නන් (යතුර, වටිනාකම)* = (“ජයග්‍රාහකයා”, ලිපිනය), (“මිල”, මිල) සමඟ DataTransaction හරහා ලංසුවක් තබයි. එවැනි දත්ත ගනුදෙනුවක් අනුමත කරනු ලබන්නේ මෙම සහභාගිවන්නාගේ අත්සන සහිත හුවමාරු ගනුදෙනුවක් දැනටමත් තිබේ නම් සහ ඔහුගේ ලංසුව පෙර පැවති සියල්ලට වඩා වැඩි නම් පමණි. අවසාන උසට ළඟා වන තෙක් වෙන්දේසිය දිගටම පවතී.

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

රක්ෂණ / සමූහ අරමුදල් සැපයීම

මූල්‍ය අලාභයන්ට එරෙහිව පරිශීලකයින්ගේ වත්කම් රක්ෂණය කිරීමට ඔබට අවශ්‍ය තත්වයක් සලකා බලමු. උදාහරණයක් ලෙස, පරිශීලකයෙකුට ටෝකනයක් ක්ෂය වුවහොත්, මෙම ටෝකන සඳහා ගෙවන ලද සම්පූර්ණ මුදල ආපසු ලබා ගත හැකි බවට සහතිකයක් අවශ්‍ය වන අතර සාධාරණ රක්ෂණ මුදලක් ගෙවීමට කැමැත්තෙන් සිටී.

මෙය ක්රියාත්මක කිරීම සඳහා, "රක්ෂණ ටෝකන්" නිකුත් කිරීම අවශ්ය වේ. එවිට රක්ෂණ ඔප්පුහිමියාගේ ගිණුමේ ස්ක්‍රිප්ට් එකක් ස්ථාපනය කර, යම් යම් කොන්දේසි සපුරාලන හුවමාරු ගනුදෙනු පමණක් ක්‍රියාත්මක කිරීමට ඉඩ සලසයි.

ද්විත්ව වියදම් වැලැක්වීම සඳහා, ඔබ (යතුර, වටිනාකම) = (purchaseTransactionId, sellOrderId) සමඟින් කල්තියා රක්ෂණ ඔප්පුහිමියාගේ ගිණුමට DataTransaction යැවීමට පරිශීලකයාගෙන් ඉල්ලා සිටිය යුතු අතර දැනටමත් භාවිත කර ඇති යතුරක් සමඟ DataTransactions යැවීම තහනම් කරන්න.

එබැවින්, පරිශීලකයාගේ සාක්ෂිවල රක්ෂණ ටෝකන් මිලදී ගැනීමේ ගනුදෙනු හැඳුනුම්පත අඩංගු විය යුතුය. මුදල් යුගලය මිලදී ගැනීමේ ගනුදෙනුවේ මෙන් ම විය යුතුය. පිරිවැය ද රක්ෂණයේ මිල අඩු කිරීම, මිලදී ගැනීමේදී නියම කර ඇති මුදලට සමාන විය යුතුය.

පසුව රක්ෂණ ගිණුම පරිශීලකයාගෙන් රක්ෂණ ටෝකන මිලදී ගත් මිලට වඩා අඩු මිලකට මිලදී ගන්නා බව වටහා ගත හැකිය: රක්ෂණ ගිණුම හුවමාරු ගනුදෙනුවක් නිර්මාණය කරයි, පරිශීලකයා ඇණවුම අත්සන් කරයි (ගනුදෙනුව නිවැරදිව සම්පූර්ණ කර ඇත්නම්), රක්ෂණ ගිණුම දෙවන ඇණවුම සහ සම්පූර්ණ ගනුදෙනුව අත්සන් කර එය බ්ලොක්චේන් වෙත යවයි.

මිලදී ගැනීමක් සිදු නොවන්නේ නම්, පරිශීලකයාට ස්ක්‍රිප්ටයේ විස්තර කර ඇති නීතිවලට අනුව හුවමාරු ගනුදෙනුවක් සාදා ගනුදෙනුව බ්ලොක්චේන් වෙත යැවිය හැකිය. මේ ආකාරයෙන් පරිශීලකයාට රක්ෂිත ටෝකන මිලදී ගැනීම සඳහා වියදම් කළ මුදල් ආපසු ලබා දිය හැකිය.

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

රක්ෂණ ටෝකනයක් ස්මාර්ට් වත්කමක් බවට පත් කළ හැකිය, උදාහරණයක් ලෙස, එය තෙවන පාර්ශවයකට මාරු කිරීම තහනම් කිරීම.

මෙම යෝජනා ක්‍රමය ක්‍රවුඩ් ෆන්ඩින් ටෝකන් සඳහාද ක්‍රියාත්මක කළ හැකි අතර, අවශ්‍ය මුදල එකතු කර නොමැති නම් අයිතිකරුවන් වෙත ආපසු ලබා දෙනු ලැබේ.

ගනුදෙනු බදු

වත්කම් වර්ග කිහිපයක් සමඟ එක් එක් ගනුදෙනුව සඳහා බදු එකතු කිරීමට අවශ්‍ය අවස්ථාවන්හිදී ස්මාර්ට් ගිවිසුම් ද අදාළ වේ. ස්ථාපනය කර ඇති නව වත්කමක් හරහා මෙය කළ හැකිය අනුග්රාහකත්වය ස්මාර්ට් වත්කම් සමඟ ගනුදෙනු සඳහා:

1. අපි FeeCoin නිකුත් කරන්නෙමු, එය ස්ථාවර මිලකට පරිශීලකයින් වෙත යවනු ලැබේ: 0,01 WAVES = 0,001 FeeCoin.

2. FeeCoin සඳහා අනුග්‍රාහකත්වය සකසන්න සහ විනිමය අනුපාතය: 0,001 WAVES = 0,001 FeeCoin.

3. ස්මාර්ට් වත්කම සඳහා පහත ස්ක්‍රිප්ට් සකසන්න:

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
}

දැන් යමෙකු N ස්මාර්ට් වත්කම් මාරු කරන සෑම අවස්ථාවකම, ඔවුන් ඔබට N/taxDivisor ප්‍රමාණයෙන් FeeCoin ලබා දෙනු ඇත (එය ඔබෙන් 10 *N/taxDivisor WAVES හිදී මිලදී ගත හැක), ඔබ පතල් කම්කරුවාට N/taxDivisor WAVES ලබා දෙනු ඇත. එහි ප්‍රතිඵලයක් වශයෙන්, ඔබේ ලාභය (බදු) 9*N / taxDivisor WAVES වනු ඇත.

ඔබට ස්මාර්ට් වත්කම් ස්ක්‍රිප්ට් එකක් සහ 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 යනු භාණ්ඩයක් හෝ සේවාවක් සඳහා වැය කළ මුදලින් කොටසක් ගැනුම්කරුට ආපසු ලැබෙන ලෝයල්ටි වැඩසටහනකි.

ස්මාර්ට් ගිණුමක් භාවිතයෙන් මෙම නඩුව ක්‍රියාත්මක කිරීමේදී, අපි රක්ෂණ නඩුවේදී කළ ආකාරයටම සාක්ෂි පරීක්ෂා කළ යුතුය. ද්විත්ව වියදම් වැලැක්වීම සඳහා, පරිශීලකයා මුදල් ආපසු ලබා ගැනීමට පෙර (යතුර, වටිනාකම) = (purchaseTransactionId, cashbackTransactionId) සමඟ DataTransaction යැවිය යුතුය.

අපි DataTransaction භාවිතයෙන් පවතින යතුරු සඳහාද තහනමක් සැකසිය යුතුය. cashbackDivisor - මුදල් ආපසු කොටසෙන් බෙදූ ඒකකය. එම. මුදල් ආපසු කොටස 0.1 නම්, පසුව 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 swap මඟින් හුවමාරුවක ආධාරයෙන් තොරව වත්කම් හුවමාරු කර ගැනීමට පරිශීලකයින්ට ඉඩ සලසයි. පරමාණුක හුවමාරුවක් සමඟ, ගනුදෙනුවේ සහභාගිවන්නන් දෙදෙනාම නිශ්චිත කාලයක් තුළ එය තහවුරු කිරීමට අවශ්ය වේ.

ගනුදෙනුව සඳහා වෙන් කර ඇති කාලය තුළ අවම වශයෙන් එක් සහභාගිවන්නෙකු ගනුදෙනුව පිළිබඳ නිවැරදි තහවුරු කිරීමක් ලබා නොදෙන්නේ නම්, ගනුදෙනුව අවලංගු වන අතර හුවමාරුව සිදු නොවේ.

අපගේ උදාහරණයේදී, අපි පහත ස්මාර්ට් ගිණුම් ස්ක්‍රිප්ට් භාවිතා කරමු:

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
}

මීළඟ ලිපියෙන් අපි විකල්ප, අනාගත සහ බිල්පත් වැනි මූල්‍ය උපකරණවල ස්මාර්ට් ගිණුම් භාවිතා කිරීම දෙස බලමු.

මූලාශ්රය: www.habr.com