កម្មវិធីនៃគណនីឆ្លាតវៃ Waves៖ ពីការដេញថ្លៃរហូតដល់កម្មវិធីប្រាក់រង្វាន់

Blockchain ជារឿយៗត្រូវបានផ្សារភ្ជាប់ជាមួយនឹងរូបិយប័ណ្ណគ្រីបតូ ប៉ុន្តែផ្នែកនៃការអនុវត្តបច្ចេកវិទ្យា DLT គឺកាន់តែទូលំទូលាយ។ ផ្នែកមួយក្នុងចំណោមតំបន់ដែលជោគជ័យបំផុតសម្រាប់ការប្រើប្រាស់ blockchain គឺជាកិច្ចសន្យាដ៏ឆ្លាតវៃដែលត្រូវបានប្រតិបត្តិដោយស្វ័យប្រវត្តិ ហើយមិនតម្រូវឱ្យមានការជឿទុកចិត្តរវាងភាគីដែលបានបញ្ចូលវានោះទេ។

ជិះ - ភាសាសម្រាប់កិច្ចសន្យាឆ្លាតវៃ

Waves បានបង្កើតភាសាពិសេសសម្រាប់កិច្ចសន្យាឆ្លាតវៃ - RIDE ។ ឯកសារពេញលេញរបស់វាមានទីតាំងនៅ នៅទីនេះ. ហើយនៅទីនេះ - អត្ថបទលើប្រធានបទនេះ។ នៅលើ Habr ។

កិច្ចសន្យា RIDE គឺជាការព្យាករណ៍ ហើយត្រឡប់ "ពិត" ឬ "មិនពិត" ជាលទ្ធផល។ ដូច្នោះហើយប្រតិបត្តិការត្រូវបានកត់ត្រានៅក្នុង blockchain ឬបដិសេធ។ កិច្ចសន្យាឆ្លាតវៃធានាយ៉ាងពេញលេញនូវការបំពេញលក្ខខណ្ឌដែលបានបញ្ជាក់។ ការបង្កើតប្រតិបត្តិការពីកិច្ចសន្យានៅក្នុង RIDE បច្ចុប្បន្នមិនអាចធ្វើទៅបានទេ។

សព្វថ្ងៃនេះ កិច្ចសន្យាឆ្លាតវៃ Waves មានពីរប្រភេទ៖ គណនីឆ្លាតវៃ និងទ្រព្យសកម្មឆ្លាតវៃ។ គណនីឆ្លាតវៃគឺជាគណនីអ្នកប្រើប្រាស់ធម្មតា ប៉ុន្តែស្គ្រីបត្រូវបានកំណត់សម្រាប់វាដែលគ្រប់គ្រងប្រតិបត្តិការទាំងអស់។ ស្គ្រីបគណនីឆ្លាតវៃអាចមើលទៅដូចនេះ ឧទាហរណ៍៖

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 គ្រាន់តែចុចប៊ូតុង NEW ។

លទ្ធភាពសម្រាប់ការប្រើប្រាស់កិច្ចសន្យាឆ្លាតវៃគឺធំទូលាយ៖ ពីការហាមឃាត់ប្រតិបត្តិការទៅកាន់អាសយដ្ឋានជាក់លាក់ (“បញ្ជីខ្មៅ”) រហូតដល់ dApps ស្មុគស្មាញ។

ឥឡូវនេះ សូមក្រឡេកមើលឧទាហរណ៍ជាក់លាក់នៃការប្រើប្រាស់កិច្ចសន្យាឆ្លាតវៃក្នុងអាជីវកម្ម៖ នៅពេលធ្វើការដេញថ្លៃ ការធានារ៉ាប់រង និងការបង្កើតកម្មវិធីភក្ដីភាព។

ការដេញថ្លៃ

លក្ខខណ្ឌមួយសម្រាប់ការដេញថ្លៃជោគជ័យគឺតម្លាភាព៖ អ្នកចូលរួមត្រូវតែមានទំនុកចិត្តថាវាមិនអាចទៅរួចទេក្នុងការរៀបចំការដេញថ្លៃ។ នេះអាចសម្រេចបានដោយសារ blockchain ដែលទិន្នន័យដែលមិនអាចផ្លាស់ប្តូរបានអំពីការភ្នាល់ទាំងអស់ និងពេលវេលាដែលពួកគេត្រូវបានបង្កើតឡើងនឹងមានសម្រាប់អ្នកចូលរួមទាំងអស់។

នៅលើ Waves blockchain ការដេញថ្លៃអាចត្រូវបានកត់ត្រានៅក្នុងស្ថានភាពគណនីដេញថ្លៃតាមរយៈ DataTransaction ។

អ្នកក៏អាចកំណត់ពេលវេលាចាប់ផ្តើម និងបញ្ចប់នៃការដេញថ្លៃដោយប្រើលេខប្លុក៖ ភាពញឹកញាប់នៃការបង្កើតប្លុកនៅក្នុង Waves blockchain គឺប្រហែលស្មើនឹង 60 វិនាទី។

1. ការដេញថ្លៃតម្លៃកើនឡើងជាភាសាអង់គ្លេស

អ្នកចូលរួមក្នុងការដេញថ្លៃជាភាសាអង់គ្លេស ដេញថ្លៃក្នុងការប្រកួតប្រជែងគ្នា។ ការភ្នាល់ថ្មីនីមួយៗត្រូវតែលើសពីការភ្នាល់មុន។ ការដេញថ្លៃបញ្ចប់នៅពេលដែលគ្មានអ្នកដេញថ្លៃលើសពីការដេញថ្លៃចុងក្រោយ។ ក្នុងករណីនេះ អ្នកដេញថ្លៃខ្ពស់បំផុតត្រូវតែផ្តល់ចំនួនទឹកប្រាក់ដែលបានបញ្ជាក់។

វាក៏មានជម្រើសដេញថ្លៃផងដែរ ដែលអ្នកលក់កំណត់តម្លៃអប្បបរមាសម្រាប់ឡូតិ៍ ហើយតម្លៃចុងក្រោយត្រូវតែលើសពីវា។ បើមិនដូច្នេះទេ ដីឡូតិ៍នៅតែមិនលក់។

ក្នុងឧទាហរណ៍នេះ យើងកំពុងធ្វើការជាមួយគណនីដែលបង្កើតជាពិសេសសម្រាប់ការដេញថ្លៃ។ រយៈពេលនៃការដេញថ្លៃគឺ 3000 ប្លុក ហើយតម្លៃចាប់ផ្តើមនៃឡូតិ៍គឺ 0,001 WAVES ។ អ្នកចូលរួមអាចដាក់ការដេញថ្លៃដោយផ្ញើ DataTransaction ជាមួយនឹងគន្លឹះ "តម្លៃ" និងតម្លៃនៃការដេញថ្លៃរបស់ពួកគេ។

តម្លៃនៃការដេញថ្លៃថ្មីត្រូវតែខ្ពស់ជាងតម្លៃបច្ចុប្បន្នសម្រាប់គន្លឹះនេះ ហើយអ្នកចូលរួមត្រូវតែមានយ៉ាងហោចណាស់ [new_bid + commission] tokens នៅក្នុងគណនីរបស់គាត់។ អាសយដ្ឋានរបស់អ្នកដេញថ្លៃត្រូវតែកត់ត្រានៅក្នុងវាល "អ្នកផ្ញើ" នៅក្នុង DataTransaction ហើយកម្ពស់ប្លុកដេញថ្លៃបច្ចុប្បន្នត្រូវតែស្ថិតនៅក្នុងរយៈពេលដេញថ្លៃ។

ប្រសិនបើនៅចុងបញ្ចប់នៃការដេញថ្លៃ អ្នកចូលរួមបានកំណត់តម្លៃខ្ពស់បំផុត គាត់អាចផ្ញើប្រតិបត្តិការប្តូរប្រាក់ដើម្បីទូទាត់ប្រាក់ដែលត្រូវគ្នាក្នុងតម្លៃជាក់លាក់ និងគូរូបិយប័ណ្ណ។

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. ការដេញថ្លៃហូឡង់នៃការថយចុះតម្លៃ

នៅក្នុងការដេញថ្លៃរបស់ហូឡង់ ជាច្រើនត្រូវបានផ្តល់ជូនដំបូងក្នុងតម្លៃខ្ពស់ជាងអ្វីដែលអ្នកទិញសុខចិត្តបង់។ តម្លៃថយចុះជាលំដាប់ រហូតដល់អ្នកចូលរួមម្នាក់យល់ព្រមទិញដីឡូតិ៍ក្នុងតម្លៃបច្ចុប្បន្ន។

ក្នុង​ឧទាហរណ៍​នេះ យើង​ប្រើ​ថេរ​ដូច​ក្នុង​លេខ​មុន ព្រម​ទាំង​ជំហាន​តម្លៃ​នៅ​ពេល delta ថយ​ចុះ។ ស្គ្រីបគណនីពិនិត្យមើលថាតើអ្នកចូលរួមពិតជាជាអ្នកភ្នាល់ដំបូងឬអត់។ បើមិនដូច្នោះទេ 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

ចូរយើងពិចារណាអំពីស្ថានភាពមួយដែលអ្នកត្រូវធានាទ្រព្យសម្បត្តិរបស់អ្នកប្រើប្រាស់ប្រឆាំងនឹងការខាតបង់ផ្នែកហិរញ្ញវត្ថុ។ ជាឧទាហរណ៍ អ្នកប្រើប្រាស់ចង់បានការធានាថាប្រសិនបើសញ្ញាសម្ងាត់ធ្លាក់ចុះ គាត់នឹងអាចទទួលបានមកវិញនូវចំនួនទឹកប្រាក់ពេញលេញដែលបានបង់សម្រាប់ថូខឹនទាំងនេះ ហើយសុខចិត្តបង់ប្រាក់ធានារ៉ាប់រងក្នុងចំនួនទឹកប្រាក់សមរម្យ។

ដើម្បីអនុវត្តវា "និមិត្តសញ្ញាធានារ៉ាប់រង" ចាំបាច់ត្រូវចេញ។ បន្ទាប់មក ស្គ្រីបមួយត្រូវបានដំឡើងនៅលើគណនីរបស់អ្នកកាន់គោលនយោបាយ ដោយអនុញ្ញាតឱ្យតែប្រតិបត្តិការ Exchange ទាំងនោះដែលបំពេញលក្ខខណ្ឌជាក់លាក់ប៉ុណ្ណោះដែលត្រូវប្រតិបត្តិ។

ដើម្បីទប់ស្កាត់ការចំណាយទ្វេដង អ្នកត្រូវស្នើសុំឱ្យអ្នកប្រើប្រាស់ផ្ញើ DataTransaction ទៅកាន់គណនីរបស់អ្នកកាន់គោលនយោបាយជាមុនជាមួយ (key, value) = (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 smart ពួកគេនឹងផ្តល់ឱ្យអ្នកនូវ 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 និងភក្ដីភាព

Cashback គឺជាប្រភេទនៃកម្មវិធីភក្ដីភាពដែលអ្នកទិញទទួលបានមកវិញនូវផ្នែកនៃចំនួនទឹកប្រាក់ដែលបានចំណាយលើផលិតផល ឬសេវាកម្ម។

នៅពេលអនុវត្តករណីនេះដោយប្រើគណនីឆ្លាតវៃ យើងត្រូវពិនិត្យមើលភ័ស្តុតាងតាមវិធីដូចគ្នាដែលយើងបានធ្វើនៅក្នុងករណីធានារ៉ាប់រង។ ដើម្បីទប់ស្កាត់ការចំណាយទ្វេដង អ្នកប្រើប្រាស់ត្រូវតែផ្ញើ DataTransaction with (key, value) = (purchaseTransactionId, cashbackTransactionId) មុនពេលទទួលបាន cashback។

យើងក៏ត្រូវតែកំណត់ការហាមឃាត់លើសោដែលមានស្រាប់ដោយប្រើ DataTransaction ។ cashbackDivisor - ឯកតាបែងចែកដោយចំណែក cashback ។ ទាំងនោះ។ ប្រសិនបើចំណែក 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