हाइपरलेगर फैब्रिक (HLF) एक ओपन सोर्स प्लेटफ़ॉर्म है जो डिस्ट्रिब्यूटेड लेज़र टेक्नोलॉजी (DLT) का उपयोग करता है, जो उन अनुप्रयोगों को विकसित करने के लिए डिज़ाइन किया गया है जो एक्सेस रूल्स (अनुमति) का उपयोग करके संगठनों के एक कंसोर्टियम द्वारा निर्मित और नियंत्रित नेटवर्क नेटवर्क वातावरण में काम करते हैं।

प्लेटफ़ॉर्म एचएलएफ शब्दों में स्मार्ट कॉन्ट्रैक्ट्स का समर्थन करता है - गोलंग, जावास्क्रिप्ट, जावा, जैसी सामान्य भाषाओं में बनाए गए चेन कोड, उदाहरण के लिए, एथेरियम, जो एक अनुबंध-उन्मुख, सीमित कार्यक्षमता का उपयोग करता है (एलएलएल, वाइपर, आदि)।

ब्लॉक कोडीन नेटवर्क के घटकों की एक महत्वपूर्ण संख्या को तैनात करने की आवश्यकता के कारण श्रृंखला कोड का विकास और परीक्षण, परीक्षण परिवर्तनों पर खर्च किए गए उच्च समय के साथ एक लंबी प्रक्रिया हो सकती है। यह आलेख CCKit लाइब्रेरी का उपयोग करते हुए HLF गोलंग स्मार्ट कॉन्ट्रैक्ट्स के तेजी से विकास और परीक्षण के दृष्टिकोण पर चर्चा करता है।

एचएलएफ आधारित आवेदन

डेवलपर के दृष्टिकोण से, ब्लॉकचेन एप्लिकेशन में दो मुख्य भाग होते हैं:

• ऑन-चेन - स्मार्ट कॉन्ट्रैक्ट्स (प्रोग्राम) ब्लॉकचेन नेटवर्क के एक अलग-थलग वातावरण में चल रहे हैं जो लेन-देन की विशेषताओं को बनाने और बनाने के नियमों को निर्धारित करते हैं। एक स्मार्ट अनुबंध में, मुख्य क्रियाएं ब्लॉकचैन नेटवर्क की स्थिति से डेटा को पढ़ रही हैं, अपडेट कर रही हैं और हटा रही हैं। इस बात पर जोर दिया जाना चाहिए कि राज्य से डेटा हटाने से यह जानकारी निकल जाती है कि यह डेटा मौजूद था।
• ऑफ-चेन एक एप्लिकेशन है (उदाहरण के लिए, एक एपीआई) जो एसडीके के माध्यम से ब्लॉकचेन पर्यावरण के साथ बातचीत करता है। इंटरैक्शन को स्मार्ट कॉन्ट्रैक्ट फ़ंक्शंस को कॉल करने और स्मार्ट कॉन्ट्रैक्ट इवेंट्स की निगरानी के रूप में समझा जाता है - बाहरी ईवेंट्स स्मार्ट कॉन्ट्रैक्ट में डेटा परिवर्तन का कारण बन सकते हैं, जबकि स्मार्ट कॉन्ट्रैक्ट में ईवेंट बाहरी सिस्टम में क्रियाओं को ट्रिगर कर सकते हैं।

डेटा आमतौर पर "होम" ब्लॉकचैन नेटवर्क नोड के माध्यम से पढ़ा जाता है। डेटा रिकॉर्ड करने के लिए, एप्लिकेशन किसी विशेष स्मार्ट अनुबंध के "अनुमोदन नीति" में भाग लेने वाले संगठनों के नोड्स को अनुरोध भेजता है।

ऑफ-चेन कोड (एपीआई, आदि) को विकसित करने के लिए, एक विशेष एसडीके का उपयोग किया जाता है जो ब्लॉकचेन नोड्स के साथ बातचीत को संप्रेषित करता है, प्रतिक्रियाएं एकत्रित करता है, आदि। HLF के लिए, गो ( 1 , 2 ), Node.Js और Java के लिए SDK कार्यान्वयन हैं

हाइपरलेगर फैब्रिक कंपोनेंट्स

चैनल

एक चैनल नोड्स का एक अलग सबनेट है जो एक पृथक ब्लॉक चेन (लेजर) का समर्थन करता है, साथ ही साथ स्मार्ट कॉन्ट्रैक्ट को संचालित करने के लिए उपयोग की जाने वाली ब्लॉक चेन ( वर्ल्ड स्टेट ) की वर्तमान स्थिति (की-वैल्यू) भी है। एक मेजबान के पास चैनलों की एक मनमानी संख्या तक पहुंच हो सकती है।

लेन-देन

हाइपरलेगर फैब्रिक में लेन-देन एक ब्लॉक श्रृंखला की स्थिति का एक परमाणु अद्यतन है, जो चिनकोड विधि के निष्पादन का परिणाम है। लेन-देन में कॉल नोड द्वारा हस्ताक्षरित कुछ तर्कों (लेनदेन प्रस्ताव) के साथ चैंकोड विधि को कॉल करने का अनुरोध शामिल है और नोड्स से प्रतिक्रियाओं का एक सेट (लेनदेन प्रस्ताव प्रतिक्रिया) है, जिस पर लेनदेन "पुष्टि" (समर्थन) किया गया था। प्रतिक्रियाओं में रीड-राइट सेट ब्लॉक श्रृंखला की स्थिति के बदलते मूल्य-मूल्य जोड़े और सेवा की जानकारी (लेन-देन की पुष्टि करने वाले नोड्स के हस्ताक्षर और प्रमाण पत्र) शामिल हैं। क्योंकि व्यक्तिगत चैनलों की ब्लॉक चेन शारीरिक रूप से अलग हो जाती है, एक लेनदेन केवल एक चैनल के संदर्भ में किया जा सकता है।

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

हाइपरलेगर फैब्रिक एक लेनदेन निष्पादन और वितरण वास्तुकला का उपयोग करता है जिसमें 3 मुख्य ऑपरेशन होते हैं:

• निष्पादन ( निष्पादित ) - एक या कई नेटवर्क नोड्स पर चल रहे एक स्मार्ट अनुबंध द्वारा निर्माण, लेनदेन - एक वितरित रजिस्ट्री की स्थिति में परमाणु परिवर्तन ( समर्थन )

  
  

• ऑर्डरिंग - एक सुगमनीय सर्वसम्मति एल्गोरिथ्म का उपयोग करके विशेष ऑर्डरर सेवा द्वारा ब्लॉकों में लेनदेन का आदेश देना और समूहीकृत करना।

  
  

• मान्य - वितरित रजिस्ट्री की उनकी प्रति में उनसे जानकारी रखने से पहले आदेशकर्ता से आने वाले लेनदेन के नेटवर्क नोड द्वारा सत्यापन

  
  

यह दृष्टिकोण आपको ब्लॉकचेन नेटवर्क में प्रवेश करने से पहले लेनदेन निष्पादन चरण को पूरा करने की अनुमति देता है, साथ ही साथ नेटवर्क नोड्स के संचालन को क्षैतिज रूप से मापता है।

Cheynkod

एक चैंकोड, जिसे स्मार्ट कॉन्ट्रैक्ट भी कहा जा सकता है, एक कार्यक्रम है जो गोलंग, जावास्क्रिप्ट (एचएलएफ 1.1+) या जावा (एचएलएफ 1.3+) में लिखा गया है, जो एक ब्लॉक श्रृंखला की स्थिति को बदलने वाले लेनदेन बनाने के नियमों को परिभाषित करता है। कार्यक्रम को ब्लॉकचेन नोड्स के वितरित नेटवर्क के कई स्वतंत्र नोड्स पर एक साथ निष्पादित किया जाता है, जो लेनदेन के "पुष्टि" के लिए आवश्यक सभी नोड्स पर कार्यक्रम के परिणामों को सामंजस्य करके स्मार्ट अनुबंधों के निष्पादन के लिए एक तटस्थ वातावरण बनाता है।

कोड को एक इंटरफ़ेस लागू करना चाहिए जिसमें विधियाँ शामिल हों:

type Chaincode interface { // Init is called during Instantiate transaction Init(stub ChaincodeStubInterface) pb.Response // Invoke is called to update or query the ledger Invoke(stub ChaincodeStubInterface) pb.Response } 

• इनिट विधि को कोडोड के तात्कालिकता या उन्नयन पर कहा जाता है। यह विधि कोडकोड की स्थिति के लिए आवश्यक आरंभ करती है। यह विधि कोड में अंतर करना महत्वपूर्ण है कि क्या कॉल एक तात्कालिकता या एक अपग्रेड है, ताकि गलती से आप उस डेटा को इनिशियलाइज़ (रीसेट) न करें जो पहले से ही कोडेक के संचालन के दौरान एक गैर-शून्य स्थिति प्राप्त करता है।
• कोडेक विधि के किसी भी फ़ंक्शन तक पहुंचने पर इनवोक विधि को कहा जाता है। यह विधि स्मार्ट अनुबंध की स्थिति के साथ काम करती है।

ब्लॉकचैन नेटवर्क के साथियों पर चिनकोड स्थापित किया गया है। सिस्टम स्तर पर, कोड का प्रत्येक उदाहरण एक विशिष्ट नेटवर्क नोड से जुड़े एक अलग डॉकटर-कंटेनर से मेल खाता है, जो कोड के निष्पादन के लिए प्रेषण कॉल करता है।
Ethereum स्मार्ट कॉन्ट्रैक्ट के विपरीत, चैनिंग लॉजिक को अपडेट किया जा सकता है, लेकिन इसके लिए यह आवश्यक है कि कोडकोड को होस्ट करने वाले सभी नोड्स एक अपडेटेड वर्जन इंस्टॉल करें।

एसडीके के माध्यम से बाहर से चिनकोड फ़ंक्शन को कॉल करने के जवाब में, चिनकोड ब्लॉक चेन ( रीड-राइट सेट ) की स्थिति, साथ ही साथ घटनाओं में भी बदलाव करता है। एक चैंकोड एक विशिष्ट चैनल को संदर्भित करता है और केवल एक चैनल में डेटा बदल सकता है। उसी समय, यदि होस्ट जिस पर कोड स्थापित है, अन्य चैनलों तक भी पहुंच है, कोड के तर्क में इन चैनलों से डेटा पढ़ सकते हैं।

ब्लॉकचेन नेटवर्क के संचालन के विभिन्न पहलुओं के प्रबंधन के लिए विशेष चेन कोड को सिस्टम चेन कोड कहा जाता है।

समर्थन नीति

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

अनुमोदन नीति का निर्धारण कोड के तत्काल या उन्नयन के समय किया जाता है। संस्करण 1.3 में, न केवल चिनकोड के स्तर पर, बल्कि व्यक्तिगत राज्य-आधारित बेचान कुंजी के स्तर पर नीतियां निर्धारित करना संभव हो गया। अनुमोदन नीतियों के उदाहरण:

• नोड्स ए, बी, सी, डी
• अधिकांश चैनल नोड्स
• ए, बी, सी, डी, ई, एफ से कम से कम 3 नोड्स

घटना

एक घटना एक नामित डेटा सेट है जो आपको ब्लॉकचैन श्रृंखला की स्थिति का "अपडेट फीड" प्रकाशित करने की अनुमति देता है। घटना विशेषताओं का सेट चैंकोड को परिभाषित करता है।

नेटवर्क का बुनियादी ढांचा

मेजबान (सहकर्मी)

एक मेजबान चैनलों की एक मनमानी संख्या से जुड़ा हुआ है जिसके लिए उसके पास अधिकार हैं। मेजबान ब्लॉक श्रृंखला और ब्लॉक श्रृंखला की स्थिति के अपने संस्करण को बनाए रखता है, और श्रृंखला कोड चलाने के लिए एक वातावरण भी प्रदान करता है। यदि मेजबान अनुमोदन नीति का हिस्सा नहीं है, तो उसे चेन कोड के साथ स्थापित करने की आवश्यकता नहीं है।

होस्ट सॉफ़्टवेयर स्तर पर, ब्लॉक श्रृंखला (विश्व स्थिति) की वर्तमान स्थिति को LevelDB या CouchDB में संग्रहीत किया जा सकता है। CouchDB का लाभ MongoDB सिंटैक्स का उपयोग करके समृद्ध प्रश्नों के लिए इसका समर्थन है।

Orderer

लेनदेन प्रबंधन सेवा हस्ताक्षरित लेनदेन को एक इनपुट के रूप में स्वीकार करती है और सुनिश्चित करती है कि लेनदेन सही क्रम में नेटवर्क नोड्स में वितरित किए जाते हैं।

आदेश देने वाला स्मार्ट कॉन्ट्रैक्ट नहीं चलाता है और इसमें ब्लॉक चेन और ब्लॉक चेन स्टेट्स नहीं होते हैं। फिलहाल (1.3) आदेशकर्ता के दो कार्यान्वयन हैं - एक विकास एकल और काफ्का पर आधारित एक संस्करण जो दुर्घटना दोष सहिष्णुता प्रदान करता है। 2018 के अंत में प्रतिभागियों के एक निश्चित अंश (बीजान्टिन गलती सहिष्णुता) के गलत व्यवहार के प्रतिरोध का समर्थन करने वाले आदेश का कार्यान्वयन अपेक्षित है।

पहचान सेवाएँ

एक हाइपरलेगर फैब्रिक नेटवर्क में, सभी सदस्यों की पहचान अन्य सदस्यों (पहचान) से होती है। पहचान के लिए, सार्वजनिक कुंजी अवसंरचना (PKI) का उपयोग किया जाता है, जिसके माध्यम से संगठनों, अवसंरचना तत्वों (नोड, ऑर्डरर), अनुप्रयोगों और अंतिम उपयोगकर्ताओं के लिए X.509 प्रमाणपत्र बनाए जाते हैं। नतीजतन, डेटा को पढ़ने और संशोधित करने के लिए नेटवर्क स्तर पर, एक चैनल पर या एक स्मार्ट अनुबंध के तर्क में पहुंच नियमों द्वारा नियंत्रित किया जा सकता है। एक ही ब्लॉकचेन नेटवर्क में, विभिन्न प्रकार की कई पहचान सेवाएं एक साथ काम कर सकती हैं।

कोडेक के कार्यान्वयन

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

 type ChaincodeStubInterface interface { // GetArgs returns the arguments intended for the chaincode Init and Invoke GetArgs() [][]byte // InvokeChaincode locally calls the specified chaincode InvokeChaincode(chaincodeName string, args [][]byte, channel string) pb.Response // GetState returns the value of the specified `key` from the ledger. GetState(key string) ([]byte, error) // PutState puts the specified `key` and `value` into the transaction's writeset as a data-write proposal. PutState(key string, value []byte) error // DelState records the specified `key` to be deleted in the writeset of the transaction proposal. DelState(key string) error // GetStateByRange returns a range iterator over a set of keys in the ledger. GetStateByRange(startKey, endKey string) (StateQueryIteratorInterface, error) // CreateCompositeKey combines the given `attributes` to form a composite key. CreateCompositeKey(objectType string, attributes []string) (string, error) // GetCreator returns `SignatureHeader.Creator` (eg an identity of the agent (or user) submitting the transaction. GetCreator() ([]byte, error) // and many more methods } 

एथेरियम स्मार्ट कॉन्ट्रैक्ट में सोलिडिटी पर विकसित हुआ, प्रत्येक विधि का एक सार्वजनिक कार्य है। Init और Invoke तरीके के हाइपरलेगर फैब्रिक चिनकोड में ChaincodeStubInterface फ़ंक्शन का उपयोग किया जाता है। GetArgs (), आप बाइट सरणियों की एक सरणी के रूप में फ़ंक्शन कॉल की दलीलें प्राप्त कर सकते हैं, जबकि कॉल करते समय सरणी के पहले तत्व में चैंकोड फ़ंक्शन का नाम शामिल है। क्योंकि किसी भी चिनकोड विधि का आह्वान चालान विधि से होकर गुजरता है; हम कह सकते हैं कि यह फ्रंट कंट्रोलर पैटर्न का कार्यान्वयन है।

उदाहरण के लिए, यदि हम ERC-20 टोकन के लिए मानक Ethereum इंटरफ़ेस के कार्यान्वयन पर विचार करते हैं, तो स्मार्ट अनुबंध को विधियों को लागू करना चाहिए:

• कुल मिलाकर ()
• balanceOf (पता _owner)
• स्थानांतरण (पता _to, uint256 _value)

और अन्य। एचएलएफ कार्यान्वयन के मामले में, इनवोक फ़ंक्शन कोड उन मामलों को संभालने में सक्षम होना चाहिए जहां कॉल करने के लिए पहला तर्क अपेक्षित विधियों (उदाहरण के लिए, "कुल मिलाकर" या "बैलेंसऑफ") का नाम है। ईआरसी -20 मानक के कार्यान्वयन का एक उदाहरण यहां देखा जा सकता है ।

चैंकोडे उदाहरण

हाइपरलेगर फैब्रिक डॉक्यूमेंटेशन के अलावा, चेन कोड के कुछ और उदाहरण हैं:

• ब्लॉकचेन बीमा ऐप (2018)
• पत्थर
• कार-लीज-डेमो (2017) एस

इन उदाहरणों में श्रृंखला कोडों के कार्यान्वयन की जगह क्रिया है और इसमें रूटिंग कार्यों को चुनने के लिए बहुत से दोहराए जाने वाले तर्क शामिल हैं), तर्कों की संख्या की जांच करना, json marshalling / unmarshalling:

 func (t *SimpleChaincode) Invoke(stub shim.ChaincodeStubInterface) pb.Response { function, args := stub.GetFunctionAndParameters() fmt.Println("invoke is running " + function) // Handle different functions if function == "initMarble" { //create a new marble return t.initMarble(stub, args) } else if function == "transferMarble" { //change owner of a specific marble return t.transferMarble(stub, args) } else if function == "readMarble" { //read a marble return t.readMarble(stub, args) } else ... 

कोड का ऐसा संगठन कोड की पठनीयता में गिरावट और संभावित त्रुटियों की ओर जाता है, जैसे कि यह , जब आप इनपुट डेटा को अनमर्श करना भूल गए। एचएलएफ विकास योजनाओं के बारे में प्रस्तुतिकरण श्रृंखला कोड के विकास के दृष्टिकोण का एक संशोधन का उल्लेख करते हैं, विशेष रूप से जावा श्रृंखला कोड में एनोटेशन की शुरूआत, आदि, हालांकि, योजनाएं केवल 2019 में अपेक्षित संस्करण से संबंधित हैं। स्मार्ट कॉन्ट्रैक्ट्स को विकसित करने के अनुभव ने निष्कर्ष निकाला है कि यदि आप एक अलग लाइब्रेरी में बुनियादी कार्यक्षमता का चयन करते हैं तो चेन कोड विकसित करना और परीक्षण करना आसान होगा।

CCKit - श्रृंखला कोड विकसित करने और परीक्षण करने के लिए एक पुस्तकालय

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

स्मार्ट कॉन्ट्रैक्ट फ़ंक्शंस को रूट करना

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

स्मार्ट कॉन्ट्रैक्ट्स के नवीनतम उदाहरणों में, उदाहरण के लिए, इंश्योरेंस ऐप में , यह चैंकोड फ़ंक्शन के नाम और फॉर्म के गोलंग कोड में फ़ंक्शन के बीच मैपिंग का उपयोग करता है:

 var bcFunctions = map[string]func(shim.ChaincodeStubInterface, []string) pb.Response{ // Insurance Peer "contract_type_ls": listContractTypes, "contract_type_create": createContractType, ... "theft_claim_process": processTheftClaim, } 

CCKit राउटर http राउटर के समान एक दृष्टिकोण का उपयोग करता है, साथ ही साथ चिनकोड फ़ंक्शन और मिडलवेयर फ़ंक्शंस के लिए अनुरोध संदर्भ का उपयोग करने की क्षमता

कोड के फ़ंक्शन के लिए कॉल का संदर्भ

Http अनुरोध संदर्भ के समान, जिसमें आमतौर पर http अनुरोध पैरामीटर तक पहुंच होती है, CCKit राउटर कॉल के संदर्भ का उपयोग स्मार्ट अनुबंध फ़ंक्शन के लिए करता है, जो कि shim.ChaincodeStubInterface के शीर्ष पर एक अमूर्त है। संदर्भ चेनिंग फ़ंक्शन के हैंडलर के लिए एकमात्र तर्क हो सकता है; इसके माध्यम से, हैंडलर फ़ंक्शन कॉल के तर्क प्राप्त कर सकता है, साथ ही स्मार्ट कॉन्ट्रैक्ट (राज्य) की स्थिति के साथ काम करने के लिए सहायक क्रियाओं तक पहुंच प्राप्त कर सकता है, उत्तर (रिस्पांस) बना सकता है, आदि।

 Context interface { Stub() shim.ChaincodeStubInterface Client() (cid.ClientIdentity, error) Response() Response Logger() *shim.ChaincodeLogger Path() string State() State Time() (time.Time, error) Args() InterfaceMap Arg(string) interface{} ArgString(string) string ArgBytes(string) []byte SetArg(string, interface{}) Get(string) interface{} Set(string, interface{}) SetEvent(string, interface{}) error } 

क्योंकि प्रसंग एक इंटरफ़ेस है, कुछ श्रृंखला कोडों में इसका विस्तार किया जा सकता है।

मिडलवेयर फ़ंक्शंस

इंटरमीडिएट प्रोसेसिंग के कार्य (मिडलवेयर) को कोड की विधि के हैंडलर के कॉल से पहले कॉल किया जाता है, कॉल के संदर्भ में कोड के तरीके और अगले इंटरमीडिएट फ़ंक्शन तक या सीधे अगले (अगले) की विधि के हैंडलर तक पहुंच जाता है। Middleware के लिए इस्तेमाल किया जा सकता है:

• धर्मान्तरित इनपुट डेटा (उदाहरण में p.String और p.Struct नीचे मिडलवेयर हैं)
• फ़ंक्शन तक पहुंच पर प्रतिबंध (उदाहरण के लिए, मालिक। केवल )
• अनुरोध प्रसंस्करण चक्र का पूरा होना
• स्टैक से अगले मध्यवर्ती प्रसंस्करण फ़ंक्शन को कॉल करना

डेटा संरचना रूपांतरण

चैनकोड इंटरफ़ेस मानता है कि बाइट सरणियों की एक सरणी इनपुट को आपूर्ति की जाती है, जिनके प्रत्येक तत्व चिनकोड फ़ंक्शन का एक गुण है। चेनिंग फ़ंक्शन के प्रत्येक हैंडलर में फ़ंक्शन कॉल तर्कों से बाइट सरणी से गोलंग डेटा प्रकार (इंट, स्ट्रिंग, संरचना, सरणी) के मैनुअल डेटा को रोकने के लिए, रूटिंग नियम बनाए जाने पर अपेक्षित डेटा प्रकार CCitit राउटर में सेट किए जाते हैं और प्रकार स्वचालित रूप से परिवर्तित हो जाता है। । निम्न उदाहरण में, carGet फ़ंक्शन स्ट्रिंग प्रकार के तर्क की अपेक्षा करता है, और carRegister फ़ंक्शन एक CarPayload संरचना की अपेक्षा करता है । तर्क का नाम भी दिया गया है, जो हैंडलर को नाम से संदर्भ से अपना मूल्य प्राप्त करने की अनुमति देता है। एक हैंडलर का एक उदाहरण नीचे दिया जाएगा। रद्दी डेटा योजना का वर्णन करने के लिए प्रोटोबॉफ़ का भी उपयोग किया जा सकता है।

 r.Group(`car`). Query(`List`, cars). // chain code method name is carList Query(`Get`, car, p.String(`id`)). // chain code method name is carGet, method has 1 string argument "id" Invoke(`Register`, carRegister, p.Struct(`car`, &CarPayload{}), // 1 struct argument owner.Only) // allow access to method only for chaincode owner (authority) 

इसके अलावा, स्वचालित रूपांतरण (मार्शेलिंग) का उपयोग स्मार्ट अनुबंध की स्थिति में डेटा लिखते समय और घटनाओं को बनाते समय (गोलंग प्रकार बाइट्स की एक श्रृंखला में क्रमबद्ध किया जाता है)

डिबगिंग और लॉगिंग चेन कोड के लिए उपकरण

कोड को डीबग करने के लिए, आप डिबग एक्सटेंशन का उपयोग कर सकते हैं, जो स्मार्ट अनुबंध विधियों को लागू करता है जो आपको स्मार्ट अनुबंध की स्थिति में कुंजी की उपस्थिति के लिए निरीक्षण करने की अनुमति देगा, साथ ही कुंजी द्वारा मूल्य को सीधे पढ़ / बदल / हटा सकता है।

कॉलकोड फ़ंक्शन के लिए कॉल के संदर्भ में लॉगिंग के लिए, लॉग () विधि का उपयोग किया जा सकता है, जो एचएलएफ में उपयोग किए गए लॉगर का एक उदाहरण देता है।

स्मार्ट कॉन्ट्रैक्ट मेथड्स कंट्रोल के तरीकों को एक्सेस करते हैं

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

स्मार्ट अनुबंध परीक्षण उपकरण

ब्लॉकचैन नेटवर्क को तैनात करना, चेन कोड को स्थापित करना और आरंभ करना एक जटिल प्रक्रिया और एक लंबी प्रक्रिया है। स्मार्ट कॉन्ट्रैक्ट कोड को फिर से स्थापित / अपग्रेड करने का समय स्मार्ट कॉन्ट्रैक्ट के DEV मोड का उपयोग करके कम किया जा सकता है, हालाँकि, कोड को अपडेट करने की प्रक्रिया अभी भी धीमी होगी।

शिम पैकेज में मॉकस्टब का कार्यान्वयन शामिल है, जो कोड के लिए कॉल को लपेटता है, एचएलएफ ब्लॉकचेन वातावरण में इसके संचालन का अनुकरण करता है। MockStub का उपयोग करने से आप परीक्षा परिणाम लगभग तुरंत प्राप्त कर सकते हैं और आपको विकास का समय कम करने की अनुमति देता है। अगर हम HLF में कोड के संचालन की सामान्य योजना पर विचार करते हैं, तो MockStub अनिवार्य रूप से SDK को बदल देता है, जिससे आप कोड के कार्यों के लिए कॉल कर सकते हैं, और होस्ट पर कोड के स्टार्टअप वातावरण का अनुकरण कर सकते हैं।

HLF डिलीवरी से MockStub में shim.ChaincodeStubInterface इंटरफ़ेस के लगभग सभी तरीकों का कार्यान्वयन शामिल है, हालांकि, वर्तमान संस्करण (1.3) में, इसमें कुछ महत्वपूर्ण विधियों जैसे कि GetCoror का कार्यान्वयन नहीं है। क्योंकि चैन कोड अभिगम नियंत्रण के लिए लेन-देन निर्माता का प्रमाण पत्र प्राप्त करने के लिए इस पद्धति का उपयोग कर सकता है, परीक्षणों में अधिकतम कवरेज के लिए, इस विधि का स्टब करने की क्षमता महत्वपूर्ण है।

CCKit लाइब्रेरी में MockStub का एक विस्तारित संस्करण है, जिसमें लापता तरीकों का कार्यान्वयन, साथ ही साथ इवेंट चैनलों के साथ काम करने के तरीके आदि शामिल हैं।

चैनकोड उदाहरण

उदाहरण के लिए, आइए पंजीकृत कारों के बारे में जानकारी संग्रहीत करने के लिए एक सरल चैंकोड बनाएं

डेटा मॉडल

कोडेक्स की स्थिति कुंजी-मूल्य भंडारण है, जिसमें कुंजी एक स्ट्रिंग है, मान बाइट्स की एक सरणी है। बुनियादी अभ्यास मानों के रूप में जोनलाइज़्ड गोलंग डेटा संरचनाओं के उदाहरणों को संग्रहीत करना है। तदनुसार, चिनकोड में डेटा के साथ काम करने के लिए, राज्य से पढ़ने के बाद, आपको बाइट सरणी को अनमर्श करना होगा।

कार के बारे में रिकॉर्ड करने के लिए, हम निम्नलिखित विशेषताओं का उपयोग करेंगे:

• पहचानकर्ता (कार नंबर)
• कार का मॉडल
• वाहन मालिक की जानकारी
• डेटा परिवर्तन समय की जानकारी

 // Car struct for chaincode state type Car struct { Id string Title string Owner string UpdatedAt time.Time // set by chaincode method } 

चैंकोड करने के लिए डेटा स्थानांतरित करने के लिए, एक अलग संरचना बनाएं जिसमें केवल चिनकोड के बाहर से आने वाले क्षेत्र हैं:

 // CarPayload chaincode method argument type CarPayload struct { Id string Title string Owner string } 

चाबी से काम करें

स्मार्ट कॉन्ट्रैक्ट स्टेट में रिकॉर्ड कीज़ एक स्ट्रिंग है। यह समग्र कुंजी बनाने की क्षमता का भी समर्थन करता है जिसमें कुंजी के कुछ हिस्सों को एक शून्य बाइट ( यू + 0000 ) द्वारा अलग किया जाता है

 func CreateCompositeKey(objectType string, attributes []string) (string, error) 

CCKit में, एक स्मार्ट अनुबंध की स्थिति के साथ काम करने के कार्य स्वचालित रूप से रिकॉर्ड के लिए कुंजी बना सकते हैं यदि हस्तांतरित संरचनाएं कीपर इंटरफ़ेस का समर्थन करती हैं

 // Keyer interface for entity containing logic of its key creation type Keyer interface { Key() ([]string, error) } 

एक कार रिकॉर्ड करने के लिए, मुख्य पीढ़ी का कार्य निम्नानुसार होगा:

 const CarEntity = `CAR` // Key for car entry in chaincode state func (c Car) Key() ([]string, error) { return []string{CarEntity, c.Id}, nil } 

स्मार्ट अनुबंध समारोह घोषणा (मार्ग)

चिनकोड के निर्माता विधि में, हम चैंकोड के कार्यों और उनके तर्कों को परिभाषित कर सकते हैं। कार पंजीकरण कोड में 3 कार्य होंगे

• कारलिस्ट, कार संरचनाओं की एक सरणी देता है
• कारगेट, एक कार पहचानकर्ता को स्वीकार करता है और एक कार संरचना देता है
• carRegister, CarPayload संरचना का क्रमबद्ध उदाहरण स्वीकार करता है और पंजीकरण परिणाम देता है। इस पद्धति तक पहुंच केवल चैंकोड के मालिक के लिए संभव है, जिसे मालिक पैकेज से मिडलवेयर का उपयोग करके बचाया जाता है

 func New() *router.Chaincode { r := router.New(`cars`) // also initialized logger with "cars" prefix r.Init(invokeInit) r.Group(`car`). Query(`List`, queryCars). // chain code method name is carList Query(`Get`, queryCar, p.String(`id`)). // chain code method name is carGet, method has 1 string argument "id" Invoke(`Register`, invokeCarRegister, p.Struct(`car`, &CarPayload{}), // 1 struct argument owner.Only) // allow access to method only for chaincode owner (authority) return router.NewChaincode(r) } 

ऊपर दिया गया उदाहरण चैनकोड संरचना का उपयोग करता है जिसमें इनिट और इनवोक विधियों का प्रसंस्करण राउटर के लिए सौंपा गया है:

 package router import ( "github.com/hyperledger/fabric/core/chaincode/shim" "github.com/hyperledger/fabric/protos/peer" ) // Chaincode default chaincode implementation with router type Chaincode struct { router *Group } // NewChaincode new default chaincode implementation func NewChaincode(r *Group) *Chaincode { return &Chaincode{r} } //======== Base methods ==================================== // // Init initializes chain code - sets chaincode "owner" func (cc *Chaincode) Init(stub shim.ChaincodeStubInterface) peer.Response { // delegate handling to router return cc.router.HandleInit(stub) } // Invoke - entry point for chain code invocations func (cc *Chaincode) Invoke(stub shim.ChaincodeStubInterface) peer.Response { // delegate handling to router return cc.router.Handle(stub) } 

एक राउटर और बुनियादी चिनकोड संरचना का उपयोग करने से हैंडलर फ़ंक्शन का पुन: उपयोग होता है। उदाहरण के लिए, carRegister फंक्शन तक पहुँच की जाँच के बिना चैंकोड लागू करने के लिए, carRegister एक नया कंस्ट्रक्टर विधि बनाने के लिए पर्याप्त होगा

एक स्मार्ट अनुबंध के कार्यों का कार्यान्वयन

गोलांग कार्य - CCKit राउटर में स्मार्ट कॉन्ट्रैक्ट फंक्शन हैंडलर तीन प्रकार के हो सकते हैं:

• StubHandlerFunc - मानक हैंडलर इंटरफ़ेस, shim.ChaincodeStubInterface को स्वीकार करता है, मानक प्रतिसाद देता है।
• ContextHandlerFunc - एक संदर्भ लेता है और सहकर्मी देता है
• हैंडलरफंच - एक संदर्भ लेता है, एक इंटरफेस और एक त्रुटि देता है। एक बाइट सरणी को लौटाया जा सकता है या कोई भी गोलगप्पा प्रकार जो स्वचालित रूप से एक बाइट सरणी में परिवर्तित हो जाता है जिसके आधार पर peer.Response बनाया जाता है। प्रतिक्रिया की स्थिति shim.Ok या shim.Error होगी , जो पारित की गई त्रुटि के आधार पर होगी।

 // StubHandlerFunc acts as raw chaincode invoke method, accepts stub and returns peer.Response StubHandlerFunc func(shim.ChaincodeStubInterface) peer.Response // ContextHandlerFunc use stub context as input parameter ContextHandlerFunc func(Context) peer.Response // HandlerFunc returns result as interface and error, this is converted to peer.Response via response.Create HandlerFunc func(Context) (interface{}, error) 

, , ( CarPayload)
State , ( )

 // car get info chaincode method handler func car(c router.Context) (interface{}, error) { return c.State().Get( // get state entry Key(c.ArgString(`id`)), // by composite key using CarKeyPrefix and car.Id &Car{}) // and unmarshal from []byte to Car struct } // cars car list chaincode method handler func cars(c router.Context) (interface{}, error) { return c.State().List( CarKeyPrefix, // get list of state entries of type CarKeyPrefix &Car{}) // unmarshal from []byte and append to []Car slice } // carRegister car register chaincode method handler func carRegister(c router.Context) (interface{}, error) { // arg name defined in router method definition p := c.Arg(`car`).(CarPayload) t, _ := c.Time() // tx time car := &Car{ // data for chaincode state Id: p.Id, Title: p.Title, Owner: p.Owner, UpdatedAt: t, } return car, // peer.Response payload will be json serialized car data c.State().Insert( //put json serialized data to state Key(car.Id), // create composite key using CarKeyPrefix and car.Id car) } 

-

- — , . BDD – Behavior Driven Development, .

, , - Ethereum ganache-cli truffle . golang - Mockstub.

, . .

Ginkgo , Go, go test . gomega expect , , .

  import ( "testing" . "github.com/onsi/ginkgo" . "github.com/onsi/gomega" examplecert "github.com/s7techlab/cckit/examples/cert" "github.com/s7techlab/cckit/extensions/owner" "github.com/s7techlab/cckit/identity" "github.com/s7techlab/cckit/state" testcc "github.com/s7techlab/cckit/testing" expectcc "github.com/s7techlab/cckit/testing/expect" ) func TestCars(t *testing.T) { RegisterFailHandler(Fail) RunSpecs(t, "Cars Suite") } 

, CarPayload :

 var Payloads = []*Car{{ Id: `A777MP77`, Title: `VAZ`, Owner: `victor`, }, { Id: `O888OO77`, Title: `YOMOBIL`, Owner: `alexander`, }, { Id: `O222OO177`, Title: `Lambo`, Owner: `hodl`, }} 

MockStub Cars.

 //Create chaincode mock cc := testcc.NewMockStub(`cars`, New()) 

क्योंकि cars , .

 // load actor certificates actors, err := identity.ActorsFromPemFile(`SOME_MSP`, map[string]string{ `authority`: `s7techlab.pem`, `someone`: `victor-nosov.pem`}, examplecert.Content) 

BeforeSuite Car authority Init . , Cars Init Init , .

 BeforeSuite(func() { // init chaincode expectcc.ResponseOk(cc.From(actors[`authority`]).Init()) // init chaincode from authority }) 

. , CarRegister , .

 It("Allow authority to add information about car", func() { //invoke chaincode method from authority actor expectcc.ResponseOk(cc.From(actors[`authority`]).Invoke(`carRegister`, Payloads[0])) }) It("Disallow non authority to add information about car", func() { //invoke chaincode method from non authority actor expectcc.ResponseError( cc.From(actors[`someone`]).Invoke(`carRegister`, Payloads[0]), owner.ErrOwnerOnly) // expect "only owner" error }) 

:

 It("Disallow authority to add duplicate information about car", func() { expectcc.ResponseError( cc.From(actors[`authority`]).Invoke(`carRegister`, Payloads[0]), state.ErrKeyAlreadyExists) //expect car id already exists }) 

निष्कर्ष

- HLF Go, Java, JavaScript, , , - (Solidity) / -. / .

HLF , , ( .). Hypeledger Fabric , .. .