Примена на паметни сметки на Waves: од аукции до бонус програми

Блокчејн често се поврзува само со криптовалути, но областите на примена на DLT технологијата се многу пошироки. Една од најперспективните области за користење на блокчејн е паметниот договор кој се извршува автоматски и не бара доверба меѓу страните што го склучиле.

RIDE – јазик за паметни договори

Waves разви специјален јазик за паметни договори - RIDE. Се наоѓа неговата комплетна документација тука. И тука - статија на оваа тема на Хабр.

Договорот RIDE е предикат и враќа „точно“ или „неточно“ како излез. Соодветно на тоа, трансакцијата е или евидентирана во блокчејн или отфрлена. Паметниот договор целосно го гарантира исполнувањето на наведените услови. Во моментов не е можно генерирање трансакции од договор во RIDE.

Денес постојат два вида паметни договори на Waves: паметни сметки и паметни средства. Паметната сметка е редовна корисничка сметка, но за неа е поставена скрипта што ги контролира сите трансакции. Скрипта за паметна сметка може да изгледа вака, на пример:

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

tx е трансакција што се обработува и која дозволуваме користење на механизмот за совпаѓање на шаблони само ако не е трансакција за пренос. Усогласувањето на шаблоните во RIDE се користи за проверка на видот на трансакцијата. Сите постоечки сметки може да се обработат во скриптата за паметна сметка видови трансакции.

Скриптата исто така може да декларира променливи, да користи конструкции „ако-тогаш-инаку“ и други методи за целосна проверка на условите. За да се осигура дека договорите имаат докажлива комплетност и сложеност (трошок) што е лесно да се предвидат пред да започне извршувањето на договорот, RIDE не содржи циклуси или изјави за скокови.

Други карактеристики на сметките на Waves вклучуваат присуство на „состојба“, односно состојба на сметката. Можете да напишете бесконечен број на парови (клуч, вредност) во состојбата на сметката користејќи трансакции со податоци (DataTransaction). Овие информации потоа може да се обработат и преку REST API и директно во паметниот договор.

Секоја трансакција може да содржи низа докази, во кои може да се внесе потписот на учесникот, ID на потребната трансакција итн.

Работа со RIDE преку ИРО ви овозможува да го видите компајлираниот приказ на договорот (ако е компајлиран), да креирате нови сметки и да поставите скрипти за него, како и да испраќате трансакции преку командната линија.

За целосен циклус, вклучувајќи креирање сметка, инсталирање паметен договор на неа и испраќање трансакции, можете исто така да користите библиотека за интеракција со REST API (на пример, C#, C, Java, JavaScript, Python, Rust, Elixir) . За да започнете да работите со IDE, само кликнете на копчето NEW.

Можностите за користење паметни договори се широки: од забрана на трансакции до одредени адреси („црна листа“) до сложени dApps.

Сега да погледнеме конкретни примери за употреба на паметни договори во бизнисот: при спроведување на аукции, осигурување и креирање програми за лојалност.

Аукции

Еден од условите за успешна аукција е транспарентноста: учесниците мора да бидат сигурни дека е невозможно да се манипулира со понудите. Ова може да се постигне благодарение на блокчејнот, каде што непроменливите податоци за сите облози и времето кога биле направени ќе бидат достапни за сите учесници.

На блокчејнот Waves, понудите може да се евидентираат во состојбата на сметката на аукцијата преку DataTransaction.

Можете исто така да го поставите времето на почеток и крај на аукцијата користејќи ги броевите на блоковите: фреквенцијата на генерирање блокови во блокчејнот Waves е приближно еднаква на 60 секунди.

1. Аукција на англиска растечка цена

Учесниците на англиската аукција пласираат понуди во конкуренција едни со други. Секој нов облог мора да го надмине претходниот. Аукцијата завршува кога нема повеќе понудувачи да ја надминат последната понуда. Во овој случај, највисокиот понудувач мора да го обезбеди наведениот износ.

Исто така, постои опција за аукција во која продавачот поставува минимална цена за лотот, а крајната цена мора да ја надмине. Во спротивно, лозата останува непродадена.

Во овој пример, работиме со сметка специјално создадена за аукцијата. Времетраењето на аукцијата е 3000 блока, а почетната цена на лот е 0,001 WAVES. Учесникот може да поднесе понуда со испраќање DataTransaction со клучната „цена“ и вредноста на нивната понуда.

Цената на новата понуда мора да биде повисока од моменталната цена за овој клуч, а учесникот мора да има најмалку токени [new_bid + провизија] на неговата сметка. Адресата на понудувачот мора да биде запишана во полето „испраќач“ во 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“

„All-pay“ е аукција во која сите учесници ја плаќаат понудата, без оглед на тоа кој ќе добие лото. Секој нов учесник плаќа понуда, а учесникот кој ќе направи максимална понуда добива ждрепка.

Во нашиот пример, секој учесник на аукцијата поставува понуда преку 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) и да забрани испраќање DataTransaction со веќе користен клуч.

Затоа, доказите на корисникот мора да го содржат ID на трансакцијата на купувањето на токен за осигурување. Валутниот пар мора да биде ист како во трансакцијата за купување. Трошокот исто така мора да биде еднаков на оној фиксен при купувањето, минус цената на осигурувањето.

Разбирливо е дека последователно осигурителната сметка купува токени за осигурување од корисникот по цена не пониска од онаа по која ги купил: осигурителната сметка создава 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 е вид на програма за лојалност во која купувачот добива назад дел од сумата потрошена за производ или услуга.

Кога го спроведуваме овој случај користејќи паметна сметка, мора да ги провериме доказите на ист начин како што направивме во случајот за осигурување. За да се спречи двојно трошење, корисникот мора да испрати DataTransaction со (клуч, вредност) = (purchaseTransactionId, cashbackTransactionId) пред да добие поврат на готовина.

Исто така, мора да поставиме забрана за постоечките клучеви користејќи DataTransaction. cashbackDivisor - единица поделена со уделот за враќање на готовина. Оние. ако уделот за враќање на готовина е 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