वेव्हस् स्मार्ट अकाउंट्सचे अॅप्लिकेशन्स: लिलावापासून बोनस प्रोग्राम्सपर्यंत

ब्लॉकचेन बहुतेकदा केवळ क्रिप्टोकरन्सीशी संबंधित असते, परंतु डीएलटी तंत्रज्ञानाच्या वापराचे क्षेत्र बरेच विस्तृत आहे. ब्लॉकचेनच्या वापरासाठी सर्वात आशादायक क्षेत्रांपैकी एक म्हणजे एक स्मार्ट करार जो आपोआप अंमलात आणला जातो आणि त्यात प्रवेश केलेल्या पक्षांमधील विश्वासाची आवश्यकता नसते.

RIDE – स्मार्ट करारांसाठी एक भाषा

वेव्हजने स्मार्ट कॉन्ट्रॅक्टसाठी एक विशेष भाषा विकसित केली आहे - RIDE. त्याची संपूर्ण कागदपत्रे स्थित आहेत येथे. आणि इथे - या विषयावरील लेख Habr वर.

RIDE करार हा एक पूर्वनिर्धारित आहे आणि आउटपुट म्हणून "सत्य" किंवा "असत्य" परत करतो. त्यानुसार, व्यवहार एकतर ब्लॉकचेनमध्ये रेकॉर्ड केला जातो किंवा नाकारला जातो. स्मार्ट करार निर्दिष्ट अटींच्या पूर्ततेची पूर्णपणे हमी देतो. RIDE मधील करारातून व्यवहार निर्माण करणे सध्या शक्य नाही.

आज दोन प्रकारचे Waves स्मार्ट करार आहेत: स्मार्ट खाती आणि स्मार्ट मालमत्ता. स्मार्ट खाते हे नियमित वापरकर्ता खाते असते, परंतु त्यासाठी एक स्क्रिप्ट सेट केली जाते जी सर्व व्यवहार नियंत्रित करते. स्मार्ट खाते स्क्रिप्ट यासारखे दिसू शकते, उदाहरणार्थ:

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

tx हा एक व्यवहार आहे ज्यावर प्रक्रिया केली जात आहे ज्याला आम्ही पॅटर्न मॅचिंग यंत्रणा वापरण्याची परवानगी देतो जर तो हस्तांतरण व्यवहार नसेल. RIDE मधील पॅटर्न मॅचिंगचा वापर व्यवहाराचा प्रकार तपासण्यासाठी केला जातो. सर्व विद्यमान खात्यांवर स्मार्ट खाते स्क्रिप्टमध्ये प्रक्रिया केली जाऊ शकते व्यवहाराचे प्रकार.

स्क्रिप्ट व्हेरिएबल्स देखील घोषित करू शकते, परिस्थिती पूर्णपणे तपासण्यासाठी “जर-तर-अन्यतर” रचना आणि इतर पद्धती वापरू शकते. कराराची अंमलबजावणी सुरू होण्याआधी अंदाज लावता येण्याजोगा पूर्णता आणि जटिलता (किंमत) आहे याची खात्री करण्यासाठी, RIDE मध्ये लूप किंवा जंप स्टेटमेंट नाहीत.

वेव्हज खात्यांच्या इतर वैशिष्ट्यांमध्ये “राज्य” म्हणजेच खात्याची स्थिती समाविष्ट आहे. तुम्ही डेटा ट्रान्झॅक्शन्स (डेटा ट्रान्झॅक्शन) वापरून खात्याच्या स्थितीवर अनंत संख्येत जोड्यांची (की, मूल्य) लिहू शकता. या माहितीवर नंतर REST API द्वारे आणि थेट स्मार्ट करारामध्ये प्रक्रिया केली जाऊ शकते.

प्रत्येक व्यवहारामध्ये अनेक पुरावे असू शकतात, ज्यामध्ये सहभागीची स्वाक्षरी, आवश्यक व्यवहाराचा आयडी इ. प्रविष्ट केला जाऊ शकतो.

RIDE द्वारे कार्य करत आहे येथे तुम्हाला कराराचे संकलित दृश्य पाहण्याची परवानगी देते (जर ते संकलित केले असेल), नवीन खाती तयार करा आणि त्यासाठी स्क्रिप्ट सेट करा, तसेच कमांड लाइनद्वारे व्यवहार पाठवा.

खाते तयार करणे, त्यावर स्मार्ट करार स्थापित करणे आणि व्यवहार पाठवणे यासह संपूर्ण चक्रासाठी, तुम्ही REST API (उदाहरणार्थ, C#, C, Java, JavaScript, Python, Rust, Elixir) सह संवाद साधण्यासाठी लायब्ररी देखील वापरू शकता. . IDE सह कार्य सुरू करण्यासाठी, फक्त नवीन बटणावर क्लिक करा.

स्मार्ट कॉन्ट्रॅक्ट्स वापरण्याच्या शक्यता विस्तृत आहेत: काही पत्त्यांवर ("ब्लॅक लिस्ट") व्यवहार प्रतिबंधित करण्यापासून ते जटिल dApps पर्यंत.

आता व्यवसायात स्मार्ट कराराच्या वापराची विशिष्ट उदाहरणे पाहू: लिलाव, विमा आणि लॉयल्टी प्रोग्राम तयार करताना.

लिलाव

यशस्वी लिलावाची एक अटी म्हणजे पारदर्शकता: सहभागींना खात्री असणे आवश्यक आहे की बिड्समध्ये फेरफार करणे अशक्य आहे. ब्लॉकचेनमुळे हे साध्य केले जाऊ शकते, जिथे सर्व बेट आणि ते केव्हा केले गेले त्याबद्दल अपरिवर्तनीय डेटा सर्व सहभागींना उपलब्ध असेल.

वेव्हज ब्लॉकचेनवर, लिलाव खात्याच्या स्थितीत डेटा ट्रान्झॅक्शनद्वारे बोली नोंदवल्या जाऊ शकतात.

तुम्ही ब्लॉक नंबर वापरून लिलावाची सुरुवात आणि समाप्ती वेळ देखील सेट करू शकता: वेव्हज ब्लॉकचेनमध्ये ब्लॉक जनरेशनची वारंवारता अंदाजे समान आहे 60 सेकंद

1. इंग्रजी चढत्या किंमतीचा लिलाव

इंग्रजी लिलावातील सहभागी एकमेकांशी स्पर्धेत बोली लावतात. प्रत्येक नवीन पैज मागील एकापेक्षा जास्त असणे आवश्यक आहे. शेवटची बोली ओलांडण्यासाठी अधिक बोलीदार नसतात तेव्हा लिलाव संपतो. या प्रकरणात, सर्वाधिक बोली लावणाऱ्याने नमूद केलेली रक्कम प्रदान करणे आवश्यक आहे.

एक लिलाव पर्याय देखील आहे ज्यामध्ये विक्रेता लॉटसाठी किमान किंमत सेट करतो आणि अंतिम किंमत त्यापेक्षा जास्त असणे आवश्यक आहे. अन्यथा, लॉट न विकला जातो.

या उदाहरणामध्ये, आम्ही विशेषतः लिलावासाठी तयार केलेल्या खात्यासह कार्य करत आहोत. लिलावाचा कालावधी 3000 ब्लॉक्सचा आहे आणि लॉटची सुरुवातीची किंमत 0,001 WAVES आहे. सहभागी "किंमत" आणि त्यांच्या बोलीच्या मूल्यासह डेटा व्यवहार पाठवून बोली लावू शकतो.

नवीन बोलीची किंमत या कीसाठी सध्याच्या किंमतीपेक्षा जास्त असणे आवश्यक आहे आणि सहभागीच्या खात्यात किमान [नवीन_बिड + कमिशन] टोकन असणे आवश्यक आहे. डेटा ट्रान्झॅक्शनमधील "प्रेषक" फील्डमध्ये बोली लावणाऱ्याचा पत्ता नोंदवला गेला पाहिजे आणि सध्याची बोली ब्लॉक उंची लिलावाच्या कालावधीत असणे आवश्यक आहे.

लिलावाच्या शेवटी सहभागीने सर्वोच्च किंमत सेट केली असल्यास, तो निर्दिष्ट किंमत आणि चलन जोडीवर संबंधित लॉटसाठी देय देण्यासाठी एक्सचेंज ट्रान्झॅक्शन पाठवू शकतो.

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. कमी होणाऱ्या किमतींचा डच लिलाव

डच लिलावात, खरेदीदार जेवढे पैसे देऊ इच्छितो त्यापेक्षा जास्त किंमतीला सुरुवातीला भरपूर ऑफर केले जाते. सहभागींपैकी एकाने सध्याच्या किमतीवर लॉट खरेदी करण्यास सहमती होईपर्यंत किंमत टप्प्याटप्प्याने कमी होते.

या उदाहरणात आम्ही मागील प्रमाणेच स्थिरांक वापरतो, तसेच डेल्टा कमी झाल्यावर किंमतीची पायरी वापरतो. खाते स्क्रिप्ट तपासते की सहभागी खरोखरच पैज लावणारा पहिला आहे की नाही. अन्यथा, ब्लॉकचेनद्वारे डेटा ट्रान्झॅक्शन स्वीकारले जाणार नाही.

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

विमा / Crowdfunding

चला अशा परिस्थितीचा विचार करूया जिथे तुम्हाला वापरकर्त्यांच्या मालमत्तेचा आर्थिक नुकसानीपासून विमा उतरवण्याची गरज आहे. उदाहरणार्थ, एखाद्या वापरकर्त्याला हमी हवी असते की टोकनचे अवमूल्यन झाल्यास, तो या टोकन्ससाठी भरलेली संपूर्ण रक्कम परत मिळवण्यास सक्षम असेल आणि तो विम्याची वाजवी रक्कम भरण्यास तयार असेल.

याची अंमलबजावणी करण्यासाठी, "विमा टोकन" जारी करणे आवश्यक आहे. नंतर पॉलिसीधारकाच्या खात्यावर एक स्क्रिप्ट स्थापित केली जाते, जी काही विशिष्ट अटी पूर्ण करणार्‍या एक्सचेंज व्यवहारांनाच अंमलात आणण्याची परवानगी देते.

दुहेरी खर्च रोखण्यासाठी, तुम्ही वापरकर्त्याला पॉलिसीधारकाच्या खात्यावर (की, मूल्य) = (purchaseTransactionId, sellOrderId) सह आगाऊ डेटा व्यवहार पाठवण्याची विनंती करणे आवश्यक आहे आणि आधीपासून वापरलेल्या की वापरून डेटा व्यवहार पाठवण्यास प्रतिबंधित करणे आवश्यक आहे.

म्हणून, वापरकर्त्याच्या पुराव्यामध्ये विमा टोकन खरेदीचा व्यवहार आयडी असणे आवश्यक आहे. चलन जोडी खरेदी व्यवहाराप्रमाणेच असणे आवश्यक आहे. किंमत देखील खरेदीच्या वेळी निश्चित केलेल्या विम्याची किंमत वजा समान असणे आवश्यक आहे.

असे समजले जाते की नंतर विमा खाते वापरकर्त्याकडून विमा टोकन विकत घेते ज्या किंमतीला त्याने खरेदी केले त्यापेक्षा कमी नाही: विमा खाते एक्सचेंज ट्रान्झॅक्शन तयार करते, वापरकर्ता ऑर्डरवर स्वाक्षरी करतो (जर व्यवहार योग्यरित्या पूर्ण झाला असेल), विमा खाते दुसऱ्या ऑर्डरवर आणि संपूर्ण व्यवहारावर स्वाक्षरी करते आणि ब्लॉकचेनला पाठवते.

कोणतीही खरेदी न झाल्यास, वापरकर्ता स्क्रिप्टमध्ये वर्णन केलेल्या नियमांनुसार एक्सचेंज ट्रान्झॅक्शन तयार करू शकतो आणि व्यवहार ब्लॉकचेनला पाठवू शकतो. अशा प्रकारे वापरकर्ता विमाधारक टोकन खरेदीवर खर्च केलेले पैसे परत करू शकतो.

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/ tax Divisor 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
}

कॅशबॅक आणि लॉयल्टी प्रोग्राम

कॅशबॅक हा लॉयल्टी प्रोग्रामचा एक प्रकार आहे ज्यामध्ये खरेदीदाराला उत्पादन किंवा सेवेवर खर्च केलेल्या रकमेचा काही भाग परत मिळतो.

स्मार्ट खाते वापरून या प्रकरणाची अंमलबजावणी करताना, आम्ही विमा प्रकरणात जसे तपासले तसे पुरावे तपासले पाहिजेत. दुहेरी खर्च टाळण्यासाठी, कॅशबॅक प्राप्त करण्यापूर्वी वापरकर्त्याने (की, मूल्य) = (खरेदी व्यवहार आयडी, कॅशबॅक ट्रॅन्सॅक्शनआयडी) सह डेटा व्यवहार पाठवणे आवश्यक आहे.

आम्ही डेटा ट्रान्झॅक्शन वापरून विद्यमान की वर बंदी देखील सेट केली पाहिजे. cashbackDivisor - कॅशबॅक शेअरने भागलेले युनिट. त्या. कॅशबॅक शेअर 0.1 असल्यास, कॅशबॅक डिव्हिझर 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