👩‍⚕️ 🧙🏻 👩🏾‍🎨 वित्तीय साधनों में लहरों के स्मार्ट खातों और स्मार्ट परिसंपत्तियों का उपयोग करना 👨🏾‍🤝‍👨🏽 🙋 🛵

पिछले लेख में, हमने व्यापार में स्मार्ट खातों का उपयोग करने के कई मामलों को देखा - नीलामी और वफादारी कार्यक्रमों सहित।
आज हम इस बारे में बात करेंगे कि कैसे स्मार्ट खाते और स्मार्ट संपत्ति विकल्प, वायदा और बिल जैसे वित्तीय साधनों की पारदर्शिता और विश्वसनीयता बढ़ा सकते हैं।

विकल्प

एक विकल्प एक स्टॉक एक्सचेंज अनुबंध है जो खरीदार को एक निश्चित मूल्य पर या एक निश्चित तारीख से पहले संपत्ति खरीदने का अधिकार देता है, लेकिन ऐसा करने के लिए उसे बाध्य नहीं करता है।

विकल्प का अभ्यास निम्नानुसार हो सकता है:

हम एक उपकरण के रूप में विकल्पों के लिए एक स्मार्ट संपत्ति का उपयोग करते हैं और प्रतिभागी के लिए एक स्मार्ट खाता जो विनिमय और मुद्दों के विकल्प के रूप में कार्य करता है। एक्सचेंज प्रतिभागी वादा करता है कि वह एक निश्चित संपत्ति की एक निश्चित राशि को बेचने वाला होगा। समाप्ति और समाप्ति ब्लॉक की ऊंचाइयों के बीच)।

स्मार्ट एसेट के कोड में, हम केवल यह सत्यापित करते हैं कि यह केवल संकेतित ऊंचाइयों के बीच कारोबार किया जाता है, और हम कुछ और नहीं चेक करते हैं, हम नियमों के अवलोकन के लिए सभी जिम्मेदारी छोड़ देंगे।

स्मार्ट एसेट कोड:

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

हम मानते हैं कि क्रियाएं इस प्रकार हैं: विनिमय सदस्य कुछ संपत्ति की खरीद के लिए विकल्प बेचता है, और बाकी प्रतिभागी इन विकल्पों को स्थानांतरित कर सकते हैं या उनका व्यापार कर सकते हैं। खरीद के अपने अधिकार का उपयोग करने के लिए, एक संभावित खरीदार को विक्रेता के खाते में, यानि एक्सचेंज प्रतिभागी को वांछित संख्या में विकल्प स्थानांतरित करने होंगे। फिर वह एक्सचेंज सदस्य के खाते की स्थिति में पूर्ण हस्तांतरण के बारे में जानकारी लिखता है और उसके बाद ही ExchangeTransaction खरीद और बिक्री की निर्दिष्ट शर्तों से गुजरने में सक्षम होगा।

स्मार्ट खाते के कोड में, हमें यह सुनिश्चित करना चाहिए कि अंतिम खरीद-बिक्री अधिनियम के लिए इसके माध्यम से गुजरने वाला कोई भी ExchangeTransaction निर्दिष्ट शर्तों को पूरा करता है, और प्रतिभागी ठीक उसी इकाई की संख्या खरीदता है जो उसने एक्सचेंज प्रतिभागी के खाते में भेजी थी। एक संभावित खरीदार को होने वाले हस्तांतरण के बारे में सही DataTransaction भेजना होगा, ताकि विनिमय सदस्य दोहरे खर्च से बच सकें। इस DataTransaction में, खरीदार अपने पते के बराबर एक कुंजी रखता है जो एक्सचेंज सदस्य के खाते में स्थानांतरित किए गए विकल्पों की संख्या के बराबर एक मूल्य है, यानी वह परिसंपत्ति इकाइयों की संख्या जो वह खरीद सकता है।

स्मार्ट खाता कोड:

 #         #  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 = extract(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 order : Order => #,         let correctAssetPair = order.assetPair.amountAsset == amountAsset && order.assetPair.priceAsset == priceAsset let correctPrice = order.price == sellPrice # -   let d = transactionById(order.proofs[2]) match d{ case dataTx : DataTransaction => let buyOrderSender = dataTx.data[0].key toBase58String(order.sender.bytes) == buyOrderSender && order.amount == extract(getInteger(dataTx.data, buyOrderSender)) case _ => false } && order.sender == this && correctAssetPair && correctPrice && height > expirationStart && height <= expirationEnd case _ => false }

स्मार्ट अकाउंट फ्यूचर्स

एक विकल्प के विपरीत, वायदा (वायदा अनुबंध) एक अधिकार नहीं है, लेकिन भविष्य में एक निश्चित बिंदु पर एक निश्चित मूल्य पर एक संपत्ति खरीदने के लिए एक खरीदार का दायित्व है।

सामान्य तौर पर, वायदा का कार्यान्वयन एक विकल्प के कार्यान्वयन के समान है। यहां, एक स्मार्ट संपत्ति एक वायदा के रूप में कार्य करती है।

आपको यह भी सुनिश्चित करना होगा कि खरीदार और विक्रेता दोनों खरीद आदेश पर हस्ताक्षर करें। वायदा एक दायित्व है जिसे किसी भी मामले में पूरा किया जाना चाहिए। इसका मतलब यह है कि यदि कोई विक्रेता या प्रतिभागी अपने दायित्वों से इनकार करता है, तो कोई भी नेटवर्क प्रतिभागी लेनदेन भेज सकता है, इस प्रकार वायदा को क्रियान्वित कर सकता है।

स्मार्ट एसेट स्क्रिप्ट सभी TransferTransaction और ExchangeTransaction एसेट फ्यूचर्स को नियंत्रित करता है, उन्हें केवल तभी मंजूरी देता है जब ख़रीद सदस्य ने एक्सचेंज सदस्य से एसेट फ्यूचर्स की भविष्य की खरीद के लिए एक ऑर्डर बनाया है।

यह आदेश मान्य होना चाहिए और उन शर्तों को पूरा करना चाहिए जिन पर वायदा जारी किया गया है। एक आदेश की जांच करने के लिए, आप उसके सभी क्षेत्रों को खरीदार के खाते में हस्ताक्षरित आदेश के बाइट प्रतिनिधित्व के साथ दर्ज कर सकते हैं, और फिर बाहर से मान्य कर सकते हैं।

फिलहाल, 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 हो।

साथ ही, वॉलेट में मौजूद उपयोगकर्ता के पास इस टोकन का गैर-शून्य संतुलन होना चाहिए। इसके बाद मतदान की अवधि आती है, जिसके दौरान उपयोगकर्ता अपने वॉलेट में प्रत्येक परिसंपत्ति के लिए वोट डाल सकता है, लेकिन केवल एक बार, 1 से 10. तक की रेटिंग देकर उपयोगकर्ता की आवाज़ें फॉर्म user_address + परिसंपत्ति की कुंजियों द्वारा दर्शाई जाती हैं।

 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 TransferTransaction के साथ एक स्मार्ट खाता (लेन-देन प्रमाण के माध्यम से) प्रदान करता है, तो वह खाता स्थिति में {कुंजी: पता, मूल्य: सत्य } लिख सकता है।

इसका मतलब यह होगा कि उपयोगकर्ता उत्पाद या सेवा की सदस्यता की पुष्टि करता है। जब सदस्यता समाप्त हो जाती है, तो कोई भी नेटवर्क उपयोगकर्ता स्थिति में संबंधित कुंजी को गलत पर सेट कर सकता है।

 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 }

वोट

ब्लॉकचैन पर वोटिंग को लागू करने के लिए स्मार्ट खातों का उपयोग किया जा सकता है। एक उदाहरण राजदूत कार्यक्रम के ढांचे के भीतर सर्वश्रेष्ठ राजदूत रिपोर्ट के लिए एक वोट होगा। खाता स्थिति का उपयोग एक या दूसरे विकल्प के लिए वोट रिकॉर्ड करने के लिए एक मंच के रूप में किया जाता है।

इस उदाहरण में, वोटिंग की अनुमति केवल उन्हीं को दी जाती है, जिन्होंने विशेष "वोटिंग" टोकन खरीदे हैं। प्रतिभागी (की, वैल्यू) = (buyTransactionId, buyTransactionId) की एक जोड़ी के साथ पहले से एक DataTransaction भेजता है। इस कुंजी के लिए एक अलग मान सेट करना निषिद्ध है। अपने पते और मतदान विकल्प का उपयोग करके, आप केवल एक बार DataEntry स्थापित कर सकते हैं। स्थापित अवधि के दौरान ही मतदान संभव है।

 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 }

जमा

जमा - कुछ शर्तों (अवधि, प्रतिशत) पर एक बैंक में धन की नियुक्ति।
हमारे उदाहरण में, बैंक का कार्य एक स्मार्ट खाते द्वारा किया जाता है। ब्लॉकों की एक निश्चित संख्या के बाद, जो जमा की अवधि से मेल खाती है, उपयोगकर्ता प्रतिशत के साथ अपने पैसे वापस कर सकता है। स्क्रिप्ट ब्लॉक (अंतिम ऊंचाई) की ऊंचाई निर्धारित करती है, जिसके बाद उपयोगकर्ता खाते से पैसे निकाल सकता है।

heightUnit - समय की एक इकाई में ब्लॉकों की संख्या (उदाहरण के लिए, महीने, वर्ष, आदि)। सबसे पहले, हम एक जोड़ी (कुंजी, मूल्य) = (initialTransferTransaction, FutureDataTransaction) के साथ एक प्रविष्टि की जांच करते हैं। फिर, उपयोगकर्ता को जमा की राशि और जमा की अवधि के लिए अर्जित ब्याज के बारे में सही जानकारी के साथ TransferTransaction भेजना होगा। इस जानकारी को वर्तमान TransferTransaction सबूत में निहित मूल TransferTransaction के खिलाफ जाँच की जाती है। डिपॉज़िटवाइज़र डिपॉज़िट के शेयर के विपरीत संख्या है (यदि डिपॉज़िट 10% पर स्वीकार किया जाता है, तो डिपॉज़िट का हिस्सा 0.1 है, और डिपॉज़िटवाइज़र = 1 / 0.1 = 10)।

 let depositDivisor = 10 let heightUnit = 1000 let finalHeight = 100000 let this = extract(tx.sender) 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) }

इस श्रृंखला के तीसरे और अंतिम लेख में, हम स्मार्ट संपत्ति का उपयोग करने के लिए अधिक विकल्पों पर ध्यान देंगे, जिसमें विशिष्ट पते के लिए लेनदेन को रोकना और प्रतिबंधित करना शामिल है।

वित्तीय साधनों में लहरों के स्मार्ट खातों और स्मार्ट परिसंपत्तियों का उपयोग करना

More articles: