ፕሮሆስተር > ጦማር > አስተዳደር > የ Waves smart accounts መተግበሪያ፡ ከጨረታ እስከ ጉርሻ ፕሮግራሞች

የ Waves smart accounts መተግበሪያ፡ ከጨረታ እስከ ጉርሻ ፕሮግራሞች

የ Waves smart accounts መተግበሪያ፡ ከጨረታ እስከ ጉርሻ ፕሮግራሞች

Blockchain ብዙውን ጊዜ ከክሪፕቶ ምንዛሬዎች ጋር ብቻ የተያያዘ ነው, ነገር ግን የዲኤልቲ ቴክኖሎጂ አተገባበር ቦታዎች በጣም ሰፊ ናቸው. ለብሎክቼይን አጠቃቀም በጣም ተስፋ ሰጭ ከሆኑት ውስጥ አንዱ በራስ-ሰር የሚሰራ እና በገቡት ወገኖች መካከል መተማመን የማይፈልግ ስማርት ውል ነው።

RIDE - ለዘመናዊ ኮንትራቶች ቋንቋ

ሞገዶች ለዘመናዊ ኮንትራቶች ልዩ ቋንቋ አዘጋጅተዋል - RIDE. የእሱ ሙሉ ሰነድ ይገኛል እዚህ. እና እዚህ - በዚህ ርዕስ ላይ ጽሑፍ በሀብር ላይ

የ RIDE ውል ተሳቢ ነው እና እንደ ውፅዓት "እውነት" ወይም "ሐሰት" ይመልሳል. በዚህ መሠረት ግብይቱ በብሎክቼይን ውስጥ ተመዝግቧል ወይም ውድቅ ተደርጓል። ብልጥ ኮንትራቱ የተገለጹትን ሁኔታዎች መሟላት ሙሉ በሙሉ ዋስትና ይሰጣል. በ RIDE ውስጥ ካለው ውል ግብይቶችን መፍጠር በአሁኑ ጊዜ አይቻልም።

ዛሬ ሁለት ዓይነት ሞገዶች ብልጥ ኮንትራቶች አሉ-ስማርት መለያዎች እና ብልጥ ንብረቶች። ስማርት መለያ መደበኛ የተጠቃሚ መለያ ነው፣ነገር ግን ሁሉንም ግብይቶች የሚቆጣጠር ስክሪፕት ተዘጋጅቷል። ዘመናዊ የመለያ ስክሪፕት ይህን ሊመስል ይችላል፣ ለምሳሌ፡-

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

tx የዝውውር ግብይት ካልሆነ ብቻ የስርዓተ ጥለት ማዛመጃ ዘዴን በመጠቀም የምንፈቅደው በሂደት ላይ ያለ ግብይት ነው። በ RIDE ውስጥ የስርዓተ-ጥለት ማዛመድ የግብይቱን አይነት ለመፈተሽ ጥቅም ላይ ይውላል። ሁሉም ነባር መለያዎች በስማርት መለያ ስክሪፕት ውስጥ ሊሠሩ ይችላሉ። የግብይት ዓይነቶች.

ስክሪፕቱ እንዲሁ ተለዋዋጮችን ማወጅ፣ ሁኔታዎችን ሙሉ በሙሉ ለማረጋገጥ “ከሆነ-ከሆነ” ግንባታዎችን እና ሌሎች ዘዴዎችን መጠቀም ይችላል። ኮንትራቶች የኮንትራት አፈፃፀም ከመጀመሩ በፊት ለመተንበይ ቀላል የሆነ ሙሉነት እና ውስብስብነት (ወጪ) እንዲኖራቸው ለማረጋገጥ RIDE loops ወይም የዝላይ መግለጫዎችን አልያዘም።

የ Waves መለያዎች ሌሎች ባህሪያት የ "ግዛት" መኖርን ያካትታሉ, ማለትም የመለያው ሁኔታ. የውሂብ ግብይቶችን (DataTransaction) በመጠቀም ገደብ የለሽ ጥንድ ጥንድ (ቁልፍ፣ እሴት) ወደ መለያ ሁኔታ መፃፍ ይችላሉ። ይህ መረጃ በሁለቱም በREST API እና በቀጥታ በስማርት ኮንትራት ሊሰራ ይችላል።

እያንዳንዱ ግብይት የተሣታፊው ፊርማ፣ የሚፈለገው ግብይት መታወቂያ፣ ወዘተ የሚገቡበት ብዙ ማስረጃዎችን ሊይዝ ይችላል።

ከ RIDE ጋር በመስራት ላይ አይዲኢ የኮንትራቱን የተቀናጀ እይታ እንዲመለከቱ ያስችልዎታል (ከተጠናቀረ) ፣ አዲስ መለያዎችን ይፍጠሩ እና ለእሱ ስክሪፕቶች ያዘጋጁ ፣ እንዲሁም ግብይቶችን በትእዛዝ መስመር ይላኩ።

ለሙሉ ዑደት፣ አካውንት መፍጠርን፣ በእሱ ላይ ዘመናዊ ውል መጫን እና ግብይቶችን መላክን ጨምሮ፣ እንዲሁም ከREST API (ለምሳሌ፣ C#፣ C፣ Java፣ JavaScript፣ Python፣ Rust፣ Elixir) ጋር መስተጋብር ለመፍጠር ቤተ-መጽሐፍትን መጠቀም ይችላሉ። . ከ IDE ጋር መስራት ለመጀመር አዲስ ቁልፍን ብቻ ጠቅ ያድርጉ።

ዘመናዊ ኮንትራቶችን የመጠቀም ዕድሎች ሰፊ ናቸው፡ ግብይቶችን ከመከልከል እስከ አንዳንድ አድራሻዎች (“ጥቁር ዝርዝር”) እስከ ውስብስብ dApps።

አሁን በንግድ ውስጥ ብልጥ ኮንትራቶችን ስለመጠቀም የተወሰኑ ምሳሌዎችን እንመልከት-ጨረታዎችን ፣ ኢንሹራንስን እና የታማኝነት ፕሮግራሞችን ሲፈጥሩ።

ጨረታዎች

ለተሳካ ጨረታ አንዱ ቅድመ ሁኔታ ግልጽነት ነው፡ ተሳታፊዎች ጨረታዎችን ማጭበርበር እንደማይቻል እርግጠኛ መሆን አለባቸው። ይህ ሊሳካ የሚችለው ለብሎክቼይን ምስጋና ይግባውና ስለ ሁሉም ውርርዶች እና የተደረጉበት ጊዜ የማይለወጥ መረጃ ለሁሉም ተሳታፊዎች የሚገኝ ይሆናል።

በ Waves blockchain ላይ ጨረታዎች በዳታ ትራንስሴሽን በኩል በጨረታ መለያ ሁኔታ መመዝገብ ይችላሉ።

እንዲሁም የማገጃ ቁጥሮችን በመጠቀም የጨረታውን መጀመሪያ እና የመጨረሻ ጊዜ ማቀናበር ይችላሉ-በ Waves blockchain ውስጥ ያለው የማገጃ ድግግሞሽ በግምት እኩል ነው 60 ሰከንዶች.

1. የእንግሊዘኛ ሽቅብ የዋጋ ጨረታ

በእንግሊዘኛ ጨረታ ላይ ያሉ ተሳታፊዎች እርስ በእርሳቸው ፉክክር ያደርጋሉ። እያንዳንዱ አዲስ ውርርድ ከቀዳሚው መብለጥ አለበት። ካለፈው ጨረታ በላይ የሚያልፉ ተጫራቾች በማይኖሩበት ጊዜ ጨረታው ያበቃል። በዚህ ሁኔታ ከፍተኛው ተጫራች የተጠቀሰውን መጠን ማቅረብ አለበት.

እንዲሁም ሻጩ ለዕጣው አነስተኛውን ዋጋ የሚያወጣበት የጨረታ አማራጭ አለ, እና የመጨረሻው ዋጋ ከእሱ በላይ መሆን አለበት. አለበለዚያ እጣው ሳይሸጥ ይቀራል.

በዚህ ምሳሌ ውስጥ፣ ለጨረታ ከተፈጠረ መለያ ጋር እየሰራን ነው። የጨረታው ቆይታ 3000 ብሎኮች ሲሆን የዕጣው መነሻ ዋጋ 0,001 WAVES ነው። አንድ ተሳታፊ ዳታ ትራንሰክሽን ከቁልፍ "ዋጋ" እና ከጨረታው ዋጋ ጋር በመላክ ጨረታ ማቅረብ ይችላል።

የአዲሱ ጨረታ ዋጋ ለዚህ ቁልፍ አሁን ካለው ዋጋ ከፍ ያለ መሆን አለበት፣ እና ተሳታፊው ቢያንስ በሂሳቡ ውስጥ [new_bid + commission] tokens ሊኖረው ይገባል። የተጫራቾች አድራሻ በ "ዳታ ትራንስሴሽን" ውስጥ "ላኪ" ውስጥ መመዝገብ አለበት, እና የአሁኑ የጨረታ እገዳ ቁመት በጨረታው ጊዜ ውስጥ መሆን አለበት.

በጨረታው መጨረሻ ላይ ተሳታፊው ከፍተኛውን ዋጋ ካስቀመጠ ለተመሳሳይ ዋጋ በተጠቀሰው ዋጋ እና ምንዛሪ ጥንድ ለመክፈል 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 በ 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. “ሁሉንም ክፍያ” ጨረታ

“ሁሉንም ክፍያ” ጨረታውን ማን ያሸነፈው ምንም ይሁን ምን ሁሉም ተሳታፊዎች የሚከፍሉበት ጨረታ ነው። እያንዳንዱ አዲስ ተሳታፊ ጨረታ ይከፍላል፣ እና ከፍተኛውን ጨረታ የሚያወጣው ተሳታፊ እጣውን ያሸንፋል።

በእኛ ምሳሌ፣ እያንዳንዱ የጨረታ ተሳታፊ በ 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 ቀደም ሲል ጥቅም ላይ በዋለ ቁልፍ መላክን መከልከል አለቦት።

ስለዚህ, የተጠቃሚው ማረጋገጫዎች የኢንሹራንስ ማስመሰያ ግዢ የግብይት መታወቂያ መያዝ አለባቸው. የመገበያያ ገንዘብ ጥንድ በግዢ ግብይት ውስጥ አንድ አይነት መሆን አለበት. ወጪውም በግዢ ጊዜ ከተወሰነው ጋር እኩል መሆን አለበት፣ የመድን ዋጋ ሲቀነስ።

በመቀጠልም የኢንሹራንስ መለያው የኢንሹራንስ ቶከኖችን ከገዛው ባነሰ ዋጋ ከተጠቃሚው እንደሚገዛ ተረድቷል፡ የኢንሹራንስ መለያው ExchangeTransaction ይፈጥራል፣ ተጠቃሚው ትዕዛዙን ይፈርማል (ግብይቱ በትክክል ከተጠናቀቀ)፣ የኢንሹራንስ መለያ ሁለተኛውን ትዕዛዝ እና አጠቃላይ ግብይቱን ይፈርማል እና ወደ blockchain ይልካል.

ምንም ግዢ ካልተከሰተ ተጠቃሚው በስክሪፕቱ ውስጥ በተገለጹት ህጎች መሠረት የ ExchangeTransaction መፍጠር እና ግብይቱን ወደ blockchain መላክ ይችላል። በዚህ መንገድ ተጠቃሚው የመድህን ቶከኖች ግዢ ላይ ያወጣውን ገንዘብ መመለስ ይችላል።

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 ዘመናዊ ንብረቶችን በሚያስተላልፍበት ጊዜ ሁሉ 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
}

በሚቀጥለው ርዕስ ውስጥ እንደ አማራጮች, የወደፊት ጊዜዎች እና ሂሳቦች ባሉ የፋይናንስ መሳሪያዎች ውስጥ ዘመናዊ ሂሳቦችን መጠቀምን እንመለከታለን.

ምንጭ: hab.com

አስተያየት ያክሉ