יישום של חשבונות חכמים של Waves: ממכירות פומביות ועד תוכניות בונוס

בלוקצ'יין מקושר לרוב רק למטבעות קריפטוגרפיים, אך תחומי היישום של טכנולוגיית DLT רחבים בהרבה. אחד התחומים המבטיחים ביותר לשימוש בבלוקצ'יין הוא חוזה חכם שמתבצע באופן אוטומטי ואינו מצריך אמון בין הצדדים שהתקשרו בו.

RIDE – שפה לחוזים חכמים

Waves פיתחה שפה מיוחדת לחוזים חכמים - RIDE. התיעוד המלא שלה נמצא כאן. והנה - מאמר בנושא זה על הבר.

חוזה RIDE הוא פרדיקט ומחזיר "נכון" או "שקר" כפלט. בהתאם לכך, העסקה נרשמת בבלוקצ'יין או נדחית. החוזה החכם מבטיח באופן מלא את מילוי התנאים שצוינו. יצירת עסקאות מחוזה ב-RIDE אינה אפשרית כרגע.

כיום ישנם שני סוגים של חוזים חכמים של Waves: חשבונות חכמים ונכסים חכמים. חשבון חכם הוא חשבון משתמש רגיל, אך מוגדר עבורו סקריפט השולט בכל העסקאות. סקריפט חשבון חכם עשוי להיראות כך, לדוגמה:

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

tx היא עסקה בעיבוד שאנו מאפשרים להשתמש במנגנון התאמת התבניות רק אם זו לא עסקת העברה. התאמת דפוסים ב-RIDE משמשת לבדיקת סוג העסקה. ניתן לעבד את כל החשבונות הקיימים בסקריפט החשבון החכם סוגי עסקאות.

הסקריפט יכול גם להכריז על משתנים, להשתמש במבני "אם-אז-אחר" ובשיטות אחרות לבדיקה מלאה של התנאים. כדי להבטיח שלחוזים יהיו שלמות ומורכבות (עלות) שניתן להוכיח שקל לחזות אותם לפני תחילת ביצוע החוזה, RIDE אינו מכיל לולאות או הצהרות קפיצה.

תכונות אחרות של חשבונות Waves כוללות נוכחות של "מדינה", כלומר, מצב החשבון. ניתן לכתוב מספר אינסופי של זוגות (מפתח, ערך) למצב החשבון באמצעות תנועות נתונים (DataTransaction). לאחר מכן ניתן לעבד מידע זה הן דרך ה- REST API והן ישירות בחוזה החכם.

כל עסקה יכולה להכיל מערך הוכחות, שלתוכם ניתן להזין את חתימת המשתתף, מזהה העסקה הנדרשת וכו'.

עבודה עם RIDE via IDE מאפשר לך לראות את התצוגה הקומפילטית של החוזה (אם היא מורכבת), ליצור חשבונות חדשים ולהגדיר עבורו סקריפטים, כמו גם לשלוח עסקאות באמצעות שורת הפקודה.

למחזור מלא, כולל יצירת חשבון, התקנת חוזה חכם עליו ושליחת עסקאות, ניתן גם להשתמש בספריה לאינטראקציה עם ה- REST API (לדוגמה, C#, C, Java, JavaScript, Python, Rust, Elixir) . כדי להתחיל לעבוד עם ה-IDE, פשוט לחץ על הלחצן NEW.

האפשרויות לשימוש בחוזים חכמים הן רחבות: מאיסור עסקאות לכתובות מסוימות ("רשימה שחורה") ועד ל-dApps מורכבות.

כעת נסתכל על דוגמאות ספציפיות לשימוש בחוזים חכמים בעסקים: בעת עריכת מכירות פומביות, ביטוח ויצירת תוכניות נאמנות.

מכירות פומביות

אחד התנאים למכירה פומבית מוצלחת הוא שקיפות: על המשתתפים להיות בטוחים שאי אפשר לעשות מניפולציות בהצעות. ניתן להשיג זאת הודות לבלוקצ'יין, שבו נתונים בלתי ניתנים לשינוי על כל ההימורים והזמן שבו הם בוצעו יהיו זמינים לכל המשתתפים.

ב-Waves blockchain, ניתן לרשום הצעות במצב חשבון המכירה הפומבית באמצעות DataTransaction.

ניתן גם להגדיר את שעת ההתחלה והסיום של המכירה הפומבית באמצעות מספרי בלוק: תדירות יצירת הבלוקים בבלוקצ'יין Waves שווה בערך ל 60 שניות.

1. מכירה פומבית של מחיר עולה באנגלית

המשתתפים במכירה פומבית באנגלית מגישים הצעות בתחרות זה עם זה. כל הימור חדש חייב לעלות על הקודם. המכרז מסתיים כאשר אין עוד מציעים שיחרגו מההצעה האחרונה. במקרה זה, על המציע הגבוה ביותר לספק את הסכום הנקוב.

קיימת גם אפשרות מכירה פומבית בה המוכר קובע מחיר מינימום למגרש, והמחיר הסופי חייב לעלות עליו. אחרת, המגרש לא נמכר.

בדוגמה זו, אנו עובדים עם חשבון שנוצר במיוחד עבור המכירה הפומבית. משך המכירה הפומבית הוא 3000 בלוקים, והמחיר ההתחלתי של המגרש הוא 0,001 WAVES. משתתף יכול להגיש הצעה על ידי שליחת DataTransaction עם המפתח "מחיר" וערך ההצעה שלו.

המחיר של ההצעה החדשה חייב להיות גבוה מהמחיר הנוכחי עבור מפתח זה, ועל המשתתף להחזיק בחשבונו לפחות אסימוני [new_bid + commission]. יש לרשום את כתובתו של המציע בשדה "שולח" ב-DataTransaction, וגובה בלוק ההצעות הנוכחי חייב להיות בתוך תקופת המכרז.

אם בסוף המכרז המשתתף קבע את המחיר הגבוה ביותר, הוא יכול לשלוח 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 לא מתקבל על ידי הבלוקצ'יין.

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. מכירה פומבית "תשלום מלא"

"All-pay" היא מכירה פומבית שבה כל המשתתפים משלמים את ההצעה, ללא קשר למי זוכה במגרש. כל משתתף חדש משלם הצעה, והמשתתף שמציע את ההצעה המקסימלית זוכה במגרש.

בדוגמה שלנו, כל משתתף במכירה הפומבית מגיש הצעה באמצעות DataTransaction עם (מפתח, ערך)* = ("זוכה", כתובת), ("מחיר", מחיר). עסקת נתונים כזו מאושרת רק אם למשתתף זה כבר יש טרנסאקציית העברה עם חתימתו והצעתו גבוהה יותר מכל הקודמות. המכירה הפומבית נמשכת עד להשגת 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)
}

ביטוח / מימון המונים

בוא נבחן מצב שבו אתה צריך לבטח את נכסי המשתמשים מפני הפסדים כספיים. לדוגמה, משתמש רוצה להבטיח שאם אסימון יפחת, הוא יוכל לקבל בחזרה את מלוא הסכום ששולם עבור האסימונים הללו, ומוכן לשלם סכום ביטוח סביר.

כדי ליישם זאת, יש להנפיק "אסימוני ביטוח". לאחר מכן מותקן סקריפט על חשבון בעל הפוליסה, המאפשר לבצע רק את עסקאות החליפין שעומדות בתנאים מסוימים.

כדי למנוע הוצאה כפולה, עליך לבקש מהמשתמש לשלוח מראש DataTransaction לחשבון המבוטח עם (key, value) = (purchaseTransactionId, sellOrderId) ולאסור שליחת DataTransactions עם מפתח שכבר נעשה בו שימוש.

לכן, ההוכחות של המשתמש חייבות להכיל את מזהה העסקה של רכישת אסימון הביטוח. צמד המטבעות חייב להיות זהה לזו שבעסקת הרכישה. כמו כן העלות צריכה להיות שווה לזו הקבועה בעת הרכישה, בניכוי מחיר הביטוח.

מובן כי לאחר מכן חשבון הביטוח קונה מהמשתמש אסימוני ביטוח במחיר שאינו נמוך מזה שבו רכש אותם: חשבון הביטוח יוצר ExchangeTransaction, המשתמש חותם על ההזמנה (אם העסקה הושלמה כהלכה), חשבון ביטוח חותם על ההזמנה השנייה ועל כל העסקה ושולח אותה לבלוקצ'יין.

אם לא מתרחשת רכישה, המשתמש יכול ליצור ExchangeTransaction לפי הכללים המתוארים בסקריפט ולשלוח את העסקה לבלוקצ'יין. כך המשתמש יכול להחזיר את הכסף שהוצא ברכישת אסימונים מבוטחים.

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 ותוכניות נאמנות

Cashback הוא סוג של תוכנית נאמנות שבה הקונה מקבל בחזרה חלק מהסכום שהוצא על מוצר או שירות.

בעת יישום מקרה זה באמצעות חשבון חכם, עלינו לבדוק את ההוכחות באותו אופן כפי שעשינו בתיק הביטוח. כדי למנוע הוצאה כפולה, על המשתמש לשלוח DataTransaction עם (מפתח, ערך) = (purchaseTransactionId, cashbackTransactionId) לפני קבלת החזר כספי.

עלינו גם להגדיר איסור על מפתחות קיימים באמצעות 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