गो पर अलविदा स्मार्ट अनुबंधों का परीक्षण: अलविदा, जावास्क्रिप्ट

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

यह मेरे पहले प्रकाशित मध्यम अंग्रेजी लेख का अनुवाद है

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

जावास्क्रिप्ट जाल

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

let proposalExists = await voting.checkProposal(); assert.equal(proposalExists, true, 'Proposal should exist'); 

यदि checkProposal स्ट्रिंग "हाँ" या "नहीं" लौटाता है, तो आप हमेशा उन्हें सही में परिवर्तित करेंगे। डायनेमिक टाइपिंग इन जालों को छुपाती है, और यहां तक ​​कि अनुभवी प्रोग्रामर बड़ी परियोजना या अन्य डेवलपर्स के साथ टीम में काम करते समय ऐसी गलतियां कर सकते हैं जो कोड में बदलाव कर सकते हैं और इसकी रिपोर्ट नहीं कर सकते।

गो की स्टैटिक टाइपिंग ऐसी त्रुटियों को रोकने में मदद करती है। इसके अलावा, परीक्षण के लिए Node.js के बजाय गो भाषा का उपयोग किसी भी गो-डेवलपर का सपना है जो स्मार्ट अनुबंधों के साथ काम करना शुरू कर देता है।

मेरी टीम एक बहुत जटिल वास्तुकला के साथ स्मार्ट अनुबंधों के आधार पर एक निवेश प्रणाली विकसित कर रही थी। स्मार्ट अनुबंध प्रणाली में कोड की 2,000 से अधिक लाइनें थीं। चूँकि टीम का अधिकांश हिस्सा गो डेवलपर्स का था, गो पर परीक्षण करना Node.js. के लिए बेहतर था।

गो पर स्मार्ट अनुबंधों के परीक्षण के लिए पहला वातावरण

2017 में, PolySwarm ने Perigord , Truffle के समान एक उपकरण विकसित किया, जिसमें जावास्क्रिप्ट के बजाय Go का उपयोग किया गया। दुर्भाग्य से, यह परियोजना अब समर्थित नहीं है, इसमें बहुत सरल उदाहरणों के साथ केवल एक ट्यूटोरियल है। इसके अलावा, यह गनाचे (एक बहुत ही सुविधाजनक जीयूआई के साथ एथेरियम को विकसित करने के लिए एक निजी ब्लॉकचैन) के साथ एकीकरण का समर्थन नहीं करता है। हमने बग्स को खत्म करके और दो नई विशेषताओं को पेश करके पेरिगर्ड में सुधार किया: मेनेमोनिक कोड से पर्स उत्पन्न करना और गनाचे ब्लॉकचेन से परीक्षण और कनेक्ट करने के लिए उनका उपयोग करना। आप यहां सोर्स कोड पढ़ सकते हैं।

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

उन्नत Perigord का उपयोग करना: एक पूर्ण गाइड

पेरीगॉर्ड का उपयोग करने के लिए आपको गो 1.7+, सोल, एबिजेन और गनाचे को स्थापित करना होगा। कृपया अपने ऑपरेटिंग सिस्टम के लिए प्रलेखन देखें।

Perigord को निम्नानुसार स्थापित करें:

 $ go get gitlab.com/go-truffle/enhanced-perigord $ go build 

उसके बाद, आप पेरिगर्ड कमांड का उपयोग कर सकते हैं:

 $ perigord A golang development environment for Ethereum Usage: perigord [command] Available Commands: add Add a new contract or test to the project build (alias for compile) compile Compile contract source files deploy (alias for migrate) generate (alias for compile) help Help about any command init Initialize new Ethereum project with example contracts and tests migrate Run migrations to deploy contracts test Run go and solidity tests Flags: -h, --help help for perigord Use "perigord [command] --help" for more information about a command. 

अब हम उपलब्ध परीक्षण विकल्पों को प्रदर्शित करने के लिए एक सरल बाजार स्मार्ट अनुबंध बनाएंगे।

एक परियोजना शुरू करने के लिए, टर्मिनल में निम्नलिखित दर्ज करें:

 $ perigord init market 

परियोजना GOPATH में src / folder में दिखाई देगी। यदि आप इसका स्थान बदलना चाहते हैं, तो प्रोजेक्ट को किसी अन्य फ़ोल्डर में ले जाएं और आयात पथ को अपडेट करें। आइए देखें कि बाजार / फ़ोल्डर में क्या है।

 $ tree . ├── contracts │ └── Foo.sol ├── generate.go ├── main.go ├── migrations │ └── 1_Migrations.go ├── perigord.yaml ├── stub │ ├── README.md │ └── main.go ├── stub_test.go └── tests └── Foo.go 

Truffle में बनाई गई परियोजना के समान है, है ना? लेकिन यह सब चल रहा है! आइए देखें कि perigord.yaml कॉन्फ़िगरेशन फ़ाइल में क्या है।

 networks: dev: url: /tmp/geth_private_testnet/geth.ipc keystore: /tmp/geth_private_testnet/keystore passphrase: blah mnemonic: candy maple cake sugar pudding cream honey rich smooth crumble sweet treat num_accounts: 10 

परीक्षण के लिए, आप निजी geth नेटवर्क और वॉलेट फ़ाइलों दोनों का उपयोग कर सकते हैं, और Ganache से कनेक्ट कर सकते हैं। ये विकल्प परस्पर अनन्य हैं। हम डिफ़ॉल्ट mnemonics लेते हैं, 10 खाते बनाते हैं और Ganache से जुड़ते हैं। कोड को perigord.yaml में बदलें:

 networks: dev: url: HTTP://127.0.0.1:7545 mnemonic: candy maple cake sugar pudding cream honey rich smooth crumble sweet treat num_accounts: 10 

HTTP http://127.0.0.1:7545 - Ganache RPC सर्वर का मानक पता। कृपया ध्यान दें कि आप परीक्षण के लिए किसी भी संख्या में खाते बना सकते हैं, लेकिन केवल Ganache (GUI) में जनरेट किए गए खातों में ही धन होगा।

हम Market.sol नामक एक अनुबंध बनाएंगे। वह पते के जोड़े का एक रिकॉर्ड रख सकता है, जिनमें से एक अनुबंध खाते में धन भेजता है, और दूसरे को धन प्राप्त करने का अधिकार है जब अनुबंध धारक ऐसे लेनदेन की अनुमति देता है। उदाहरण के लिए, दो प्रतिभागी एक-दूसरे पर भरोसा नहीं करते हैं, लेकिन अनुबंध के मालिक पर भरोसा करते हैं, जो यह तय करता है कि एक निश्चित शर्त पूरी की जाती है या नहीं। उदाहरण प्रदर्शन प्रयोजनों के लिए कई बुनियादी कार्यों को लागू करता है।

प्रोजेक्ट में संपर्क जोड़ें:

 $ perigord add contract Market 

उपसर्ग .sol स्वचालित रूप से जोड़ा जाएगा। आप अन्य अनुबंध भी जोड़ सकते हैं या नमूना अनुबंध Foo.sol को हटा सकते हैं। जब आप GOPATH में काम कर रहे हैं, तो आप जटिल संरचनाओं को बनाने के लिए आयात अनुबंधों का उपयोग कर सकते हैं। हमारे पास तीन सॉलिडिटी फाइलें होंगी: मुख्य बाजार अनुबंध, योग्य और माइग्रेशन सहायक अनुबंध और सेफमैथ लाइब्रेरी। आप स्रोत कोड यहां पा सकते हैं।

अब परियोजना की निम्नलिखित संरचना है:

 . ├── contracts │ ├── Market.sol │ ├── Ownable.sol │ └── SafeMath.sol ├── generate.go ├── main.go ├── migrations │ └── 1_Migrations.go ├── perigord.yaml ├── stub │ ├── README.md │ └── main.go ├── stub_test.go └── tests └── Foo.go 

EVM बायटेकोड, ABI और गो बाइंडिंग बनाएं:

 $ perigord build 

उन सभी अनुबंधों के माइग्रेशन जोड़ें जिन्हें आप तैनात करेंगे। क्योंकि हम केवल Market.sol की तैनाती करते हैं, हमें केवल एक नया माइग्रेशन चाहिए:

 $ perigord add migration Market 

हमारे अनुबंध में एक निर्माता नहीं है जो मापदंडों को स्वीकार करता है। यदि आपको कंस्ट्रक्टर के लिए पैरामीटर पास करने की आवश्यकता है, तो उन्हें माइग्रेशन फ़ाइल में {{NewContract} फंक्शन में जोड़ें।:

 address, transaction, contract, err := bindings.Deploy{NewContract}(auth, network.Client(), “FOO”, “BAR”) 

नमूना फ़ाइल Foo.go हटाएं और हमारे अनुबंध के लिए एक परीक्षण फ़ाइल जोड़ें:

 $ perigord add test Market 

नियतात्मक बटुए का उपयोग करने के लिए, हमें विन्यास फाइल से मंत्रशास्त्र को पढ़ने की आवश्यकता है:

 func getMnemonic() string { viper.SetConfigFile("perigord.yaml") if err := viper.ReadInConfig(); err != nil { log.Fatal() } mnemonic := viper.GetStringMapString("networks.dev")["mnemonic"] return mnemonic } 

नेटवर्क पता प्राप्त करने के लिए निम्न सहायक फ़ंक्शन का उपयोग किया जाता है:

 func getNetworkAddress() string { viper.SetConfigFile("perigord.yaml") if err := viper.ReadInConfig(); err != nil { log.Fatal() } networkAddr := viper.GetStringMapString("networks.dev")["url"] return networkAddr } 

एक और सहायक कार्य जो हमें करने की आवश्यकता है, वह है ,ETETH, हम इसका उपयोग ईथर से किसी भी Ethereum पते पर उत्पन्न होने वाले बटुए (सूचकांक द्वारा इंगित) में से एक को स्थानांतरित करने के लिए करेंगे:

 func sendETH(s *MarketSuite, c *ethclient.Client, sender int, receiver common.Address, value *big.Int) { senderAcc := s.network.Accounts()[sender].Address nonce, err := c.PendingNonceAt(context.Background(), senderAcc) if err != nil { log.Fatal(err) } gasLimit := uint64(6721975) // in units gasPrice := big.NewInt(3700000000) wallet, err := hdwallet.NewFromMnemonic(getMnemonic()) toAddress := receiver var data []byte tx := types.NewTransaction(nonce, toAddress, value, gasLimit, gasPrice, data) chainID, err := c.NetworkID(context.Background()) if err != nil { log.Fatal(err) } privateKey, err := wallet.PrivateKey(s.network.Accounts()[sender]) signedTx, err := types.SignTx(tx, types.NewEIP155Signer(chainID), privateKey) if err != nil { log.Fatal(err) } ts := types.Transactions{signedTx} rawTx := hex.EncodeToString(ts.GetRlp(0)) var trx *types.Transaction rawTxBytes, err := hex.DecodeString(rawTx) err = rlp.DecodeBytes(rawTxBytes, &trx) err = c.SendTransaction(context.Background(), trx) if err != nil { log.Fatal(err) } } 

अनुबंध कॉल को संशोधित करने के लिए निम्नलिखित दो कार्यों का उपयोग किया जाता है:

 func ensureAuth(auth bind.TransactOpts) *bind.TransactOpts { return &bind.TransactOpts{ auth.From, auth.Nonce, auth.Signer, auth.Value, auth.GasPrice, auth.GasLimit, auth.Context} } func changeAuth(s MarketSuite, account int) bind.TransactOpts { return *s.network.NewTransactor(s.network.Accounts()[account]) } 

परीक्षण प्रक्रिया

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

 contractSession := contract.Session("Market") c.Assert(contractSession, NotNil) contractSessionActual, ok := contractSession.(*bindings.MarketSession) c.Assert(ok, Equals, true) c.Assert(contractSessionActual, NotNil) owner, _ := contractSessionActual.Owner() account0 := s.network.Accounts()[0] c.Assert(owner.Hex(), Equals, account0.Address.Hex()) //Owner account is account 0 

अगली उपयोगी सुविधा वॉलेट को बदल रही है जो अनुबंध का कारण बनता है:

 ownerInd := 0 sender := 5 receiver := 6 senderAcc := s.network.Accounts()[sender].Address receiverAcc := s.network.Accounts()[receiver].Address //Call contract on behalf of its owner auth := changeAuth(*s, ownerInd) _, err = contractSessionActual.Contract.SetSenderReceiverPair(ensureAuth(auth), senderAcc, receiverAcc) 

क्योंकि परीक्षण में उपयोग किए जाने वाले मुख्य कार्यों में से एक कॉलिंग अनुबंध को बदल रहा है, चलो प्रेषक की ओर से भुगतान करें:

 auth = changeAuth(*s, sender) //Change auth fo senderAcc to make a deposit on behalf of the sender client, _ := ethclient.Dial(getNetworkAddress()) //Let's check the current balance balance, _ := client.BalanceAt(context.Background(), contract.AddressOf("Market"), nil) c.Assert(balance.Int64(), Equals, big.NewInt(0).Int64()) //Balance should be 0 //Let's transfer 3 ETH to the contract on behalf of the sender value := big.NewInt(3000000000000000000) // in wei (3 eth) contractReceiver := contract.AddressOf("Market") sendETH(s, client, sender, contractReceiver, value) balance2, _ := client.BalanceAt(context.Background(), contract.AddressOf("Market"), nil) c.Assert(balance2.Int64(), Equals, value.Int64()) //Balance should be 3 ETH 

पूर्ण परीक्षण कोड यहाँ है ।

अब stub_test.go खोलें और सुनिश्चित करें कि सभी आयात आपके वर्तमान प्रोजेक्ट की ओर इशारा करते हैं। हमारे मामले में, यह है:

 import ( _ "market/migrations" _ "market/tests" "testing" . "gopkg.in/check.v1" ) 

परीक्षण चलाएं:

 $ perigord test 

यदि सब कुछ सही ढंग से किया जाता है, तो परीक्षण के अंत के बाद एक समान परिणाम होगा:

 Running migration 2 Running migration 3 OK: 1 passed PASS ok market 0.657s 

यदि आपको कोई समस्या है, तो स्रोत फ़ाइलों को डाउनलोड करें और इस गाइड में वर्णित चरणों को दोहराएं।

निष्कर्ष में

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

मुझे उम्मीद है कि PolySwarm टीम द्वारा शुरू किया गया काम और Inn4Science द्वारा जारी रखा जाना Go समुदाय के लिए उपयोगी होगा और कम सुविधाजनक उपकरणों का उपयोग करके परीक्षण और डिबगिंग के घंटों तक मुक्त होगा।