વેવ્ઝ સ્માર્ટ એકાઉન્ટ્સની એપ્લિકેશન્સ: હરાજીથી બોનસ પ્રોગ્રામ્સ સુધી

બ્લોકચેન ઘણીવાર ફક્ત ક્રિપ્ટોકરન્સી સાથે સંકળાયેલું હોય છે, પરંતુ ડીએલટી ટેક્નોલોજીના ઉપયોગના ક્ષેત્રો વધુ વ્યાપક છે. બ્લોકચેનના ઉપયોગ માટેના સૌથી આશાસ્પદ ક્ષેત્રોમાંનું એક સ્માર્ટ કોન્ટ્રાક્ટ છે જે આપમેળે અમલમાં આવે છે અને તેમાં પ્રવેશેલા પક્ષકારો વચ્ચે વિશ્વાસની જરૂર નથી.

રાઇડ – સ્માર્ટ કોન્ટ્રાક્ટ માટેની ભાષા

વેવ્ઝે સ્માર્ટ કોન્ટ્રાક્ટ માટે એક ખાસ ભાષા વિકસાવી છે - RIDE. તેના સંપૂર્ણ દસ્તાવેજો સ્થિત છે અહીં. અને અહીં - આ વિષય પર લેખ Habr પર.

RIDE કોન્ટ્રાક્ટ એ પ્રિડિકેટ છે અને આઉટપુટ તરીકે "સાચું" અથવા "ખોટું" આપે છે. તદનુસાર, વ્યવહાર કાં તો બ્લોકચેનમાં રેકોર્ડ કરવામાં આવે છે અથવા નકારવામાં આવે છે. સ્માર્ટ કોન્ટ્રાક્ટ ચોક્કસ શરતોની પરિપૂર્ણતાની સંપૂર્ણ બાંયધરી આપે છે. RIDE માં કરારમાંથી વ્યવહારો જનરેટ કરવાનું હાલમાં શક્ય નથી.

આજે બે પ્રકારના વેવ્ઝ સ્માર્ટ કોન્ટ્રાક્ટ છે: સ્માર્ટ એકાઉન્ટ્સ અને સ્માર્ટ એસેટ. સ્માર્ટ એકાઉન્ટ એ નિયમિત વપરાશકર્તા ખાતું છે, પરંતુ તેના માટે એક સ્ક્રિપ્ટ સેટ કરેલી છે જે તમામ વ્યવહારોને નિયંત્રિત કરે છે. સ્માર્ટ એકાઉન્ટ સ્ક્રિપ્ટ આના જેવી દેખાઈ શકે છે, ઉદાહરણ તરીકે:

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

tx એ પ્રક્રિયા કરવામાં આવી રહેલ ટ્રાન્ઝેક્શન છે જેને અમે પેટર્ન મેચિંગ મિકેનિઝમનો ઉપયોગ કરવાની મંજૂરી આપીએ છીએ જો તે ટ્રાન્સફર ટ્રાન્ઝેક્શન ન હોય. RIDE માં પેટર્ન મેચિંગનો ઉપયોગ વ્યવહારના પ્રકારને તપાસવા માટે થાય છે. સ્માર્ટ એકાઉન્ટ સ્ક્રિપ્ટમાં હાલના તમામ એકાઉન્ટ પર પ્રક્રિયા કરી શકાય છે વ્યવહારના પ્રકારો.

સ્ક્રિપ્ટ ચલોને પણ જાહેર કરી શકે છે, "જો-તો-બીજું" રચનાઓનો ઉપયોગ કરી શકે છે અને શરતોને સંપૂર્ણ રીતે તપાસવા માટે અન્ય પદ્ધતિઓનો ઉપયોગ કરી શકે છે. કોન્ટ્રેક્ટની અમલવારી શરૂ થાય તે પહેલાં અનુમાન લગાવવું સરળ છે કે કોન્ટ્રેક્ટમાં સાબિત થઈ શકે તેવી સંપૂર્ણતા અને જટિલતા (ખર્ચ) છે તેની ખાતરી કરવા માટે, RIDEમાં લૂપ્સ અથવા જમ્પ સ્ટેટમેન્ટ નથી.

વેવ્ઝ એકાઉન્ટ્સની અન્ય વિશેષતાઓમાં "સ્ટેટ" એટલે કે ખાતાની સ્થિતિનો સમાવેશ થાય છે. તમે ડેટા ટ્રાન્ઝેક્શન્સ (ડેટા ટ્રાન્ઝેક્શન) નો ઉપયોગ કરીને એકાઉન્ટ સ્ટેટમાં અનંત સંખ્યામાં જોડી (કી, મૂલ્ય) લખી શકો છો. આ માહિતી પછી REST API દ્વારા અને સીધા સ્માર્ટ કોન્ટ્રાક્ટમાં બંને પર પ્રક્રિયા કરી શકાય છે.

દરેક વ્યવહારમાં પુરાવાઓની શ્રેણી હોઈ શકે છે, જેમાં સહભાગીની સહી, જરૂરી વ્યવહારનું ID વગેરે દાખલ કરી શકાય છે.

દ્વારા RIDE સાથે કામ કરવું અહીં તમને કરારનું સંકલિત દૃશ્ય જોવાની મંજૂરી આપે છે (જો તે સંકલિત કરવામાં આવ્યું હોય), નવા એકાઉન્ટ્સ બનાવો અને તેના માટે સ્ક્રિપ્ટો સેટ કરો, તેમજ આદેશ વાક્ય દ્વારા વ્યવહારો મોકલો.

એકાઉન્ટ બનાવવા, તેના પર સ્માર્ટ કોન્ટ્રાક્ટ ઇન્સ્ટોલ કરવા અને વ્યવહારો મોકલવા સહિત સંપૂર્ણ ચક્ર માટે, તમે REST API (ઉદાહરણ તરીકે, C#, C, Java, JavaScript, Python, Rust, Elixir) સાથે ક્રિયાપ્રતિક્રિયા કરવા માટે લાઇબ્રેરીનો પણ ઉપયોગ કરી શકો છો. . IDE સાથે કામ શરૂ કરવા માટે, ફક્ત નવું બટન ક્લિક કરો.

સ્માર્ટ કોન્ટ્રાક્ટનો ઉપયોગ કરવાની શક્યતાઓ વિશાળ છે: અમુક સરનામાંઓ ("બ્લેક લિસ્ટ") થી જટિલ dApps સુધીના વ્યવહારો પર પ્રતિબંધ મૂકવો.

હવે ચાલો વ્યવસાયમાં સ્માર્ટ કોન્ટ્રાક્ટના ઉપયોગના ચોક્કસ ઉદાહરણો જોઈએ: જ્યારે હરાજી, વીમો અને લોયલ્ટી પ્રોગ્રામ બનાવતી વખતે.

હરાજી

સફળ હરાજી માટેની શરતોમાંની એક પારદર્શિતા છે: સહભાગીઓને વિશ્વાસ હોવો જોઈએ કે બિડમાં ચાલાકી કરવી અશક્ય છે. બ્લોકચેનને આભારી આ હાંસલ કરી શકાય છે, જ્યાં તમામ બેટ્સ અને તે કયા સમયે બનાવવામાં આવ્યા હતા તે અંગેનો અવિચલિત ડેટા બધા સહભાગીઓને ઉપલબ્ધ હશે.

વેવ્ઝ બ્લોકચેન પર, ડેટા ટ્રાન્ઝેક્શન દ્વારા બિડને ઓક્શન એકાઉન્ટ સ્ટેટમાં રેકોર્ડ કરી શકાય છે.

તમે બ્લોક નંબરોનો ઉપયોગ કરીને હરાજીની શરૂઆત અને સમાપ્તિનો સમય પણ સેટ કરી શકો છો: વેવ્સ બ્લોકચેનમાં બ્લોક જનરેશનની આવર્તન લગભગ સમાન છે 60 સેકન્ડ

1. અંગ્રેજી ચડતી કિંમતની હરાજી

અંગ્રેજી હરાજીમાં સહભાગીઓ એકબીજા સાથે સ્પર્ધામાં બિડ કરે છે. દરેક નવી શરત અગાઉના એક કરતાં વધી જવી જોઈએ. જ્યારે છેલ્લી બિડ કરતાં વધુ બિડર્સ ન હોય ત્યારે હરાજી સમાપ્ત થાય છે. આ કિસ્સામાં, સૌથી વધુ બોલી લગાવનારએ જણાવેલ રકમ પ્રદાન કરવી આવશ્યક છે.

એક હરાજી વિકલ્પ પણ છે જેમાં વેચનાર લોટ માટે લઘુત્તમ કિંમત નક્કી કરે છે અને અંતિમ કિંમત તેનાથી વધી જવી જોઈએ. નહિંતર, લોટ વેચાયા વગર રહે છે.

આ ઉદાહરણમાં, અમે હરાજી માટે ખાસ બનાવેલા એકાઉન્ટ સાથે કામ કરી રહ્યા છીએ. હરાજીની અવધિ 3000 બ્લોક્સ છે, અને લોટની પ્રારંભિક કિંમત 0,001 વેવ્સ છે. સહભાગી કી "કિંમત" અને તેમની બિડની કિંમત સાથે ડેટા ટ્રાન્ઝેક્શન મોકલીને બિડ મૂકી શકે છે.

નવી બિડની કિંમત આ કી માટે વર્તમાન કિંમત કરતા વધારે હોવી જોઈએ અને સહભાગી પાસે તેના ખાતામાં ઓછામાં ઓછા [નવી_બિડ + કમિશન] ટોકન્સ હોવા જોઈએ. બિડરનું સરનામું ડેટા ટ્રાન્ઝેક્શનમાં "પ્રેષક" ફીલ્ડમાં રેકોર્ડ કરવું આવશ્યક છે, અને વર્તમાન બિડ બ્લોક ઊંચાઈ હરાજીના સમયગાળાની અંદર હોવી જોઈએ.

જો હરાજીના અંતે સહભાગીએ સૌથી વધુ કિંમત નક્કી કરી હોય, તો તે ચોક્કસ કિંમત અને ચલણ જોડી પર સંબંધિત લોટ માટે ચૂકવણી કરવા માટે એક્સચેન્જ ટ્રાન્ઝેક્શન મોકલી શકે છે.

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) સાથે ડેટા ટ્રાન્ઝેક્શન મોકલવાની વિનંતી કરવાની જરૂર છે અને પહેલેથી જ ઉપયોગમાં લેવાયેલી કી વડે ડેટા ટ્રાન્ઝેક્શન મોકલવા પર પ્રતિબંધ મૂકવો પડશે.

તેથી, વપરાશકર્તાના પુરાવાઓમાં વીમા ટોકન ખરીદીનું ટ્રાન્ઝેક્શન ID હોવું આવશ્યક છે. ચલણની જોડી ખરીદી વ્યવહારમાં હોય તેવી જ હોવી જોઈએ. કિંમત પણ ખરીદતી વખતે નિયત કરેલ રકમની બરાબર હોવી જોઈએ, વીમાની કિંમત બાદ કરો.

તે સમજી શકાય છે કે પછીથી વીમા ખાતું વપરાશકર્તા પાસેથી વીમા ટોકન્સ ખરીદે છે જે તેણે ખરીદ્યા હોય તેના કરતા ઓછી કિંમતે ન હોય: વીમા ખાતું એક્સચેન્જ ટ્રાન્ઝેક્શન બનાવે છે, વપરાશકર્તા ઓર્ડર પર સહી કરે છે (જો વ્યવહાર યોગ્ય રીતે પૂર્ણ થયો હોય), વીમા ખાતું બીજા ઓર્ડર અને સમગ્ર વ્યવહાર પર સહી કરે છે અને તેને બ્લોકચેન પર મોકલે છે.

જો કોઈ ખરીદી ન થાય, તો વપરાશકર્તા સ્ક્રિપ્ટમાં વર્ણવેલ નિયમો અનુસાર એક્સચેન્જ ટ્રાન્ઝેક્શન બનાવી શકે છે અને ટ્રાન્ઝેક્શનને બ્લોકચેન પર મોકલી શકે છે. આ રીતે વપરાશકર્તા વીમાવાળા ટોકન્સની ખરીદી પર ખર્ચવામાં આવેલ નાણાં પરત કરી શકે છે.

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 (જે તમારી પાસેથી 10 *N/taxDivisor WAVES પર ખરીદી શકાય છે) ની રકમમાં FeeCoin આપશે, અને તમે ખાણિયોને N/taxDivisor WAVES આપશે. પરિણામે, તમારો નફો (કર) 9*N / taxDivisor WAVES હશે.

તમે સ્માર્ટ એસેટ સ્ક્રિપ્ટ અને માસ ટ્રાન્સફર ટ્રાન્ઝેક્શનનો ઉપયોગ કરીને કરવેરા પણ કરી શકો છો:

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
}

કેશબેક અને લોયલ્ટી પ્રોગ્રામ

કેશબેક એ લોયલ્ટી પ્રોગ્રામનો એક પ્રકાર છે જેમાં ખરીદનારને ઉત્પાદન અથવા સેવા પર ખર્ચવામાં આવેલી રકમનો ભાગ પાછો મળે છે.

સ્માર્ટ એકાઉન્ટનો ઉપયોગ કરીને આ કેસને અમલમાં મૂકતી વખતે, આપણે વીમાના કેસમાં જે રીતે પુરાવા તપાસ્યા હતા તે જ રીતે તપાસવા જોઈએ. બેવડા ખર્ચને રોકવા માટે, વપરાશકર્તાએ કેશબેક મેળવતા પહેલા (કી, મૂલ્ય) = (પરચેઝટ્રાન્સેકશનઆઈડી, કેશબેકટ્રાન્સેકશનઆઈડી) સાથે ડેટા ટ્રાન્ઝેક્શન મોકલવું આવશ્યક છે.

આપણે ડેટા ટ્રાન્ઝેક્શનનો ઉપયોગ કરીને હાલની કી પર પ્રતિબંધ પણ સેટ કરવો જોઈએ. 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