Waves ჭკვიანი ანგარიშების აპლიკაციები: აუქციონებიდან ბონუს პროგრამებამდე

ბლოკჩეინი ხშირად ასოცირდება მხოლოდ კრიპტოვალუტებთან, მაგრამ DLT ტექნოლოგიის გამოყენების სფეროები გაცილებით ფართოა. ბლოკჩეინის გამოყენების ერთ-ერთი ყველაზე პერსპექტიული სფერო არის ჭკვიანი კონტრაქტი, რომელიც სრულდება ავტომატურად და არ საჭიროებს ნდობას მასში შესულ მხარეებს შორის.

RIDE – ჭკვიანი კონტრაქტების ენა

Waves-მა შეიმუშავა სპეციალური ენა ჭკვიანი კონტრაქტებისთვის - RIDE. მისი სრული დოკუმენტაცია განთავსებულია აქ. Და აქ - სტატია ამ თემაზე ჰაბრზე.

RIDE კონტრაქტი არის პრედიკატი და აბრუნებს "true" ან "false" როგორც გამომავალი. შესაბამისად, ტრანზაქცია ან ჩაიწერება ბლოკჩეინში, ან უარყოფილია. სმარტ კონტრაქტი სრულ გარანტიას იძლევა მითითებული პირობების შესრულებას. RIDE-ში კონტრაქტიდან ტრანზაქციების გენერირება ამჟამად შეუძლებელია.

დღეს არსებობს Waves-ის ჭკვიანი კონტრაქტების ორი ტიპი: ჭკვიანი ანგარიშები და ჭკვიანი აქტივები. ჭკვიანი ანგარიში არის ჩვეულებრივი მომხმარებლის ანგარიში, მაგრამ მისთვის დაყენებულია სკრიპტი, რომელიც აკონტროლებს ყველა ტრანზაქციას. ჭკვიანი ანგარიშის სკრიპტი შეიძლება ასე გამოიყურებოდეს, მაგალითად:

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

tx არის დამუშავებული ტრანზაქცია, რომელსაც ჩვენ დავუშვებთ შაბლონის შესატყვისი მექანიზმის გამოყენებას მხოლოდ იმ შემთხვევაში, თუ ეს არ არის გადაცემის ტრანზაქცია. შაბლონის შესატყვისი RIDE-ში გამოიყენება ტრანზაქციის ტიპის შესამოწმებლად. ყველა არსებული ანგარიშის დამუშავება შესაძლებელია ჭკვიანი ანგარიშის სკრიპტში გარიგების ტიპები.

სკრიპტს შეუძლია ასევე გამოაცხადოს ცვლადები, გამოიყენოს „if-then-else“ კონსტრუქტები და სხვა მეთოდები პირობების სრულად შესამოწმებლად. იმის უზრუნველსაყოფად, რომ კონტრაქტებს ჰქონდეთ დასამტკიცებელი სისრულე და სირთულე (ღირებულება), რომლის პროგნოზირება ადვილია კონტრაქტის შესრულების დაწყებამდე, RIDE არ შეიცავს მარყუჟებს ან ნახტომის განცხადებებს.

Waves ანგარიშების სხვა მახასიათებლებს მიეკუთვნება „მდგომარეობის“ არსებობა, ანუ ანგარიშის მდგომარეობა. თქვენ შეგიძლიათ ჩაწეროთ უსასრულო რაოდენობის წყვილი (გასაღები, მნიშვნელობა) ანგარიშის მდგომარეობაზე მონაცემთა ტრანზაქციის გამოყენებით (DataTransaction). შემდეგ ეს ინფორმაცია შეიძლება დამუშავდეს როგორც REST API-ით, ასევე უშუალოდ სმარტ კონტრაქტში.

თითოეული ტრანზაქცია შეიძლება შეიცავდეს მტკიცებულებათა მასივს, რომელშიც შეიძლება შეიყვანოთ მონაწილის ხელმოწერა, საჭირო ტრანზაქციის ID და ა.შ.

მუშაობა RIDE-თან მეშვეობით IDE საშუალებას გაძლევთ ნახოთ კონტრაქტის შედგენილი ხედვა (თუ ის შედგენილია), შექმნათ ახალი ანგარიშები და დააყენოთ მისთვის სკრიპტები, ასევე გაგზავნოთ ტრანზაქციები ბრძანების ხაზის მეშვეობით.

სრული ციკლისთვის, მათ შორის ანგარიშის შექმნა, მასზე ჭკვიანი კონტრაქტის დაყენება და ტრანზაქციების გაგზავნა, ასევე შეგიძლიათ გამოიყენოთ ბიბლიოთეკა REST API-სთან ურთიერთობისთვის (მაგალითად, C#, C, Java, JavaScript, Python, Rust, Elixir) . IDE-სთან მუშაობის დასაწყებად, უბრალოდ დააჭირეთ ღილაკს NEW.

ჭკვიანი კონტრაქტების გამოყენების შესაძლებლობები ფართოა: ტრანზაქციების აკრძალვიდან გარკვეულ მისამართებამდე („შავი სია“) კომპლექსურ dApp-ებამდე.

ახლა მოდით გადავხედოთ ბიზნესში ჭკვიანი კონტრაქტების გამოყენების კონკრეტულ მაგალითებს: აუქციონების ჩატარებისას, დაზღვევისა და ლოიალობის პროგრამების შექმნისას.

აუქციონები

წარმატებული აუქციონის ერთ-ერთი პირობა არის გამჭვირვალობა: მონაწილეები უნდა იყვნენ დარწმუნებულნი, რომ შეუძლებელია წინადადებების მანიპულირება. ამის მიღწევა შესაძლებელია ბლოკჩეინის წყალობით, სადაც უცვლელი მონაცემები ყველა ფსონისა და მათი დადების დროის შესახებ ხელმისაწვდომი იქნება ყველა მონაწილისთვის.

Waves ბლოკჩეინზე, შეთავაზებები შეიძლება ჩაიწეროს აუქციონის ანგარიშის მდგომარეობაში DataTransaction-ის საშუალებით.

თქვენ ასევე შეგიძლიათ დააყენოთ აუქციონის დაწყების და დასრულების დრო ბლოკის ნომრების გამოყენებით: ბლოკების წარმოქმნის სიხშირე Waves ბლოკჩეინში დაახლოებით ტოლია 60 წამი.

1. ინგლისური აღმავალი ფასის აუქციონი

ინგლისურ აუქციონში მონაწილეები ერთმანეთს კონკურენციას უწევენ. ყოველი ახალი ფსონი უნდა აღემატებოდეს წინა ფსონს. აუქციონი მთავრდება, როდესაც აღარ იქნება პრეტენდენტი, რომელიც გადააჭარბებს ბოლო წინადადებას. ამ შემთხვევაში ყველაზე მაღალმა პრეტენდენტმა უნდა წარმოადგინოს მითითებული თანხა.

ასევე არსებობს აუქციონის ვარიანტი, რომლის დროსაც გამყიდველი ადგენს ლოტის მინიმალურ ფასს და საბოლოო ფასი მას უნდა აღემატებოდეს. წინააღმდეგ შემთხვევაში, ლოტი რჩება გაუყიდველი.

ამ მაგალითში ჩვენ ვმუშაობთ სპეციალურად აუქციონისთვის შექმნილ ანგარიშთან. აუქციონის ხანგრძლივობაა 3000 ბლოკი, ხოლო ლოტის საწყისი ფასი 0,001 WAVES. მონაწილეს შეუძლია განათავსოს წინადადება DataTransaction-ის გაგზავნით, რომელშიც მითითებულია საკვანძო „ფასი“ და მათი შეთავაზების ღირებულება.

ახალი ბიდის ფასი უნდა იყოს ამ გასაღების მიმდინარე ფასზე მაღალი და მონაწილეს უნდა ჰქონდეს მინიმუმ [new_bid + საკომისიოს] ტოკენები თავის ანგარიშზე. პრეტენდენტის მისამართი უნდა იყოს ჩაწერილი 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. აუქციონი „ყველა-ანაზღაურებადი“

"All-pay" არის აუქციონი, რომელშიც ყველა მონაწილე იხდის ბიდს, მიუხედავად იმისა, თუ ვინ მოიგებს ლოტს. ყოველი ახალი მონაწილე იხდის ბიდს, ხოლო მონაწილე, რომელიც მაქსიმალურ წინადადებას გააკეთებს, იგებს ლოტს.

ჩვენს მაგალითში, აუქციონის თითოეული მონაწილე განათავსებს წინადადებას 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)
}

დაზღვევა / Crowdfunding

მოდით განვიხილოთ სიტუაცია, როდესაც თქვენ უნდა დააზღვიოთ მომხმარებლების აქტივები ფინანსური ზარალისგან. მაგალითად, მომხმარებელს სურს გარანტია იმისა, რომ თუ ტოკენი გაუფასურდება, ის შეძლებს დაიბრუნოს ამ ტოკენებისთვის გადახდილი სრული თანხა და მზად არის გადაიხადოს გონივრული დაზღვევა.

ამის განსახორციელებლად საჭიროა „დაზღვევის ტოკენების“ გაცემა. შემდეგ დაზღვეულის ანგარიშზე დაინსტალირებულია სკრიპტი, რომელიც საშუალებას აძლევს შესრულდეს მხოლოდ იმ ExchangeTransactions, რომლებიც აკმაყოფილებენ გარკვეულ პირობებს.

ორმაგი ხარჯვის თავიდან ასაცილებლად, თქვენ უნდა სთხოვოთ მომხმარებელს წინასწარ გამოაგზავნოს DataTransaction დაზღვეულის ანგარიშზე (გასაღები, ღირებულება) = (purchaseTransactionId, sellOrderId) და აკრძალოს DataTransactions გაგზავნა უკვე გამოყენებული გასაღებით.

ამიტომ, მომხმარებლის მტკიცებულებები უნდა შეიცავდეს სადაზღვევო ნიშნის შესყიდვის ტრანზაქციის ID-ს. ვალუტის წყვილი უნდა იყოს იგივე, რაც შესყიდვის ტრანზაქციაში. ღირებულება ასევე უნდა იყოს შეძენის დროს დაფიქსირებულის ტოლი დაზღვევის ფასის გამოკლებით.

გასაგებია, რომ შემდგომში სადაზღვევო ანგარიში ყიდულობს დაზღვევის ტოკენებს მომხმარებლისგან იმ ფასად, რომლითაც მან იყიდა ისინი: სადაზღვევო ანგარიში ქმნის ExchangeTransaction-ს, მომხმარებელი ხელს აწერს შეკვეთას (თუ ტრანზაქცია სწორად არის დასრულებული), სადაზღვევო ანგარიშზე ხელს აწერს მეორე შეკვეთას და მთელ ტრანზაქციას და აგზავნის მას ბლოკჩეინში.

თუ შესყიდვა არ მოხდა, მომხმარებელს შეუძლია შექმნას ExchangeTransaction სკრიპტში აღწერილი წესების მიხედვით და გააგზავნოს ტრანზაქცია ბლოკჩეინში. ამ გზით მომხმარებელს შეუძლია დააბრუნოს დაზღვეული ტოკენების შეძენაზე დახარჯული თანხა.

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

დაზღვევის ნიშანი შეიძლება გახდეს ჭკვიანი აქტივი, მაგალითად, აკრძალოს მისი გადაცემა მესამე პირებზე.

ამ სქემის დანერგვა შესაძლებელია ასევე crowdfunding ტოკენებზე, რომლებიც უბრუნდებიან მფლობელებს საჭირო თანხის შეუგროვებლობის შემთხვევაში.

ტრანზაქციის გადასახადები

სმარტ კონტრაქტები ასევე გამოიყენება იმ შემთხვევებში, როდესაც აუცილებელია გადასახადის შეგროვება თითოეულ ტრანზაქციაზე რამდენიმე ტიპის აქტივით. ეს შეიძლება გაკეთდეს ახალი აქტივის მეშვეობით დაინსტალირებული სპონსორობა ჭკვიანი აქტივებით გარიგებებისთვის:

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 სმარტ აქტივებს, მოგცემთ FeeCoin-ს N/taxDivisor-ის ოდენობით (რომლის ყიდვა შეგიძლიათ თქვენგან 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 არის ლოიალობის პროგრამა, რომლის დროსაც მყიდველი უბრუნდება პროდუქტზე ან მომსახურებაზე დახარჯული თანხის ნაწილს.

სმარტ ანგარიშის გამოყენებით ამ შემთხვევის განხორციელებისას ჩვენ უნდა შევამოწმოთ მტკიცებულებები ისევე, როგორც სადაზღვევო საქმეში. ორმაგი ხარჯვის თავიდან ასაცილებლად, მომხმარებელმა უნდა გამოაგზავნოს DataTransaction (გასაღები, მნიშვნელობა) = (purchaseTransactionId, cashbackTransactionId) ქეშბექის მიღებამდე.

ჩვენ ასევე უნდა დავაწესოთ აკრძალვა არსებულ გასაღებებზე DataTransaction-ის გამოყენებით. cashbackDivisor - ერთეული გაყოფილი ქეშბექის წილზე. იმათ. თუ cashback წილი არის 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)
}

ატომური გაცვლა

ატომური სვოპი მომხმარებლებს საშუალებას აძლევს გაცვალონ აქტივები ბირჟის დახმარების გარეშე. ატომური სვოპით, გარიგების ორივე მონაწილე ვალდებულია დაადასტუროს იგი გარკვეული პერიოდის განმავლობაში.

თუ ერთ-ერთი მონაწილე მაინც არ უზრუნველყოფს ტრანზაქციის სწორ დადასტურებას ტრანზაქციისთვის გამოყოფილ დროში, ტრანზაქცია უქმდება და გაცვლა არ ხდება.

ჩვენს მაგალითში, ჩვენ გამოვიყენებთ შემდეგი ჭკვიანი ანგარიშის სკრიპტს:

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