വേവ്സ് സ്മാർട്ട് അക്കൗണ്ടുകളുടെ ആപ്ലിക്കേഷനുകൾ: ലേലം മുതൽ ബോണസ് പ്രോഗ്രാമുകൾ വരെ

ബ്ലോക്ക്‌ചെയിൻ പലപ്പോഴും ക്രിപ്‌റ്റോകറൻസികളുമായി മാത്രം ബന്ധപ്പെട്ടിരിക്കുന്നു, എന്നാൽ DLT സാങ്കേതികവിദ്യയുടെ പ്രയോഗത്തിന്റെ മേഖലകൾ വളരെ വിശാലമാണ്. ബ്ലോക്ക്‌ചെയിൻ ഉപയോഗിക്കുന്നതിനുള്ള ഏറ്റവും വാഗ്ദാനമായ മേഖലകളിലൊന്ന് ഒരു സ്മാർട്ട് കരാറാണ്, അത് യാന്ത്രികമായി നടപ്പിലാക്കുകയും അതിൽ പ്രവേശിച്ച കക്ഷികൾക്കിടയിൽ വിശ്വാസം ആവശ്യമില്ല.

റൈഡ് - സ്മാർട്ട് കരാറുകൾക്കുള്ള ഒരു ഭാഷ

സ്മാർട്ട് കരാറുകൾക്കായി വേവ്സ് ഒരു പ്രത്യേക ഭാഷ വികസിപ്പിച്ചെടുത്തിട്ടുണ്ട് - RIDE. അതിന്റെ പൂർണ്ണമായ ഡോക്യുമെന്റേഷൻ സ്ഥിതി ചെയ്യുന്നു ഇവിടെ. പിന്നെ ഇവിടെ - ഈ വിഷയത്തെക്കുറിച്ചുള്ള ലേഖനം ഹബ്രിൽ.

റൈഡ് കരാർ ഒരു പ്രവചനമാണ് കൂടാതെ ഔട്ട്പുട്ടായി "ശരി" അല്ലെങ്കിൽ "തെറ്റ്" നൽകുന്നു. അതനുസരിച്ച്, ഇടപാട് ബ്ലോക്ക്ചെയിനിൽ രേഖപ്പെടുത്തുകയോ നിരസിക്കുകയോ ചെയ്യുന്നു. സ്‌മാർട്ട് കരാർ നിർദ്ദിഷ്ട വ്യവസ്ഥകളുടെ പൂർത്തീകരണത്തിന് പൂർണ്ണമായി ഉറപ്പ് നൽകുന്നു. RIDE-ലെ ഒരു കരാറിൽ നിന്ന് ഇടപാടുകൾ സൃഷ്ടിക്കുന്നത് നിലവിൽ സാധ്യമല്ല.

ഇന്ന് രണ്ട് തരം വേവ്സ് സ്മാർട്ട് കരാറുകളുണ്ട്: സ്മാർട്ട് അക്കൗണ്ടുകളും സ്മാർട്ട് അസറ്റുകളും. ഒരു സ്മാർട്ട് അക്കൗണ്ട് ഒരു സാധാരണ ഉപയോക്തൃ അക്കൗണ്ടാണ്, എന്നാൽ എല്ലാ ഇടപാടുകളും നിയന്ത്രിക്കുന്ന ഒരു സ്ക്രിപ്റ്റ് അതിനായി സജ്ജീകരിച്ചിരിക്കുന്നു. ഒരു സ്മാർട്ട് അക്കൗണ്ട് സ്ക്രിപ്റ്റ് ഇതുപോലെയായിരിക്കാം, ഉദാഹരണത്തിന്:

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

tx എന്നത് ഒരു ട്രാൻസ്ഫർ ഇടപാടല്ലെങ്കിൽ മാത്രം പാറ്റേൺ പൊരുത്തപ്പെടുത്തൽ സംവിധാനം ഉപയോഗിക്കാൻ അനുവദിക്കുന്ന ഒരു ഇടപാടാണ്. ഇടപാടിന്റെ തരം പരിശോധിക്കാൻ RIDE-ലെ പാറ്റേൺ പൊരുത്തപ്പെടുത്തൽ ഉപയോഗിക്കുന്നു. നിലവിലുള്ള എല്ലാ അക്കൗണ്ടുകളും സ്മാർട്ട് അക്കൗണ്ട് സ്‌ക്രിപ്റ്റിൽ പ്രോസസ്സ് ചെയ്യാൻ കഴിയും ഇടപാട് തരങ്ങൾ.

സ്ക്രിപ്റ്റിന് വേരിയബിളുകൾ പ്രഖ്യാപിക്കാനും വ്യവസ്ഥകൾ പൂർണ്ണമായി പരിശോധിക്കുന്നതിന് "if-then-else" കൺസ്ട്രക്റ്റുകളും മറ്റ് രീതികളും ഉപയോഗിക്കാനും കഴിയും. കരാർ നിർവ്വഹണം ആരംഭിക്കുന്നതിന് മുമ്പ് പ്രവചിക്കാൻ എളുപ്പമുള്ള, തെളിയിക്കാവുന്ന സമ്പൂർണ്ണതയും സങ്കീർണ്ണതയും (ചെലവ്) കരാറുകൾക്ക് ഉണ്ടെന്ന് ഉറപ്പാക്കാൻ, RIDE-ൽ ലൂപ്പുകളോ ജമ്പ് പ്രസ്താവനകളോ അടങ്ങിയിട്ടില്ല.

വേവ്സ് അക്കൗണ്ടുകളുടെ മറ്റ് സവിശേഷതകളിൽ ഒരു "സ്റ്റേറ്റ്" യുടെ സാന്നിധ്യം ഉൾപ്പെടുന്നു, അതായത് അക്കൗണ്ടിന്റെ അവസ്ഥ. ഡാറ്റാ ഇടപാടുകൾ (ഡാറ്റാ ട്രാൻസാക്ഷൻ) ഉപയോഗിച്ച് അക്കൗണ്ട് നിലയിലേക്ക് നിങ്ങൾക്ക് അനന്തമായ ജോഡികൾ (കീ, മൂല്യം) എഴുതാം. ഈ വിവരങ്ങൾ REST API വഴിയും നേരിട്ട് സ്‌മാർട്ട് കരാറിലും പ്രോസസ്സ് ചെയ്യാവുന്നതാണ്.

ഓരോ ഇടപാടിലും ഒരു കൂട്ടം തെളിവുകൾ അടങ്ങിയിരിക്കാം, അതിൽ പങ്കാളിയുടെ ഒപ്പ്, ആവശ്യമായ ഇടപാടിന്റെ ഐഡി മുതലായവ നൽകാം.

RIDE വഴി പ്രവർത്തിക്കുന്നു ഇവിടെ കരാറിന്റെ സമാഹരിച്ച കാഴ്ച കാണാൻ നിങ്ങളെ അനുവദിക്കുന്നു (അത് കംപൈൽ ചെയ്തിട്ടുണ്ടെങ്കിൽ), പുതിയ അക്കൗണ്ടുകൾ സൃഷ്ടിക്കുക, അതിനായി സ്ക്രിപ്റ്റുകൾ സജ്ജമാക്കുക, അതുപോലെ കമാൻഡ് ലൈൻ വഴി ഇടപാടുകൾ അയയ്ക്കുക.

ഒരു അക്കൗണ്ട് സൃഷ്‌ടിക്കുക, അതിൽ ഒരു സ്‌മാർട്ട് കോൺട്രാക്‌റ്റ് ഇൻസ്‌റ്റാൾ ചെയ്യുക, ഇടപാടുകൾ അയയ്‌ക്കുക എന്നിവ ഉൾപ്പെടെയുള്ള ഒരു പൂർണ്ണ സൈക്കിളിനായി, നിങ്ങൾക്ക് REST API-യുമായി സംവദിക്കുന്നതിന് ഒരു ലൈബ്രറിയും ഉപയോഗിക്കാം (ഉദാഹരണത്തിന്, C#, C, Java, JavaScript, Python, Rust, Elixir) . IDE ഉപയോഗിച്ച് പ്രവർത്തിക്കാൻ ആരംഭിക്കുന്നതിന്, പുതിയ ബട്ടൺ ക്ലിക്ക് ചെയ്യുക.

സ്മാർട്ട് കരാറുകൾ ഉപയോഗിക്കുന്നതിനുള്ള സാധ്യതകൾ വിശാലമാണ്: ചില വിലാസങ്ങൾ ("ബ്ലാക്ക് ലിസ്റ്റ്") വരെയുള്ള ഇടപാടുകൾ നിരോധിക്കുന്നത് മുതൽ സങ്കീർണ്ണമായ dApps വരെ.

ഇപ്പോൾ ബിസിനസ്സിൽ സ്മാർട്ട് കരാറുകളുടെ ഉപയോഗത്തിന്റെ നിർദ്ദിഷ്ട ഉദാഹരണങ്ങൾ നോക്കാം: ലേലം നടത്തുമ്പോൾ, ഇൻഷുറൻസ്, ലോയൽറ്റി പ്രോഗ്രാമുകൾ സൃഷ്ടിക്കുമ്പോൾ.

ലേലങ്ങൾ

വിജയകരമായ ലേലത്തിനുള്ള വ്യവസ്ഥകളിലൊന്ന് സുതാര്യതയാണ്: ലേലത്തിൽ കൃത്രിമം കാണിക്കുന്നത് അസാധ്യമാണെന്ന് പങ്കാളികൾക്ക് ഉറപ്പുണ്ടായിരിക്കണം. എല്ലാ പന്തയങ്ങളെക്കുറിച്ചും അവ നിർമ്മിച്ച സമയത്തെക്കുറിച്ചും മാറ്റമില്ലാത്ത ഡാറ്റ എല്ലാ പങ്കാളികൾക്കും ലഭ്യമാകുന്ന ബ്ലോക്ക്ചെയിനിന് നന്ദി ഇത് നേടാനാകും.

വേവ്സ് ബ്ലോക്ക്ചെയിനിൽ, ലേല അക്കൗണ്ട് അവസ്ഥയിൽ ഡാറ്റാ ട്രാൻസാക്ഷൻ വഴി ബിഡ്ഡുകൾ രേഖപ്പെടുത്താം.

ബ്ലോക്ക് നമ്പറുകൾ ഉപയോഗിച്ച് നിങ്ങൾക്ക് ലേലത്തിന്റെ ആരംഭ സമയവും അവസാന സമയവും സജ്ജമാക്കാൻ കഴിയും: വേവ്സ് ബ്ലോക്ക്ചെയിനിലെ ബ്ലോക്ക് ജനറേഷന്റെ ആവൃത്തി ഏകദേശം തുല്യമാണ് 60 സെക്കന്റുകൾ.

1. ഇംഗ്ലീഷ് ആരോഹണ വില ലേലം

ഒരു ഇംഗ്ലീഷ് ലേലത്തിൽ പങ്കെടുക്കുന്നവർ പരസ്പരം മത്സരത്തിൽ ലേലം വിളിക്കുന്നു. ഓരോ പുതിയ പന്തയവും മുമ്പത്തേതിനേക്കാൾ കൂടുതലായിരിക്കണം. അവസാനത്തെ ബിഡിനേക്കാൾ കൂടുതൽ ലേലക്കാർ ഇല്ലാതിരിക്കുമ്പോൾ ലേലം അവസാനിക്കും. ഈ സാഹചര്യത്തിൽ, ഏറ്റവും ഉയർന്ന ലേലക്കാരൻ പറഞ്ഞ തുക നൽകണം.

ഒരു ലേല ഓപ്ഷനും ഉണ്ട്, അതിൽ വിൽപ്പനക്കാരൻ ലോട്ടിന് കുറഞ്ഞ വില നിശ്ചയിക്കുന്നു, അവസാന വില അതിനെ കവിയണം. അല്ലെങ്കിൽ, ചീട്ട് വിൽക്കപ്പെടാതെ കിടക്കും.

ഈ ഉദാഹരണത്തിൽ, ലേലത്തിനായി പ്രത്യേകം സൃഷ്‌ടിച്ച ഒരു അക്കൗണ്ട് ഉപയോഗിച്ചാണ് ഞങ്ങൾ പ്രവർത്തിക്കുന്നത്. ലേല കാലയളവ് 3000 ബ്ലോക്കുകളാണ്, ലോട്ടിന്റെ ആരംഭ വില 0,001 തരംഗങ്ങളാണ്. ഒരു പങ്കാളിക്ക് "വില" എന്ന കീയും അവരുടെ ബിഡിന്റെ മൂല്യവും സഹിതം ഒരു ഡാറ്റാ ട്രാൻസാക്ഷൻ അയച്ചുകൊണ്ട് ഒരു ബിഡ് സ്ഥാപിക്കാം.

പുതിയ ബിഡ്ഡിന്റെ വില ഈ കീയുടെ നിലവിലെ വിലയേക്കാൾ കൂടുതലായിരിക്കണം, കൂടാതെ പങ്കെടുക്കുന്നയാളുടെ അക്കൗണ്ടിൽ കുറഞ്ഞത് [new_bid + കമ്മീഷൻ] ടോക്കണുകളെങ്കിലും ഉണ്ടായിരിക്കണം. ബിഡ്ഡറുടെ വിലാസം ഡാറ്റാ ട്രാൻസാക്ഷനിലെ "അയക്കുന്നയാൾ" ഫീൽഡിൽ രേഖപ്പെടുത്തിയിരിക്കണം, കൂടാതെ നിലവിലെ ബിഡ് ബ്ലോക്കിന്റെ ഉയരം ലേല കാലയളവിനുള്ളിൽ ആയിരിക്കണം.

ലേലത്തിന്റെ അവസാനത്തിൽ പങ്കെടുക്കുന്നയാൾ ഏറ്റവും ഉയർന്ന വില നിശ്ചയിച്ചിട്ടുണ്ടെങ്കിൽ, നിർദ്ദിഷ്ട വിലയിലും കറൻസി ജോഡിയിലും അനുബന്ധ ലോട്ടിന് പണമടയ്ക്കാൻ അയാൾക്ക് ഒരു എക്സ്ചേഞ്ച് ട്രാൻസാക്ഷൻ അയയ്ക്കാം.

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) കൂടാതെ ഇതിനകം ഉപയോഗിച്ച ഒരു കീ ഉപയോഗിച്ച് DataTransactions അയക്കുന്നത് നിരോധിക്കുകയും വേണം.

അതിനാൽ, ഉപയോക്താവിന്റെ തെളിവുകളിൽ ഇൻഷുറൻസ് ടോക്കൺ വാങ്ങലിന്റെ ഇടപാട് ഐഡി ഉണ്ടായിരിക്കണം. കറൻസി ജോഡി വാങ്ങൽ ഇടപാടിലെ പോലെ തന്നെ ആയിരിക്കണം. ഇൻഷുറൻസിന്റെ വിലയിൽ നിന്ന് കുറയ്‌ക്കുമ്പോൾ വാങ്ങുന്ന സമയത്ത് നിശ്ചയിച്ചതിന് തുല്യമായിരിക്കണം ചെലവും.

പിന്നീട് ഇൻഷുറൻസ് അക്കൗണ്ട് ഉപയോക്താവിൽ നിന്ന് ഇൻഷുറൻസ് ടോക്കണുകൾ വാങ്ങിയതിനേക്കാൾ കുറഞ്ഞ വിലയ്ക്ക് വാങ്ങുന്നുവെന്ന് മനസ്സിലാക്കുന്നു: ഇൻഷുറൻസ് അക്കൗണ്ട് ഒരു എക്‌സ്‌ചേഞ്ച് ട്രാൻസാക്ഷൻ സൃഷ്ടിക്കുന്നു, ഉപയോക്താവ് ഓർഡറിൽ ഒപ്പിടുന്നു (ഇടപാട് ശരിയായി പൂർത്തിയാക്കിയാൽ), ഇൻഷുറൻസ് അക്കൗണ്ട് രണ്ടാമത്തെ ഓർഡറും മുഴുവൻ ഇടപാടും ഒപ്പിട്ട് ബ്ലോക്ക്ചെയിനിലേക്ക് അയയ്ക്കുന്നു.

വാങ്ങൽ ഒന്നും സംഭവിക്കുന്നില്ലെങ്കിൽ, സ്ക്രിപ്റ്റിൽ വിവരിച്ചിരിക്കുന്ന നിയമങ്ങൾക്കനുസൃതമായി ഉപയോക്താവിന് ഒരു എക്സ്ചേഞ്ച് ട്രാൻസാക്ഷൻ സൃഷ്ടിക്കാനും ഇടപാട് ബ്ലോക്ക്ചെയിനിലേക്ക് അയയ്ക്കാനും കഴിയും. ഇതുവഴി ഇൻഷ്വർ ചെയ്ത ടോക്കണുകൾ വാങ്ങുന്നതിന് ചെലവഴിച്ച പണം ഉപയോക്താവിന് തിരികെ നൽകാനാകും.

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 ആയിരിക്കും.

നിങ്ങൾക്ക് ഒരു സ്‌മാർട്ട് അസറ്റ് സ്‌ക്രിപ്‌റ്റും മാസ്‌ട്രാൻസ്‌ഫർ ട്രാൻസാക്ഷനും ഉപയോഗിച്ച് നികുതി ചുമത്താനും കഴിയും:

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) ഉപയോഗിച്ച് ഒരു ഡാറ്റാ ട്രാൻസാക്ഷൻ അയയ്ക്കണം.

ഡാറ്റാ ട്രാൻസാക്ഷൻ ഉപയോഗിച്ച് നിലവിലുള്ള കീകൾ നിരോധിക്കുകയും വേണം. ക്യാഷ്ബാക്ക് ഡിവിസർ - യൂണിറ്റ് ക്യാഷ്ബാക്ക് ഷെയർ കൊണ്ട് ഹരിക്കുന്നു. ആ. ക്യാഷ്ബാക്ക് ഷെയർ 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