ब्लॉकचेन अक्सर केवल क्रिप्टोकरेंसी के साथ जुड़ा हुआ है, लेकिन डीएलटी तकनीक का दायरा बहुत व्यापक है। ब्लॉकचेन का उपयोग करने के लिए सबसे आशाजनक क्षेत्रों में से एक एक स्मार्ट अनुबंध है जो स्वचालित रूप से चलता है और इसे समाप्त करने वाले दलों के बीच विश्वास की आवश्यकता नहीं होती है।
RIDE - स्मार्ट कॉन्ट्रैक्ट के लिए भाषालहरों ने स्मार्ट अनुबंधों के लिए एक विशेष भाषा विकसित की है - RIDE। इसका पूरा दस्तावेज
यहां मौजूद
है । और यहाँ - हैबे
पर इस विषय पर
एक लेख ।
RIDE पर अनुबंध एक विधेय है और आउटपुट पर "सही" या "गलत" लौटाता है। तदनुसार, एक लेनदेन या तो ब्लॉकचेन को लिखा जाता है या अस्वीकार कर दिया जाता है। एक स्मार्ट अनुबंध पूरी तरह से निर्दिष्ट शर्तों की पूर्ति की गारंटी देता है। RIDE में एक अनुबंध से लेनदेन पीढ़ी वर्तमान में संभव नहीं है।
आज, लहरों के दो प्रकार हैं स्मार्ट अनुबंध: स्मार्ट खाते और स्मार्ट संपत्ति। एक स्मार्ट खाता एक नियमित उपयोगकर्ता खाता है, लेकिन इसके लिए एक स्क्रिप्ट निर्धारित की जाती है जो सभी लेनदेन को नियंत्रित करती है। एक स्मार्ट खाता स्क्रिप्ट इस तरह दिख सकती है:
match tx { case t: TransferTransaction | MassTransferTransaction => false case _ => true }
tx एक संसाधित लेनदेन है जिसे हम पैटर्न मिलान तंत्र का उपयोग करने की अनुमति केवल तभी देते हैं जब यह हस्तांतरण लेनदेन न हो। RIDE पैटर्न मिलान का उपयोग लेनदेन के प्रकार को सत्यापित करने के लिए किया जाता है। स्मार्ट खाते की स्क्रिप्ट में, सभी मौजूदा
लेनदेन प्रकार संसाधित किए जा सकते हैं।
साथ ही, स्क्रिप्ट में चर घोषित किए जा सकते हैं, "if-then-अन्यथा" कंस्ट्रक्शन और शर्तों की पूरी जाँच के लिए अन्य तरीकों का उपयोग किया जा सकता है। कॉन्ट्रैक्ट के लिए प्रोवीजन पूरा होने और जटिलता (लागत) होने की संभावना है, जो अनुबंध की शुरुआत से पहले भविष्यवाणी करना आसान है, आरआईडीई में लूप और ऑपरेटर जैसे कूद नहीं होते हैं।
लहरों के खातों की अन्य विशेषताओं में एक "राज्य" की उपस्थिति है, अर्थात्, खाते की स्थिति। डेटा लेनदेन (DataTransaction) का उपयोग करके खाते की स्थिति में अनंत संख्या में जोड़े (कुंजी, मूल्य) लिखे जा सकते हैं। इसके अलावा, इस जानकारी को REST API, और सीधे स्मार्ट अनुबंध के माध्यम से संसाधित किया जा सकता है।
प्रत्येक लेनदेन में प्रमाणों की एक सरणी हो सकती है, जिसमें आप प्रतिभागी के हस्ताक्षर, आवश्यक लेनदेन की आईडी आदि दर्ज कर सकते हैं।
आईडीई के माध्यम से RIDE के साथ काम करने से आप अनुबंध के संकलित रूप (यदि यह संकलित हैं) को देख सकते हैं, नए खाते बना सकते हैं और इसके लिए स्क्रिप्ट सेट कर सकते हैं, साथ ही कमांड लाइन के माध्यम से लेनदेन भेज सकते हैं।
एक पूर्ण चक्र के लिए, जिसमें एक खाता बनाना, उस पर एक स्मार्ट अनुबंध स्थापित करना और लेनदेन भेजना शामिल है, आप लाइब्रेरी का उपयोग REST API (उदाहरण के लिए, C #, C, Java, जावास्क्रिप्ट, पायथन, रस्ट, एलिक्सिर) के साथ बातचीत करने के लिए भी कर सकते हैं। आईडीई के साथ काम करना शुरू करने के लिए, बस नए बटन पर क्लिक करें।
स्मार्ट अनुबंधों का उपयोग करने की संभावनाएं व्यापक हैं: लेनदेन के निषेध से लेकर कुछ पते ("ब्लैक लिस्ट") से लेकर जटिल डीएपी तक।
अब आइए व्यवसाय में स्मार्ट अनुबंधों के उपयोग के विशिष्ट उदाहरण देखें: नीलामी, बीमा और वफादारी कार्यक्रम बनाने के दौरान।
नीलामीएक सफल नीलामी के लिए शर्तों में से एक पारदर्शिता है: बोलीदाताओं को यह सुनिश्चित करना चाहिए कि बोलियों में हेरफेर करना असंभव है। यह ब्लॉकचेन के लिए धन्यवाद प्राप्त किया जा सकता है, जहां सभी दांवों पर अपरिवर्तित डेटा और वे जिस समय बने थे, सभी प्रतिभागियों के लिए उपलब्ध होंगे।
लहरें ब्लॉकचेन पर, बोली को स्टेट अकाउंट अकाउंट स्टेट में डेटाट्रांसलेशन के माध्यम से रिकॉर्ड किया जा सकता है।
आप ब्लॉक संख्याओं का उपयोग करके नीलामी का आरंभ और समाप्ति समय भी निर्धारित कर सकते हैं: लहरें ब्लॉकचैन में ब्लॉक पीढ़ी की आवृत्ति लगभग
60 सेकंड है।
1. अंग्रेजी बढ़ती मूल्य नीलामीएक दूसरे के साथ प्रतिस्पर्धा करते हुए, अंग्रेजी नीलामी बोली में प्रतिभागी। प्रत्येक नई शर्त पिछले एक से अधिक होनी चाहिए। नीलामी तब समाप्त होती है जब अंतिम बोली से अधिक कोई तैयार नहीं होता है। इस मामले में, उच्चतम बोली लगाने वाले को घोषित राशि प्रदान करनी होगी।
एक नीलामी विकल्प भी है जिसमें विक्रेता लॉट के लिए न्यूनतम मूल्य निर्धारित करता है, और अंतिम मूल्य इससे अधिक होना चाहिए। नहीं तो बहुत कुछ अनकहा रह जाता है।
इस उदाहरण में, हम नीलामी के लिए विशेष रूप से बनाए गए खाते के साथ काम कर रहे हैं। नीलामी की अवधि 3000 ब्लॉक है, और बहुत की प्रारंभिक कीमत 0.001 WAVES है। एक प्रतिभागी लेन-देन के साक्ष्यों में "मूल्य" कुंजी और उसकी बोली के मूल्य के साथ एक डेटाट्रैक्शन भेजकर दांव लगा सकता है, आपको सार्वजनिक कुंजी और प्रेषक के हस्ताक्षर जोड़ने की आवश्यकता है।
इस कुंजी के लिए नए दांव की कीमत मौजूदा कीमत से अधिक होनी चाहिए, और प्रतिभागी के खाते में कम से कम [new_state + कमीशन] टोकन होना चाहिए। बोलीदाता का पता 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 pk = d.proofs[1] let address = addressFromPublicKey(pk) let priceIsBigger = newPrice > currentPrice let fee = 700000 let hasMoney = wavesBalance(address) + fee >= newPrice let correctFields = size(d.data) == 2 && extract(getString(d.data, "sender")) == toBase58String(address.bytes) startHeight <= height && height <= finishHeight && priceIsBigger && hasMoney && correctFields && sigVerify(tx.bodyBytes, tx.proofs[0], tx.proofs[1]) case o : Order => # let pk = o.proofs[1] let address = addressFromPublicKey(pk) let senderIsWinner = address == addressFromString(extract(getString(this, "sender"))) #, , let correctAssetPair = o.assetPair.amountAsset == token && ! isDefined(o.assetPair.priceAsset) let correctAmount = o.amount == 1 let correctPrice = o.price == extract(getInteger(this, "price")) height > finishHeight && senderIsWinner && correctAssetPair && correctAmount && correctPrice && sigVerify(o.bodyBytes, o.proofs[0], o.proofs[1]) 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")) # let pk = d.proofs[1] let address = addressFromPublicKey(pk) let correctFields = extract(getString(d.data, "sender")) == toBase58String(address.bytes) && size(d.data) == 2 && newPrice == currentPrice #, "sender" let noBetsBefore = !isDefined(getInteger(this, "sender")) let fee = 700000 let hasMoney = wavesBalance(address) - fee >= newPrice startHeight <= height && height <= finishHeight && noBetsBefore && hasMoney && correctFields && sigVerify(tx.bodyBytes, tx.proofs[0], tx.proofs[1]) case o : Order => # let pk = o.proofs[1] let address = addressFromPublicKey(pk) #, sender let senderIsWinner = address == addressFromString(extract(getString(this, "sender"))) #, mount , - - waves let correctAssetPair = o.assetPair.amountAsset == token && ! isDefined(o.assetPair.priceAsset) let correctAmount = o.amount == 1 let correctPrice = o.price == extract(getInteger(this, "price")) height > finishHeight && senderIsWinner && correctAssetPair && correctAmount && correctPrice && sigVerify(o.bodyBytes, o.proofs[0], o.proofs[1]) case _ => false }
3. ऑल-पे नीलामी"ऑल-पे" - एक नीलामी, जिसमें से सभी प्रतिभागी बोली का भुगतान करते हैं, भले ही वह कितना भी जीतता हो। प्रत्येक नया प्रतिभागी दांव का भुगतान करता है, और जिस प्रतिभागी ने अधिकतम शर्त लगाई है वह बहुत जीतता है।
हमारे उदाहरण में, प्रत्येक नीलामी प्रतिभागी DataTransaction (कुंजी, मूल्य) * = ("विजेता", पता), ("मूल्य", मूल्य) के माध्यम से बोली लगाता है। इस तरह के DataTransaction को तभी अनुमोदित किया जाता है जब इस प्रतिभागी के लिए पहले से ही उसके हस्ताक्षर के साथ एक TransferTransaction हो और उसकी दर पिछले सभी की तुलना में अधिक हो। नीलामी अंतिम छोर तक पहुंचने तक जारी रहती है।
let startHeight = 1000 let endHeight = 2000 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) }
बीमा / क्राउडफंडिंगऐसी स्थिति पर विचार करें जहां आपको वित्तीय नुकसान से उपयोगकर्ता परिसंपत्तियों का बीमा करने की आवश्यकता होती है। उदाहरण के लिए, उपयोगकर्ता एक गारंटी प्राप्त करना चाहता है कि यदि टोकन मूल्यह्रास करता है, तो वह इन टोकन के लिए भुगतान की गई पूरी राशि वापस करने में सक्षम होगा और बीमा की उचित राशि का भुगतान करने के लिए तैयार है।
इसे लागू करने के लिए, आपको "बीमा टोकन" जारी करने की आवश्यकता है। फिर, पॉलिसीधारक के खाते पर एक स्क्रिप्ट स्थापित की जाती है जो आपको केवल उन ExchangeTransactions को निष्पादित करने की अनुमति देती है जो कुछ शर्तों को पूरा करते हैं।
दोहरे खर्च को रोकने के लिए, आपको उपयोगकर्ता को पॉलिसीधारक खाते से पहले (कुंजी, मूल्य) = (PurchaseTransactionId, sellOrderId) के साथ डेटाट्रांसलेशन भेजने का अनुरोध करना होगा और पहले से उपयोग की जाने वाली कुंजी के साथ डेटाट्रेन भेजने पर रोक लगाना चाहिए।
इसलिए, उपयोगकर्ता के प्रमाण में बीमा टोकन की खरीद की लेनदेन आईडी होनी चाहिए। मुद्रा जोड़ी को खरीद लेनदेन के समान होना चाहिए। लागत भी खरीद के समय दर्ज की गई राशि के बराबर होनी चाहिए, जो बीमा की कीमत को घटाती है।
यह समझा जाता है कि बाद में बीमा खाता उपयोगकर्ता से बीमा टोकन को उस कीमत पर कम कर देता है, जिस मूल्य पर उसने उन्हें खरीदा है, उससे कम कीमत पर: बीमा खाता 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 o : Order => # , if !isDefined(o.proofs[7]) then sigVerify(o.bodyBytes, o.proofs[0], o.senderPublicKey) else # , let purchaseTx = transactionById(o.proofs[7]) let purchaseTxHeight = extract(transactionHeightById(o.proofs[7])) # match purchaseTx { case purchase : ExchangeTransaction => let correctSender = purchase.sender == o.sender let correctAssetPair = o.assetPair.amountAsset == insuranceToken && purchase.sellOrder.assetPair.amountAsset == insuranceToken && o.assetPair.priceAsset == purchase.sellOrder.assetPair.priceAsset let correctPrice = o.price == purchase.price - insurancePrice && o.amount == purchase.amount let correctHeight = height > purchaseTxHeight + freezePeriod #, - ID let correctProof = extract(getBinary(this, toBase58String(purchase.id))) == o.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 }
अब, हर बार जब कोई एन स्मार्ट संपत्तियों को स्थानांतरित करता है, तो वह आपको एन / टैक्सडाइवाइज़र की राशि में FeeCoin देगा (जिसे आप 10 * एन / टैक्सडिवाइज़र WAVES के लिए खरीदा जा सकता है), और आप माइनर / टैक्सडाइज़र WAVES देंगे। नतीजतन, आपका लाभ (कर) 9 * एन / करदाता 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 }
कैशबैक और लॉयल्टी प्रोग्रामकैशबैक एक प्रकार की वफादारी कार्यक्रम है जिसमें किसी उत्पाद या सेवा पर खर्च की गई राशि का एक हिस्सा खरीदार को वापस कर दिया जाता है।
स्मार्ट खाते का उपयोग करते हुए इस मामले को लागू करते समय, हमें उसी तरह से सबूतों की जांच करनी चाहिए जैसे हमने बीमा मामले में की थी। कैशबैक प्राप्त करने से पहले दोहरे खर्च को रोकने के लिए, उपयोगकर्ता को (कुंजी, मूल्य) = (buyTransactionId, cashbackTransactionId) के साथ एक डेटाट्रैक्शन भेजना होगा।
हमें DataTransaction का उपयोग करके मौजूदा कुंजियों पर भी प्रतिबंध लगाना चाहिए। कैशबैकडाइज़र - कैशबैक के हिस्से से विभाजित एक इकाई। यानी यदि कैशबैक शेयर 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 }
अगले लेख में, हम वित्तीय साधनों में स्मार्ट खातों के उपयोग पर विचार करेंगे - जैसे विकल्प, वायदा और बिल।