ویوز سمارٹ اکاؤنٹس کی درخواستیں: نیلامی سے لے کر بونس پروگرام تک

بلاکچین اکثر صرف کرپٹو کرنسیوں سے منسلک ہوتا ہے، لیکن ڈی ایل ٹی ٹیکنالوجی کے اطلاق کے شعبے بہت وسیع ہیں۔ بلاکچین کے استعمال کے لیے سب سے امید افزا شعبوں میں سے ایک ایک سمارٹ معاہدہ ہے جو خود بخود عمل میں آتا ہے اور اس میں داخل ہونے والے فریقین کے درمیان اعتماد کی ضرورت نہیں ہوتی ہے۔

RIDE – سمارٹ معاہدوں کے لیے ایک زبان

لہروں نے سمارٹ معاہدوں کے لیے ایک خاص زبان تیار کی ہے - RIDE۔ اس کی مکمل دستاویزات موجود ہیں۔ یہاں. اور یہاں - اس موضوع پر مضمون Habré پر.

RIDE معاہدہ ایک پیش گوئی ہے اور آؤٹ پٹ کے طور پر "سچ" یا "غلط" لوٹاتا ہے۔ اس کے مطابق، لین دین یا تو بلاکچین میں ریکارڈ کیا جاتا ہے یا مسترد کر دیا جاتا ہے۔ سمارٹ کنٹریکٹ مخصوص شرائط کی تکمیل کی مکمل ضمانت دیتا ہے۔ RIDE میں معاہدے سے لین دین پیدا کرنا فی الحال ممکن نہیں ہے۔

آج دو قسم کے ویوز سمارٹ کنٹریکٹس ہیں: سمارٹ اکاؤنٹس اور سمارٹ اثاثے۔ سمارٹ اکاؤنٹ ایک باقاعدہ صارف اکاؤنٹ ہوتا ہے، لیکن اس کے لیے ایک اسکرپٹ سیٹ کیا جاتا ہے جو تمام لین دین کو کنٹرول کرتا ہے۔ ایک سمارٹ اکاؤنٹ اسکرپٹ اس طرح نظر آ سکتا ہے، مثال کے طور پر:

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

tx ایک ٹرانزیکشن ہے جس پر عملدرآمد کیا جا رہا ہے جس کی ہم پیٹرن میچنگ میکانزم کو صرف اس صورت میں استعمال کرنے کی اجازت دیتے ہیں جب یہ ٹرانسفر ٹرانزیکشن نہ ہو۔ RIDE میں پیٹرن میچنگ کا استعمال ٹرانزیکشن کی قسم کو چیک کرنے کے لیے کیا جاتا ہے۔ تمام موجودہ اکاؤنٹس کو سمارٹ اکاؤنٹ اسکرپٹ میں پروسیس کیا جا سکتا ہے۔ لین دین کی اقسام.

اسکرپٹ متغیرات کا بھی اعلان کر سکتا ہے، حالات کو مکمل طور پر جانچنے کے لیے "اگر-تو-اور" تعمیرات اور دیگر طریقے استعمال کر سکتا ہے۔ اس بات کو یقینی بنانے کے لیے کہ معاہدوں میں مکمل اور پیچیدگی (لاگت) ہے جس کا اندازہ لگانا آسان ہے کنٹریکٹ پر عمل درآمد شروع ہونے سے پہلے، RIDE میں لوپس یا جمپ اسٹیٹمنٹ نہیں ہوتے ہیں۔

ویوز اکاؤنٹس کی دیگر خصوصیات میں "ریاست" کی موجودگی شامل ہے، یعنی اکاؤنٹ کی حالت۔ آپ ڈیٹا ٹرانزیکشنز (ڈیٹا ٹرانزیکشن) کا استعمال کرتے ہوئے اکاؤنٹ کی حالت میں جوڑوں کی لامحدود تعداد (کلید، قدر) لکھ سکتے ہیں۔ اس کے بعد اس معلومات پر REST API کے ذریعے اور براہ راست سمارٹ کنٹریکٹ میں کارروائی کی جا سکتی ہے۔

ہر لین دین میں ثبوتوں کی ایک صف شامل ہو سکتی ہے، جس میں شرکت کنندہ کے دستخط، مطلوبہ لین دین کی ID وغیرہ درج کیے جا سکتے ہیں۔

RIDE کے ذریعے کام کرنا IDE آپ کو معاہدے کا مرتب شدہ منظر دیکھنے کی اجازت دیتا ہے (اگر یہ مرتب کیا گیا ہے)، نئے اکاؤنٹس بنانے اور اس کے لیے اسکرپٹس ترتیب دینے کے ساتھ ساتھ کمانڈ لائن کے ذریعے لین دین بھیجنے کی اجازت دیتا ہے۔

ایک مکمل سائیکل کے لیے، بشمول ایک اکاؤنٹ بنانا، اس پر ایک سمارٹ کنٹریکٹ انسٹال کرنا اور لین دین بھیجنا، آپ 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. نیلامی "تمام تنخواہ"

"آل پے" ایک نیلامی ہے جس میں تمام شرکاء بولی ادا کرتے ہیں، قطع نظر اس کے کہ کون لاٹ جیتتا ہے۔ ہر نیا شریک ایک بولی ادا کرتا ہے، اور زیادہ سے زیادہ بولی لگانے والا حصہ جیتتا ہے۔

ہماری مثال میں، ہر نیلامی کا حصہ دار ڈیٹا ٹرانزیکشن کے ذریعے بولی لگاتا ہے (کلید، قدر)* = ("فاتح"، پتہ)، ("قیمت"، قیمت)۔ اس طرح کے ڈیٹا ٹرانزیکشن کی منظوری صرف اس صورت میں دی جاتی ہے جب اس شریک کے پاس پہلے سے ہی اس کے دستخط کے ساتھ ایک ٹرانسفر ٹرانزیکشن موجود ہو اور اس کی بولی گزشتہ تمام لوگوں سے زیادہ ہو۔ نیلامی اس وقت تک جاری رہتی ہے جب تک کہ آخری اونچائی تک نہیں پہنچ جاتی۔

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

انشورنس / کراؤڈ فنڈنگ

آئیے ایک ایسی صورتحال پر غور کریں جہاں آپ کو مالی نقصانات کے خلاف صارفین کے اثاثوں کا بیمہ کروانے کی ضرورت ہے۔ مثال کے طور پر، ایک صارف اس بات کی گارنٹی چاہتا ہے کہ اگر ایک ٹوکن کی قدر گھٹ جاتی ہے، تو وہ ان ٹوکنز کے لیے ادا کی گئی پوری رقم واپس حاصل کر سکے گا، اور وہ انشورنس کی معقول رقم ادا کرنے کے لیے تیار ہے۔

اس کو نافذ کرنے کے لیے، "انشورنس ٹوکنز" جاری کرنے کی ضرورت ہے۔ اس کے بعد پالیسی ہولڈر کے اکاؤنٹ پر ایک اسکرپٹ انسٹال ہوتا ہے، جس سے صرف ان ہی ایکسچینج ٹرانزیکشنز کو انجام دینے کی اجازت ملتی ہے جو کچھ شرائط کو پورا کرتے ہیں۔

دوہرے اخراجات کو روکنے کے لیے، آپ کو صارف سے درخواست کرنی ہوگی کہ وہ پالیسی ہولڈر کے اکاؤنٹ میں (کلی، قدر) = (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 / 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
}

کیش بیک اور لائلٹی پروگرام

کیش بیک ایک قسم کا لائلٹی پروگرام ہے جس میں خریدار کو کسی پروڈکٹ یا سروس پر خرچ کی گئی رقم کا کچھ حصہ واپس مل جاتا ہے۔

سمارٹ اکاؤنٹ کا استعمال کرتے ہوئے اس کیس کو لاگو کرتے وقت، ہمیں ثبوتوں کو اسی طرح چیک کرنا چاہیے جیسا کہ ہم نے انشورنس کیس میں کیا تھا۔ دوہرے اخراجات کو روکنے کے لیے، صارف کو کیش بیک حاصل کرنے سے پہلے ڈیٹا ٹرانزیکشن (کی، ویلیو) = (purchaseTransactionId، cashbackTransactionId) کے ساتھ بھیجنا چاہیے۔

ہمیں ڈیٹا ٹرانزیکشن کا استعمال کرتے ہوئے موجودہ کیز پر بھی پابندی لگانی چاہیے۔ 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