ຄໍາຮ້ອງສະຫມັກຂອງບັນຊີ smart Waves: ຈາກການປະມູນກັບໂຄງການໂບນັດ

Blockchain ມັກຈະກ່ຽວຂ້ອງກັບ cryptocurrencies, ແຕ່ພື້ນທີ່ຂອງການນໍາໃຊ້ເຕັກໂນໂລຢີ DLT ແມ່ນກວ້າງກວ່າ. ຫນຶ່ງໃນພື້ນທີ່ທີ່ໂດດເດັ່ນທີ່ສຸດສໍາລັບການນໍາໃຊ້ blockchain ແມ່ນສັນຍາສະຫມາດທີ່ຖືກປະຕິບັດໂດຍອັດຕະໂນມັດແລະບໍ່ຮຽກຮ້ອງໃຫ້ມີຄວາມໄວ້ວາງໃຈລະຫວ່າງຝ່າຍທີ່ເຂົ້າໄປໃນມັນ.

RIDE - ພາສາສໍາລັບສັນຍາສະຫມາດ

Waves ໄດ້ພັດທະນາພາສາພິເສດສໍາລັບສັນຍາສະຫມາດ – RIDE. ເອກະສານຄົບຖ້ວນຂອງມັນຕັ້ງຢູ່ ທີ່ນີ້. ແລະ​ທີ່​ນີ້ - ບົດ​ຄວາມ​ກ່ຽວ​ກັບ​ຫົວ​ຂໍ້​ນີ້​ ສຸດ Habr.

ສັນຍາ RIDE ແມ່ນຕົວຊີ້ບອກແລະສົ່ງຄືນ "ຄວາມຈິງ" ຫຼື "ຜິດ" ເປັນຜົນຜະລິດ. ດັ່ງນັ້ນ, ການເຮັດທຸລະກໍາຈະຖືກບັນທຶກໄວ້ໃນ blockchain ຫຼືຖືກປະຕິເສດ. ສັນຍາສະຫມາດຮັບປະກັນຢ່າງເຕັມສ່ວນການປະຕິບັດຕາມເງື່ອນໄຂທີ່ລະບຸໄວ້. ການຜະລິດທຸລະກໍາຈາກສັນຍາໃນ RIDE ແມ່ນບໍ່ເປັນໄປໄດ້.

ມື້ນີ້ມີສອງປະເພດຂອງສັນຍາສະຫຼາດ Waves: ບັນຊີອັດສະລິຍະ ແລະຊັບສິນອັດສະລິຍະ. ບັນຊີອັດສະລິຍະແມ່ນບັນຊີຜູ້ໃຊ້ປົກກະຕິ, ແຕ່ສະຄຣິບຖືກຕັ້ງໃຫ້ມັນຄວບຄຸມການເຮັດທຸລະກໍາທັງໝົດ. ສະຄຣິບບັນຊີອັດສະລິຍະອາດມີລັກສະນະນີ້, ຕົວຢ່າງ:

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

tx ແມ່ນທຸລະກໍາທີ່ກໍາລັງດໍາເນີນການທີ່ພວກເຮົາອະນຸຍາດໃຫ້ນໍາໃຊ້ກົນໄກການຈັບຄູ່ຮູບແບບພຽງແຕ່ຖ້າວ່າມັນບໍ່ແມ່ນການໂອນຍ້າຍ. ການຈັບຄູ່ຮູບແບບໃນ RIDE ແມ່ນໃຊ້ເພື່ອກວດສອບປະເພດຂອງທຸລະກໍາ. ບັນ​ຊີ​ທີ່​ມີ​ຢູ່​ທັງ​ຫມົດ​ສາ​ມາດ​ໄດ້​ຮັບ​ການ​ປະ​ມວນ​ຜົນ​ໃນ​ສະ​ຄຣິ​ບ​ບັນ​ຊີ smart​ ປະເພດທຸລະກໍາ.

ສະຄຣິບຍັງສາມາດປະກາດຕົວແປໄດ້, ໃຊ້ໂຄງສ້າງ "ຖ້າແລ້ວ-ອື່ນ" ແລະວິທີການອື່ນໆເພື່ອກວດສອບເງື່ອນໄຂຢ່າງສົມບູນ. ເພື່ອຮັບປະກັນວ່າສັນຍາມີຄວາມສົມບູນທີ່ພິສູດໄດ້ ແລະຊັບຊ້ອນ (ຄ່າໃຊ້ຈ່າຍ) ທີ່ງ່າຍຕໍ່ການຄາດຄະເນກ່ອນການປະຕິບັດສັນຍາຈະເລີ່ມຕົ້ນ, RIDE ບໍ່ມີຄໍາຖະແຫຼງການ loops ຫຼື jumped.

ລັກສະນະອື່ນໆຂອງບັນຊີ Waves ປະກອບມີການປະກົດຕົວຂອງ "ລັດ", ນັ້ນແມ່ນ, ສະຖານະຂອງບັນຊີ. ທ່ານ​ສາ​ມາດ​ຂຽນ​ຈໍາ​ນວນ infinite ຂອງ​ຄູ່ (ກະ​ແຈ​, ມູນ​ຄ່າ​) ກັບ​ສະ​ຖາ​ນະ​ບັນ​ຊີ​ໂດຍ​ການ​ນໍາ​ໃຊ້​ການ​ໂອນ​ຂໍ້​ມູນ (DataTransaction​)​. ຂໍ້ມູນນີ້ສາມາດຖືກປຸງແຕ່ງທັງຜ່ານ REST API ແລະໂດຍກົງໃນສັນຍາສະຫມາດ.

ແຕ່ລະທຸລະກໍາສາມາດມີ array ຂອງຫຼັກຖານ, ເຂົ້າໄປໃນລາຍເຊັນຂອງຜູ້ເຂົ້າຮ່ວມ, ID ຂອງການເຮັດທຸລະກໍາທີ່ຕ້ອງການ, ແລະອື່ນໆ.

ເຮັດວຽກກັບ RIDE ຜ່ານ ທີ່ນີ້ ອະນຸຍາດໃຫ້ທ່ານເຫັນມຸມເບິ່ງທີ່ລວບລວມຂອງສັນຍາ (ຖ້າມັນຖືກລວບລວມ), ສ້າງບັນຊີໃຫມ່ແລະກໍານົດ scripts ສໍາລັບມັນ, ເຊັ່ນດຽວກັນກັບສົ່ງທຸລະກໍາຜ່ານເສັ້ນຄໍາສັ່ງ.

ສໍາລັບຮອບວຽນເຕັມ, ລວມທັງການສ້າງບັນຊີ, ການຕິດຕັ້ງສັນຍາສະຫມາດໃສ່ມັນແລະການສົ່ງທຸລະກໍາ, ທ່ານຍັງສາມາດໃຊ້ຫ້ອງສະຫມຸດສໍາລັບການພົວພັນກັບ REST API (ຕົວຢ່າງ: C#, C, Java, JavaScript, Python, Rust, Elixir) . ເພື່ອເລີ່ມຕົ້ນການເຮັດວຽກກັບ IDE, ພຽງແຕ່ກົດປຸ່ມ NEW.

ຄວາມເປັນໄປໄດ້ສໍາລັບການນໍາໃຊ້ສັນຍາສະຫມາດແມ່ນກວ້າງ: ຈາກການຫ້າມການເຮັດທຸລະກໍາກັບທີ່ຢູ່ທີ່ແນ່ນອນ ("ບັນຊີດໍາ") ໄປຫາ dApps ທີ່ສັບສົນ.

ຕອນນີ້ໃຫ້ເບິ່ງຕົວຢ່າງສະເພາະຂອງການນໍາໃຊ້ສັນຍາສະຫມາດໃນທຸລະກິດ: ເມື່ອດໍາເນີນການປະມູນ, ການປະກັນໄພ, ແລະການສ້າງໂຄງການຄວາມສັດຊື່.

ການປະມູນ

ຫນຶ່ງໃນເງື່ອນໄຂສໍາລັບການປະມູນທີ່ປະສົບຜົນສໍາເລັດແມ່ນຄວາມໂປ່ງໃສ: ຜູ້ເຂົ້າຮ່ວມຕ້ອງຫມັ້ນໃຈວ່າມັນເປັນໄປບໍ່ໄດ້ທີ່ຈະຈັດການປະມູນ. ນີ້ສາມາດບັນລຸໄດ້ຍ້ອນ blockchain, ບ່ອນທີ່ຂໍ້ມູນທີ່ບໍ່ປ່ຽນແປງກ່ຽວກັບການເດີມພັນທັງຫມົດແລະເວລາທີ່ພວກເຂົາໄດ້ເຮັດຈະມີໃຫ້ຜູ້ເຂົ້າຮ່ວມທັງຫມົດ.

ໃນ Waves blockchain, ການປະມູນສາມາດຖືກບັນທຶກໄວ້ໃນສະຖານະບັນຊີການປະມູນຜ່ານ DataTransaction.

ນອກນັ້ນທ່ານຍັງສາມາດກໍານົດເວລາເລີ່ມຕົ້ນແລະເວລາສິ້ນສຸດຂອງການປະມູນໂດຍໃຊ້ຕົວເລກຕັນ: ຄວາມຖີ່ຂອງການຜະລິດຕັນໃນ Waves blockchain ແມ່ນປະມານເທົ່າກັບ. 60 ວິນາທີ.

1. English ascending price auction

ຜູ້​ເຂົ້າ​ຮ່ວມ​ໃນ​ການ​ປະ​ມູນ​ຂອງ​ພາ​ສາ​ອັງ​ກິດ​ສະ​ຖານ​ທີ່​ປະ​ມູນ​ໃນ​ການ​ແຂ່ງ​ຂັນ​ກັນ​. ແຕ່ລະການເດີມພັນໃຫມ່ຕ້ອງເກີນອັນທີ່ແລ້ວ. ການປະມູນຈະສິ້ນສຸດລົງເມື່ອບໍ່ມີຜູ້ປະມູນຫຼາຍກວ່າການປະມູນຄັ້ງສຸດທ້າຍ. ໃນກໍລະນີນີ້, ຜູ້ປະມູນສູງສຸດຕ້ອງໃຫ້ຈໍານວນທີ່ລະບຸໄວ້.

ນອກນັ້ນຍັງມີທາງເລືອກການປະມູນທີ່ຜູ້ຂາຍກໍານົດລາຄາຕໍາ່ສຸດທີ່ສໍາລັບ lots, ແລະລາຄາສຸດທ້າຍຕ້ອງເກີນມັນ. ຖ້າ​ບໍ່​ດັ່ງ​ນັ້ນ​, lots ຍັງ​ບໍ່​ໄດ້​ຂາຍ​.

ໃນຕົວຢ່າງນີ້, ພວກເຮົາກໍາລັງເຮັດວຽກກັບບັນຊີທີ່ສ້າງຂຶ້ນໂດຍສະເພາະສໍາລັບການປະມູນ. ໄລຍະເວລາການປະມູນແມ່ນ 3000 ຕັນ, ແລະລາຄາເລີ່ມຕົ້ນຂອງ lots ແມ່ນ 0,001 WAVES. ຜູ້ເຂົ້າຮ່ວມສາມາດວາງການສະເຫນີລາຄາໂດຍການສົ່ງ DataTransaction ທີ່ມີລະຫັດ "ລາຄາ" ແລະມູນຄ່າຂອງການສະເຫນີລາຄາຂອງພວກເຂົາ.

ລາຄາຂອງການສະເຫນີລາຄາໃຫມ່ຕ້ອງສູງກວ່າລາຄາປະຈຸບັນສໍາລັບກະແຈນີ້, ແລະຜູ້ເຂົ້າຮ່ວມຕ້ອງມີຢ່າງຫນ້ອຍ [new_bid + commission] tokens ໃນບັນຊີຂອງລາວ. ທີ່ຢູ່ຂອງຜູ້ປະມູນຈະຕ້ອງຖືກບັນທຶກໄວ້ໃນຊ່ອງ "ຜູ້ສົ່ງ" ໃນ DataTransaction, ແລະຄວາມສູງຂອງການສະເຫນີລາຄາໃນປະຈຸບັນຕ້ອງຢູ່ໃນໄລຍະເວລາການປະມູນ.

ຖ້າໃນຕອນທ້າຍຂອງການປະມູນຜູ້ເຂົ້າຮ່ວມໄດ້ກໍານົດລາຄາທີ່ສູງທີ່ສຸດ, ລາວສາມາດສົ່ງ ExchangeTransaction ເພື່ອຈ່າຍຄ່າ lots ທີ່ສອດຄ້ອງກັນໃນລາຄາທີ່ກໍານົດແລະຄູ່ສະກຸນເງິນ.

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 ດ້ວຍ (key, value)* = ("ຜູ້ຊະນະ", ທີ່ຢູ່), ("ລາຄາ", ລາຄາ). DataTransaction ດັ່ງກ່າວໄດ້ຮັບການອະນຸມັດພຽງແຕ່ວ່າຜູ້ເຂົ້າຮ່ວມນີ້ມີ TransferTransaction ທີ່ມີລາຍເຊັນຂອງລາວຢູ່ກ່ອນແລ້ວແລະການສະເຫນີລາຄາຂອງລາວແມ່ນສູງກວ່າທຸກອັນທີ່ຜ່ານມາ. ການປະມູນຍັງສືບຕໍ່ຈົນກ່ວາ endHeight ແມ່ນບັນລຸໄດ້.

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

ໃຫ້ພິຈາລະນາສະຖານະການທີ່ທ່ານຈໍາເປັນຕ້ອງຮັບປະກັນຊັບສິນຂອງຜູ້ໃຊ້ຕໍ່ກັບການສູນເສຍທາງດ້ານການເງິນ. ຕົວຢ່າງ, ຜູ້ໃຊ້ຕ້ອງການການຄໍ້າປະກັນວ່າຖ້າ token depreciates, ລາວຈະສາມາດໄດ້ຮັບຄືນຈໍານວນເຕັມທີ່ຈ່າຍສໍາລັບ tokens ເຫຼົ່ານີ້, ແລະເຕັມໃຈທີ່ຈະຈ່າຍຄ່າປະກັນໄພທີ່ສົມເຫດສົມຜົນ.

ເພື່ອປະຕິບັດມັນ, "ເຄື່ອງຫມາຍການປະກັນໄພ" ຈໍາເປັນຕ້ອງໄດ້ອອກ. ຫຼັງຈາກນັ້ນ, script ຈະຖືກຕິດຕັ້ງຢູ່ໃນບັນຊີຂອງຜູ້ຖືນະໂຍບາຍ, ອະນຸຍາດໃຫ້ປະຕິບັດພຽງແຕ່ ExchangeTransactions ທີ່ຕອບສະຫນອງເງື່ອນໄຂບາງຢ່າງທີ່ຈະດໍາເນີນການ.

ເພື່ອປ້ອງກັນການໃຊ້ຈ່າຍສອງເທົ່າ, ທ່ານຈໍາເປັນຕ້ອງຮ້ອງຂໍໃຫ້ຜູ້ໃຊ້ສົ່ງ DataTransaction ກັບບັນຊີຂອງຜູ້ຖືນະໂຍບາຍລ່ວງຫນ້າດ້ວຍ (key, value) = (purchaseTransactionId, sellOrderId) ແລະຫ້າມສົ່ງ DataTransactions ດ້ວຍລະຫັດທີ່ໃຊ້ແລ້ວ.

ດັ່ງນັ້ນ, ຫຼັກຖານຂອງຜູ້ໃຊ້ຕ້ອງມີ ID ການເຮັດທຸລະກໍາຂອງການຊື້ເຄື່ອງປະກັນໄພ. ຄູ່ສະກຸນເງິນຈະຕ້ອງຄືກັນກັບໃນທຸລະກໍາການຊື້. ຄ່າ​ໃຊ້​ຈ່າຍ​ຍັງ​ຕ້ອງ​ເທົ່າ​ກັບ​ທີ່​ກໍາ​ນົດ​ໄວ້​ໃນ​ເວ​ລາ​ຂອງ​ການ​ຊື້​, ລົບ​ລາ​ຄາ​ຂອງ​ການ​ປະ​ກັນ​ໄພ​.

ມັນເຂົ້າໃຈວ່າຕໍ່ມາບັນຊີປະກັນໄພຊື້ tokens ປະກັນໄພຈາກຜູ້ໃຊ້ໃນລາຄາບໍ່ຕ່ໍາກວ່າຫນຶ່ງທີ່ເຂົາຊື້ໃຫ້ເຂົາເຈົ້າ: ບັນຊີປະກັນໄພສ້າງ ExchangeTransaction, ຜູ້ໃຊ້ເຊັນຄໍາສັ່ງ (ຖ້າຫາກວ່າການເຮັດທຸລະກໍາສໍາເລັດຢ່າງຖືກຕ້ອງ), ໄດ້. ບັນຊີປະກັນໄພເຊັນຄໍາສັ່ງທີສອງແລະທຸລະກໍາທັງຫມົດແລະສົ່ງມັນໄປ blockchain .

ຖ້າບໍ່ມີການຊື້ເກີດຂຶ້ນ, ຜູ້ໃຊ້ສາມາດສ້າງ ExchangeTransaction ຕາມກົດລະບຽບທີ່ອະທິບາຍໄວ້ໃນສະຄິບແລະສົ່ງທຸລະກໍາກັບ blockchain. ວິທີນີ້ຜູ້ໃຊ້ສາມາດສົ່ງຄືນເງິນທີ່ໃຊ້ໃນການຊື້ tokens ປະກັນໄພ.

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

ໂທເຄັນປະກັນໄພສາມາດສ້າງເປັນຊັບສິນທີ່ສະຫຼາດ, ຕົວຢ່າງ, ເພື່ອຫ້າມການໂອນເງິນຂອງຕົນໃຫ້ກັບບຸກຄົນທີສາມ.

ໂຄງການນີ້ຍັງສາມາດຖືກປະຕິບັດສໍາລັບການລະດົມທຶນ tokens, ເຊິ່ງຈະຖືກສົ່ງຄືນໃຫ້ເຈົ້າຂອງຖ້າຈໍານວນທີ່ຕ້ອງການຍັງບໍ່ທັນໄດ້ເກັບກໍາ.

ພາສີທຸລະກໍາ

ສັນຍາສະຫມາດແມ່ນຍັງໃຊ້ໄດ້ໃນກໍລະນີທີ່ມັນຈໍາເປັນຕ້ອງເກັບພາສີໃນແຕ່ລະທຸລະກໍາທີ່ມີຊັບສິນຫຼາຍປະເພດ. ນີ້ສາມາດເຮັດໄດ້ໂດຍຜ່ານຊັບສິນໃຫມ່ທີ່ມີການຕິດຕັ້ງ ການສະໜັບສະໜຸນ ສໍາລັບການເຮັດທຸລະກໍາກັບຊັບສິນອັດສະລິຍະ:

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 ແມ່ນປະເພດຂອງໂຄງການຄວາມສັດຊື່ທີ່ຜູ້ຊື້ໄດ້ຮັບຄືນສ່ວນຫນຶ່ງຂອງຈໍານວນເງິນທີ່ໃຊ້ໃນຜະລິດຕະພັນຫຼືການບໍລິການ.

ເມື່ອປະຕິບັດກໍລະນີນີ້ໂດຍໃຊ້ບັນຊີ smart, ພວກເຮົາຕ້ອງກວດເບິ່ງຫຼັກຖານສະແດງໃນລັກສະນະດຽວກັນກັບກໍລະນີປະກັນໄພ. ເພື່ອປ້ອງກັນການໃຊ້ຈ່າຍສອງເທົ່າ, ຜູ້ໃຊ້ຕ້ອງສົ່ງ DataTransaction ກັບ (key, value) = (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
}

ໃນບົດຄວາມຕໍ່ໄປພວກເຮົາຈະເບິ່ງການນໍາໃຊ້ບັນຊີ smart ໃນເຄື່ອງມືທາງດ້ານການເງິນເຊັ່ນ: ທາງເລືອກ, ອະນາຄົດແລະໃບບິນຄ່າ.

ແຫຼ່ງຂໍ້ມູນ: www.habr.com