ఆర్థిక సాధనాల్లో వేవ్స్ స్మార్ట్ ఖాతాలు మరియు స్మార్ట్ ఆస్తుల అప్లికేషన్

మునుపటిలో వ్యాసం వేలం మరియు లాయల్టీ ప్రోగ్రామ్‌లతో సహా వ్యాపారంలో స్మార్ట్ ఖాతాలను ఉపయోగించే అనేక సందర్భాలను మేము పరిశీలించాము.
ఈ రోజు మనం స్మార్ట్ ఖాతాలు మరియు స్మార్ట్ ఆస్తులు ఆప్షన్‌లు, ఫ్యూచర్‌లు మరియు బిల్లులు వంటి ఆర్థిక సాధనాల యొక్క పారదర్శకత మరియు విశ్వసనీయతను ఎలా మెరుగుపరుస్తాయనే దాని గురించి మాట్లాడుతాము.

ఎంపిక

ఎంపిక అనేది ఎక్స్ఛేంజ్ కాంట్రాక్ట్, ఇది కొనుగోలుదారుకు ఒక నిర్దిష్ట ధర వద్ద లేదా నిర్దిష్ట తేదీకి ముందు ఆస్తిని కొనుగోలు చేసే హక్కును ఇస్తుంది, కానీ అలా చేయమని అతనిని నిర్బంధించదు.

ఎంపిక యొక్క అమలు క్రింది విధంగా ఉంటుంది:

మేము ఆప్షన్‌ల కోసం స్మార్ట్ అసెట్‌ను పరికరంగా ఉపయోగిస్తాము మరియు ఎక్స్‌ఛేంజ్‌గా వ్యవహరించి ఎంపికలను జారీ చేసే పాల్గొనేవారి కోసం స్మార్ట్ ఖాతాను ఉపయోగిస్తాము. ఎక్స్‌ఛేంజ్ పార్టిసిపెంట్, ఎక్స్‌పైర్‌స్టార్ట్ మరియు ఎక్స్‌పైరేషన్‌ఎండ్ బ్లాక్ ఎత్తుల మధ్య నిర్దిష్ట ఆస్తిలో కొంత మొత్తాన్ని విక్రయ ధరకు విక్రయిస్తానని వాగ్దానం చేశాడు.

స్మార్ట్ అసెట్ కోడ్‌లో, ఇది పేర్కొన్న ఎత్తుల మధ్య మాత్రమే వర్తకం చేయబడిందని మేము తనిఖీ చేస్తాము మరియు మరేదైనా తనిఖీ చేయము; మేము నిబంధనలకు అనుగుణంగా అన్ని బాధ్యతలను ఎక్స్ఛేంజ్ పార్టిసిపెంట్ కోడ్‌కు వదిలివేస్తాము.

స్మార్ట్ ఆస్తి కోడ్:

let expirationStart = 100000
let expirationEnd = 101440

match tx {
   case some : ExchangeTransaction | TransferTransaction =>
       height > expirationStart && height <= expirationEnd
   case _ => false
}

చర్యలు క్రింది విధంగా జరుగుతాయని మేము ఊహిస్తాము: మార్పిడిలో పాల్గొనేవారు కొంత ఆస్తిని కొనుగోలు చేయడానికి ఎంపికలను విక్రయిస్తారు మరియు ఇతర పాల్గొనేవారు ఈ ఎంపికలను ఫార్వార్డ్ చేయవచ్చు లేదా వాటిని వ్యాపారం చేయవచ్చు. కొనుగోలు చేయడానికి తన హక్కును వినియోగించుకోవడానికి, సంభావ్య కొనుగోలుదారు తప్పనిసరిగా కావలసిన సంఖ్యలో ఎంపికలను విక్రేత ఖాతాకు బదిలీ చేయాలి, అంటే మార్పిడిలో పాల్గొనే వ్యక్తి. తరువాత, అతను ఎక్స్ఛేంజ్ పార్టిసిపెంట్ యొక్క రాష్ట్ర ఖాతాకు పూర్తి బదిలీ గురించి సమాచారాన్ని వ్రాస్తాడు మరియు అప్పుడు మాత్రమే ఎక్స్ఛేంజ్ ట్రాన్సాక్షన్ కొనుగోలు మరియు అమ్మకం యొక్క పేర్కొన్న షరతుల ప్రకారం కొనసాగుతుంది.

స్మార్ట్ ఖాతా కోడ్‌లో, కొనుగోలు మరియు అమ్మకం యొక్క తుది చర్య కోసం ఏదైనా ఎక్స్ఛేంజ్ ట్రాన్సాక్షన్ దాని గుండా వెళుతుందని మేము నిర్ధారించుకోవాలి మరియు పాల్గొనేవారు ఎక్స్ఛేంజ్ పార్టిసిపెంట్ ఖాతాకు పంపిన యూనిట్ల సంఖ్యను ఖచ్చితంగా కొనుగోలు చేస్తారు. సంభావ్య కొనుగోలుదారు తప్పనిసరిగా బదిలీ గురించి సరైన డేటా లావాదేవీని పంపాలి, తద్వారా మార్పిడిలో పాల్గొనేవారు రెట్టింపు ఖర్చును నివారించవచ్చు. ఈ డేటా ట్రాన్సాక్షన్‌లో, కొనుగోలుదారు తన చిరునామాకు సమానమైన కీ ప్రకారం, ఎక్స్ఛేంజ్ పార్టిసిపెంట్ ఖాతాకు బదిలీ చేయబడిన ఎంపికల సంఖ్యకు సమానమైన విలువను ఉంచుతాడు, అంటే అతను కొనుగోలు చేయగల ఆస్తి యూనిట్ల సంఖ్య.

స్మార్ట్ ఖాతా కోడ్:

#владелец аккаунта дает обязательство продать определенное количество юнитов ассета
#по цене sellPrice между высотами блоков expirationStart и expirationEnd

let expirationStart = 100000
let expirationEnd = 101440
let sellPrice = 10000
let amountAsset = base58'8jfD2JBLe23XtCCSQoTx5eAW5QCU6Mbxi3r78aNQLcNf'
let priceAsset = base58'9jfD2JBLe23XtCCSQoTx5eAW5QCU6Mbxi3r78aNQLcNf'
#ID ассета-опциона
let optionsAsset = base58'7jfD2JBLe23XtCCSQoTx5eAW5QCU6Mbxi3r78aNQLcNf'
#извлекаем из транзакции адрес отправителя
let this = tx.sender
match tx {
   case dataTx : DataTransaction =>
       #извлекаем количество юнитов из дата-транзакции по ключу (ID пользователя)
       let units = extract(getInteger(dataTx.data, dataTx.data[0].key))

       #извлекаем трансфер-транзакцию опционов из пруфа
       let e = transactionById(dataTx.proofs[2]) #
       match e {
           case transferTx : TransferTransaction =>
               #убеждаемся, что трансфер был на текущий адрес
               (transferTx.recipient == this) &&
               #убеждаемся, что отправитель транзакции написал в качестве ключа свой ID
               dataTx.data[0].key == toBase58String(transferTx.sender.bytes) &&
               sigVerify(dataTx.bodyBytes, dataTx.proofs[0], transferTx.senderPublicKey) &&
               #убеждаемся, что указанное количество юнитов соответствует посланному количеству опционов
               (units == transferTx.amount) &&
               #убеждаемся, что был переведен именно ассет-опцион
               (transferTx.assetId == optionsAsset)              
           case _ => false
       } &&
       size(dataTx.data) == 1 && !isDefined(getInteger(this, dataTx.data[0].key))
       && height > expirationStart && height <= expirationEnd
   case exchangeTx : ExchangeTransaction =>
       #убеждаемся, что итоговый обмен происходит по указанным заранее правилам
       let correctAssetPair = exchangeTx.sellOrder.assetPair.amountAsset == amountAsset &&
                                   exchangeTx.sellOrder.assetPair.priceAsset == priceAsset
       let correctPrice = exchangeTx.sellOrder.price == sellPrice
       #извлекаем дата-транзакцию из пруфа      
       let d = transactionById(exchangeTx.proofs[2])
       match d{
           case dataTx : DataTransaction =>
               let buyOrderSender = dataTx.data[0].key
               toBase58String(exchangeTx.buyOrder.sender.bytes) == buyOrderSender &&
               exchangeTx.amount == extract(getInteger(dataTx.data, buyOrderSender))
           case _ => false
       } &&
       exchangeTx.sellOrder.sender == this &&
       correctAssetPair && correctPrice &&
       height > expirationStart && height <= expirationEnd
   case _ => false
}

స్మార్ట్ ఖాతాలపై భవిష్యత్తు

ఒక ఎంపిక వలె కాకుండా, ఫ్యూచర్స్ (ఫ్యూచర్స్ కాంట్రాక్ట్) అనేది ఒక హక్కు కాదు, అయితే భవిష్యత్తులో ఒక నిర్దిష్ట సమయంలో ఒప్పందం ద్వారా నిర్ణయించబడిన ధరకు ఆస్తిని కొనుగోలు చేయడం కొనుగోలుదారు యొక్క బాధ్యత.

సాధారణంగా, భవిష్యత్తును వ్రాయడం అనేది ఒక ఎంపికను వ్రాయడం వలె ఉంటుంది. ఇక్కడ స్మార్ట్ ఆస్తి భవిష్యత్తుగా పనిచేస్తుంది.

కొనుగోలుదారు మరియు విక్రేత ఇద్దరూ కొనుగోలు ఆర్డర్‌పై సంతకం చేశారని కూడా మీరు నిర్ధారించుకోవాలి. భవిష్యత్తు అనేది ఏ సందర్భంలోనైనా నెరవేర్చవలసిన బాధ్యత. దీనర్థం విక్రేత లేదా పాల్గొనేవారు తమ బాధ్యతలను నిరాకరిస్తే, నెట్‌వర్క్‌లోని ఎవరైనా పాల్గొనేవారు లావాదేవీని పంపవచ్చు, తద్వారా భవిష్యత్తును అమలు చేయవచ్చు.

స్మార్ట్ అసెట్ స్క్రిప్ట్ ఫ్యూచర్స్ అసెట్ యొక్క అన్ని బదిలీ లావాదేవీలు మరియు మార్పిడి లావాదేవీలను నియంత్రిస్తుంది, కొనుగోలుదారు భాగస్వామి ఎక్స్ఛేంజ్ పార్టిసిపెంట్ నుండి ఫ్యూచర్స్ అసెట్ యొక్క భవిష్యత్తు కొనుగోలు కోసం ఆర్డర్‌ను సృష్టించినట్లయితే మాత్రమే వాటిని ఆమోదిస్తుంది.

ఈ ఆర్డర్ తప్పనిసరిగా చెల్లుబాటులో ఉండాలి మరియు ఫ్యూచర్‌లు జారీ చేయబడిన షరతులను సంతృప్తి పరచాలి. ఆర్డర్‌ను ధృవీకరించడానికి, మీరు సంతకం చేసిన ఆర్డర్ యొక్క బైట్ ప్రాతినిధ్యంతో పాటు కొనుగోలుదారు యొక్క ఖాతా యొక్క స్థితిలో దాని అన్ని ఫీల్డ్‌లను నమోదు చేయవచ్చు, ఆపై బాహ్య ధ్రువీకరణను చేయవచ్చు.

ప్రస్తుతానికి, RIDE లావాదేవీ బైట్‌లను అన్వయించడానికి స్థానిక ఫంక్షన్‌ను కలిగి లేదు, కానీ దాని అమలుకు అవసరమైన అన్ని సాధనాలను కలిగి ఉంటుంది. అందువల్ల, డెవలపర్లు ఈ లక్షణాన్ని స్వయంగా అమలు చేయడానికి ప్రయత్నించవచ్చు.

బహుళ సంతకం ఖాతా / ఎస్క్రో

బహుళ సంతకం ఖాతా బహుళ వినియోగదారులను ఉమ్మడిగా ఆస్తులను నిర్వహించడానికి అనుమతిస్తుంది (ఉదాహరణకు, నలుగురిలో ముగ్గురు వినియోగదారులు సంతకాలు కలిగి ఉంటే మాత్రమే ఆస్తులతో లావాదేవీలు సాధ్యమవుతాయి). RIDE భాషలో బహుళ సంతకం ఖాతాలను సృష్టించడానికి, మేము లావాదేవీ రుజువులను ఉపయోగించవచ్చు.

బహుళ సంతకం ఖాతాను ఎస్క్రో ఖాతాగా కూడా ఉపయోగించవచ్చు, దీనిలో ఒప్పందంలోని పార్టీలు తమ బాధ్యతలను నెరవేర్చే వరకు నిధులు ఉంటాయి.

let alicePubKey  = base58'5AzfA9UfpWVYiwFwvdr77k6LWupSTGLb14b24oVdEpMM'
let bobPubKey    = base58'2KwU4vzdgPmKyf7q354H9kSyX9NZjNiq4qbnH2wi2VDF'
let cooperPubKey = base58'GbrUeGaBfmyFJjSQb9Z8uTCej5GzjXfRDVGJGrmgt5cD'
#выясняем, кто предоставил корректные подписи
let aliceSigned  = if(sigVerify(tx.bodyBytes, tx.proofs[0], alicePubKey)) then 1 else 0
let bobSigned    = if(sigVerify(tx.bodyBytes, tx.proofs[1], bobPubKey)) then 1 else 0
let cooperSigned = if(sigVerify(tx.bodyBytes, tx.proofs[2], cooperPubKey)) then 1 else 0
#суммируем все корректные подписи и проверяем их количество
aliceSigned + bobSigned + cooperSigned >= 2

టోకెన్ క్యూరేటెడ్ రిజిస్ట్రీ (TCR)

అనేక బ్లాక్‌చెయిన్ ప్లాట్‌ఫారమ్‌లు విషపూరిత ఆస్తులతో సమస్యను కలిగి ఉన్నాయి. ఉదాహరణకు, కమీషన్ చెల్లించిన ఏదైనా చిరునామా వేవ్స్‌లో ఆస్తిని సృష్టించవచ్చు.

విషపూరిత ఆస్తుల నుండి వినియోగదారులను మరియు బ్లాక్‌చెయిన్‌ను రక్షించే సమస్యను టోకెన్ హోల్డర్‌లు రూపొందించిన టోకెన్ క్యూరేటెడ్ రిజిస్ట్రీ (TCR) ద్వారా పరిష్కరించవచ్చు.

జాబితాకు జోడించబడే నిర్దిష్ట టోకెన్ కోసం ఓటు వేయడానికి, హోల్డర్ జారీ చేసిన మొత్తం టోకెన్ల సంఖ్యలో తన వాటాకు సమానమైన బిడ్‌ను వేస్తాడు. టోకెన్‌ను కలిగి ఉన్నవారిలో ఎక్కువ మంది దానికి ఓటు వేస్తే రిజిస్టర్‌లో చేర్చబడుతుంది.

మా ఉదాహరణలో, ప్రస్తుత గణన విలువ = 0 అయితే మాత్రమే, స్టేట్ కీ = asset_nameని ఉపయోగించి ("ఛాలెంజ్" వ్యవధిలో) పరిశీలన కోసం జాబితాకు టోకెన్‌ను జోడించడానికి వినియోగదారుని మేము అనుమతిస్తాము.

అలాగే, వినియోగదారు తన వాలెట్‌లో ఈ టోకెన్ యొక్క జీరో కాని బ్యాలెన్స్‌ని కలిగి ఉండాలి. ఆపై ఓటింగ్ వ్యవధి వస్తుంది, ఈ సమయంలో వినియోగదారు తన వాలెట్‌లోని ప్రతి ఆస్తికి ఓటు వేయవచ్చు, కానీ ఒక్కసారి మాత్రమే, 1 నుండి 10 వరకు రేటింగ్ ఇస్తారు. వినియోగదారు ఓట్లు ఫారమ్ user_address+assetID యొక్క కీల ద్వారా సూచించబడతాయి.

let asset = base58'8jfD2JBLe23XtCCSQoTx5eAW5QCU6Mbxi3r78aNQLcNf'
let addingStartHeight = 1000
let votingStartHeight = 2000
let votingEndHeight = 3000

#извлекаем из транзакции адрес отправителя
let this = extract(tx.sender)

#извлекаем адрес из пруфа транзакции
let address = addressFromPublicKey(tx.proofs[1])
match tx {
   case t: DataTransaction =>
       if(height > addingStartHeight)
       then(
           if(height < votingStartHeight)
           then(
               #adding
               #выясняем, есть ли этот ассет у этого адреса
               let hasTokens = assetBalance(address, asset) > 0
               size(t.data) == 1
                     #убеждаемся, что этот ассет еще не был добавлен
                     && !isDefined(getInteger(this, toBase58String(asset)))
                     #убеждаемся, что по ключу-ассету добавляется значение равное 0
                     && extract(getInteger(t.data, toBase58String(asset))) == 0
                     && hasTokens
           )
           else(
               if(height < votingEndHeight)
               then
               (
                   #voting
                   #узнаем текущее количество голосов за данный ассет и задаваемое количество
                   let currentAmount = extract(getInteger(this, toBase58String(asset)))
                   let newAmount = extract(getInteger(t.data, toBase58String(asset)))
                   let betString = toBase58String(address.bytes) + toBase58String(asset)

                   #убеждаемся, что этот адрес еще не голосовал за этот ассет
                   let noBetBefore = !isDefined(getInteger(this, betString))
                   let isBetCorrect = extract(getInteger(t.data, betString)) > 0
                       && extract(getInteger(t.data, betString)) <= 10
                  
                   #убеждаемся, что у голосующего есть необходимые токены
                   let hasTokens = assetBalance(address, asset) > 0
                   #проверяем корректность значений транзакции
                   size(t.data) == 2 && isDefined(getInteger(this, toBase58String(asset)))
                       && newAmount == currentAmount + 1
                       && noBetBefore && isBetCorrect && hasTokens
               )
               else false
           ) && sigVerify(tx.bodyBytes, tx.proofs[0], tx.proofs[1])
       )
       else false
   case _ => false
}

చందా రుసుము

ఈ ఉదాహరణలో, నిర్దిష్ట వ్యవధిలో ఉత్పత్తి లేదా సేవ కోసం సాధారణ చెల్లింపులు చేయడానికి స్మార్ట్ ఖాతాల వినియోగాన్ని మేము పరిశీలిస్తాము - “చందా రుసుము”.
వినియోగదారుడు స్మార్ట్ ఖాతాను (లావాదేవీ రుజువుల ద్వారా) బదిలీ చేసిన నిధులతో అవసరమైన మొత్తంతో బదిలీ లావాదేవీ IDని అందించినట్లయితే, అతను ఖాతా స్థితికి {కీ: చిరునామా, విలువ:) వ్రాయవచ్చు నిజమైన}.

వినియోగదారు ఉత్పత్తి లేదా సేవకు వారి సభ్యత్వాన్ని నిర్ధారించారని దీని అర్థం. చందా గడువు ముగిసినప్పుడు, ఏ నెట్‌వర్క్ వినియోగదారు అయినా రాష్ట్రంలోని సంబంధిత కీ పక్కన విలువను సెట్ చేయవచ్చు తప్పుడు.

let subscriptionPeriod = 44000
let signature = tx.proofs[0]
let pk = tx.proofs[1]
let requiredAmount = 100000

#извлекаем из транзакции адрес отправителя
let this = extract(tx.sender)
match tx {
   case d: DataTransaction =>
     #извлекаем дату последнего платежа
     let lastPaymentHeight = extract(getInteger(this, d.data[0].key + "_lastPayment"))
     size(d.data) == 1 && d.data[0].value == "false" && lastPaymentHeight + subscriptionPeriod < height
     ||
     (
       let address = d.data[0].key

       #извлекаем трансфер-транзакцию по ID, указанному в пруфах
       let ttx = transactionById(d.proofs[0])
       
       size(d.data) == 2
           && d.data[0].value == "true"
           && d.data[1].key == address + "_lastPayment"
           && match ttx {
             case purchase : TransferTransaction =>
               d.data[1].value == transactionHeightById(purchase.id)
               && toBase58String(purchase.sender.bytes) == address
               && purchase.amount == requiredAmount
               && purchase.recipient == this
               #убеждаемся, что ассет waves
               && !isDefined(purchase.assetId)
         case _ => false
       }
     )
   case _ => false
}

ఓటింగ్

బ్లాక్‌చెయిన్‌లో ఓటింగ్‌ను అమలు చేయడానికి స్మార్ట్ ఖాతాలను ఉపయోగించవచ్చు. అంబాసిడర్ ప్రోగ్రామ్‌లో ఉత్తమ రాయబారి నివేదిక కోసం ఓటు వేయడం ఒక ఉదాహరణ. నిర్దిష్ట ఎంపిక కోసం ఓట్లను రికార్డ్ చేయడానికి ఖాతా స్థితి వేదికగా ఉపయోగించబడుతుంది.

ఈ ఉదాహరణలో, ప్రత్యేక "ఓటింగ్" టోకెన్లను కొనుగోలు చేసిన వారికి మాత్రమే ఓటు వేయడానికి అనుమతి ఉంది. పాల్గొనేవారు జత (కీ, విలువ) = (purchaseTransactionId, buyTransactionId)తో ముందుగానే డేటా లావాదేవీని పంపుతారు. ఈ కీ కోసం మరొక విలువను సెట్ చేయడం నిషేధించబడింది. మీ చిరునామా మరియు ఓటింగ్ ఎంపికను ఉపయోగించి, మీరు ఒక్కసారి మాత్రమే డేటాఎంట్రీని సెట్ చేయవచ్చు. నిర్ణీత వ్యవధిలో మాత్రమే ఓటింగ్‌కు అవకాశం ఉంటుంది.

let asset = base58'8jfD2JBLe23XtCCSQoTx5eAW5QCU6Mbxi3r78aNQLcNf'
let address = addressFromPublicKey(tx.proofs[1])
let votingStartHeight = 2000
let votingEndHeight = 3000

#извлекаем из транзакции адрес отправителя
let this = extract(tx.sender)
 match tx {
   case t: DataTransaction =>
     (height > votingStartHeight && height < votingEndHeight) &&
     #убеждаемся, что у транзакции правильная подпись
     sigVerify(tx.bodyBytes, tx.proofs[0], tx.proofs[1]) &&

     #проверяем, что пользователь отдает свой голос напротив своего адреса
     if (t.data[0].key == toBase58String(address.bytes))
     then (
       #извлекаем транзакцию перевод голосовательного токена из пруфов
       let purchaseTx = transactionById(t.proofs[7])
       
       match purchaseTx {
         case purchase : TransferTransaction =>
           let correctSender = purchase.sender == t.sender
           let correctAsset = purchase.assetId == asset
           let correctPrice = purchase.amount == 1
           let correctProof = extract(getBinary(this, toBase58String(purchase.id))) == t.id
           correctSender && correctAsset && correctPrice && correctProof
         case _ => false
       }
     )
     else
         size(t.data) == 1 && !isDefined(getBinary(this, t.data[0].key))
   case _ => false
}

మార్పిడికి సంభంధించిన బిల్లు

ప్రామిసరీ నోట్ అనేది ఒక పక్షం డిమాండ్‌పై లేదా ముందుగా నిర్ణయించిన తేదీలో నిర్ణీత మొత్తాన్ని మరొక పక్షం చెల్లించాల్సిన వ్రాతపూర్వక బాధ్యత.

మా ఉదాహరణలో, మేము స్మార్ట్ ఖాతాను ఉపయోగిస్తాము, దాని గడువు తేదీ బిల్లు చెల్లింపు తేదీకి అనుగుణంగా ఉంటుంది.

let expiration = 100000
let amount = 10
let asset =  base58'9jfD2JBLe23XtCCSQoTx5eAW5QCU6Mbxi3r78aNQLcNf'
  
let Bob = Address(base58'3NBVqYXrapgJP9atQccdBPAgJPwHDKkh6A8')
let Alice = Address(base58'3PNX6XwMeEXaaP1rf5MCk8weYeF7z2vJZBg')
  
match tx {
    case t: TransferTransaction =>
        (t.assetId == asset)&&      
        (t.amount == amount)&&       
        (t.sender == Bob)&&
        (t.recipient == Alice)&&
        (sigVerify(t.bodyBytes, t.proofs[0], t.senderPublicKey))&&
        (height >= expiration)
    case _ => false
}

డిపాజిట్

డిపాజిట్ అంటే కొన్ని షరతులలో (పదం, వడ్డీ) బ్యాంకులో నిధులను ఉంచడం.
మా ఉదాహరణలో, బ్యాంకు యొక్క పనితీరు స్మార్ట్ ఖాతా ద్వారా నిర్వహించబడుతుంది. డిపాజిట్ కాలానికి అనుగుణంగా నిర్దిష్ట సంఖ్యలో బ్లాక్‌ల తర్వాత, వినియోగదారు వారి డబ్బును వడ్డీతో తిరిగి పొందవచ్చు. స్క్రిప్ట్ బ్లాక్ ఎత్తును నిర్దేశిస్తుంది (ఫైనల్‌హైట్), దాన్ని చేరుకున్న తర్వాత వినియోగదారు ఖాతా నుండి డబ్బును ఉపసంహరించుకోవచ్చు.

highUnit - ఒక యూనిట్ సమయంలో బ్లాక్‌ల సంఖ్య (ఉదాహరణకు, నెల, సంవత్సరం మొదలైనవి). ముందుగా మనం జత (కీ, విలువ) = (ప్రారంభ బదిలీ లావాదేవీ, ఫ్యూచర్‌డేటా ట్రాన్సాక్షన్)తో ఎంట్రీ కోసం తనిఖీ చేస్తాము. వినియోగదారు ఆ తర్వాత తప్పనిసరిగా డిపాజిట్ మొత్తం మరియు డిపాజిట్ వ్యవధికి వచ్చిన వడ్డీ గురించి సరైన సమాచారంతో బదిలీ లావాదేవీని సమర్పించాలి. ఈ సమాచారం ప్రస్తుత ట్రాన్స్‌ఫర్‌ట్రాన్సాక్షన్ ప్రూఫ్‌లో ఉన్న అసలు బదిలీ లావాదేవీకి వ్యతిరేకంగా తనిఖీ చేయబడింది. డిపాజిట్ డివైజర్ అనేది డిపాజిట్ వాటా యొక్క విలోమ సంఖ్య (డిపాజిట్ 10% వద్ద ఆమోదించబడినట్లయితే, డిపాజిట్ వాటా 0,1 మరియు డిపాజిట్ డివైజర్ = 1/0,1 = 10).

let this = extract(tx.sender)
let depositDivisor = 10
let heightUnit = 1000
let finalHeight = 100000
 match tx {
   case e : TransferTransaction =>
     #извлекаем высоту транзакции по ID транзакции в седьмом пруфе  
     let depositHeight = extract(transactionHeightById(e.proofs[7]))

     #извлекаем транзакцию депозита
     let purchaseTx = transactionById(e.proofs[7])    
     match purchaseTx {
       case deposit : TransferTransaction =>
         let correctSender = deposit.sender == e.sender
         #убеждаемся, что пользователь переводит себе корректную сумму депозита + проценты
         let correctAmount = deposit.amount + deposit.amount / depositDivisor * (height - depositHeight) / heightUnit == e.amount
         let correctProof = extract(getBinary(this, toBase58String(deposit.id))) == e.id
         correctSender && correctProof && correctAmount
       case _ => false
     }
     && finalHeight <= height 
 case _ => sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
}

ఈ సిరీస్‌లోని మూడవ మరియు చివరి కథనంలో, నిర్దిష్ట చిరునామాల కోసం స్తంభింపజేయడం మరియు లావాదేవీలను పరిమితం చేయడంతో సహా స్మార్ట్ ఆస్తుల యొక్క మరిన్ని ఉపయోగాలను మేము పరిశీలిస్తాము.

మూలం: www.habr.com