प्रवाह और ताल का उपयोग करके डिजिटल संग्रहणीय पोर्टल कैसे बनाएं (भाग 1)

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

इस लेख के अंत तक, आपके पास फ़्लो ब्लॉकचेन पर अपना स्वयं का विकेन्द्रीकृत एप्लिकेशन बनाने के लिए आवश्यक उपकरण और ज्ञान होगा।

आइए सीधे गोता लगाएँ!

हम क्या बना रहे हैं?

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

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

आवश्यक शर्तें

शुरू करने से पहले, अपने सिस्टम पर फ़्लो सीएलआई स्थापित करना सुनिश्चित करें। यदि आपने ऐसा नहीं किया है, तो इन इंस्टॉलेशन निर्देशों का पालन करें।

की स्थापना

यदि आप अपने प्रोजेक्ट को किकस्टार्ट करने के लिए तैयार हैं, तो सबसे पहले कमांड फ्लो सेटअप टाइप करें।

यह कमांड आपके प्रोजेक्ट की नींव तैयार करने के लिए पर्दे के पीछे कुछ जादू करता है। यह एक फ़ोल्डर सिस्टम बनाता है और आपके प्रोजेक्ट को कॉन्फ़िगर करने के लिए फ़्लो.जेसन नामक एक फ़ाइल सेट करता है, जिससे यह सुनिश्चित होता है कि सब कुछ व्यवस्थित है और जाने के लिए तैयार है!

परियोजना संरचना

प्रोजेक्ट में एक cadence फ़ोल्डर और flow.json फ़ाइल होगी। (फ्लो.जेसन फ़ाइल आपके प्रोजेक्ट के लिए एक कॉन्फ़िगरेशन फ़ाइल है, जो स्वचालित रूप से बनाए रखी जाती है।)

कैडेंस फ़ोल्डर में निम्नलिखित शामिल हैं:

• /अनुबंध: इसमें सभी ताल अनुबंध शामिल हैं।
• /स्क्रिप्ट्स: सभी कैडेंस स्क्रिप्ट्स को धारण करता है।
• /लेन-देन: सभी कैडेंस लेनदेन को संग्रहीत करता है।

फ़्लो एनएफटी मानक का उपयोग करने के लिए नीचे दिए गए चरणों का पालन करें।

चरण 1: एक फ़ाइल बनाएँ।

सबसे पहले, flow-collectibles-portal फ़ोल्डर पर जाएं, और cadence फ़ोल्डर ढूंढें। फिर, contracts फ़ोल्डर खोलें। एक नई फ़ाइल बनाएं और इसे NonFungibleToken.cdc नाम दें।

चरण 2: कॉपी और पेस्ट करें।

अब, नॉनफंगिबलटोकन नाम का लिंक खोलें जिसमें एनएफटी मानक शामिल है। उस फ़ाइल से सभी सामग्री की प्रतिलिपि बनाएँ, और इसे आपके द्वारा अभी बनाई गई नई फ़ाइल ("NonFungibleToken.cdc") में पेस्ट करें।

इतना ही! आपने अपने प्रोजेक्ट के लिए सफलतापूर्वक मानक स्थापित कर लिए हैं।

अब, आइए कुछ कोड लिखें!

हालाँकि, इससे पहले कि हम कोडिंग में उतरें, डेवलपर्स के लिए यह महत्वपूर्ण है कि वे अपने कोड की संरचना कैसे करें, इसका एक मानसिक मॉडल स्थापित करें।

शीर्ष स्तर पर, हमारे कोडबेस में तीन मुख्य घटक होते हैं:

1. एनएफटी: प्रत्येक संग्रहणीय वस्तु को एनएफटी के रूप में दर्शाया जाता है।

   
   

2. संग्रह: एक संग्रह एक विशिष्ट उपयोगकर्ता के स्वामित्व वाले एनएफटी के समूह को संदर्भित करता है।

   
   

3. वैश्विक कार्य और चर: ये स्मार्ट अनुबंध के लिए वैश्विक स्तर पर परिभाषित कार्य और चर हैं और किसी विशेष संसाधन से जुड़े नहीं हैं।

स्मार्ट अनुबंध संरचना

स्मार्ट अनुबंध मूल संरचना

cadence/contracts के अंदर Collectibles.cdc नामक एक नई फ़ाइल बनाएं। यहीं पर हम कोड लिखेंगे।

अनुबंध संरचना

 import NonFungibleToken from "./NonFungibleToken.cdc" pub contract Collectibles: NonFungibleToken{ pub var totalSupply: UInt64 // other code will come here init(){ self.totalSupply = 0 } }

आइए कोड को पंक्ति दर पंक्ति तोड़ें:

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

   
   

2. आयात करने के बाद, आइए अपना अनुबंध बनाएं। ऐसा करने के लिए, हम pub contract [contract name] उपयोग करते हैं। हर बार जब आप कोई नया अनुबंध बनाएं तो उसी सिंटैक्स का उपयोग करें। आप contract name वह भर सकते हैं जिसे आप अपने अनुबंध का नाम देना चाहें। हमारे मामले में, आइए इसे Collectibles कहें।

   
   

3. इसके बाद, हम यह सुनिश्चित करना चाहते हैं कि हमारा अनुबंध नॉनफंगिबलटोकन की कार्यक्षमता और नियमों के एक निश्चित सेट का पालन करता है। ऐसा करने के लिए, हम `:` की मदद से एक नॉनफंगिबलटोकन इंटरफ़ेस जोड़ते हैं।
   इस तरह ( `pub contract Collectibles: NonFungibleToken{}` )

   
   

4. प्रत्येक अनुबंध में init() फ़ंक्शन अवश्य होना चाहिए। इसे तब कहा जाता है जब अनुबंध प्रारंभ में तैनात किया जाता है। यह वैसा ही है जिसे सॉलिडिटी कंस्ट्रक्टर कहती है।

   
   

5. अब, आइए डेटा प्रकार UInt64 के साथ totalSupply नामक एक वैश्विक वैरिएबल बनाएं। यह वेरिएबल आपके कुल संग्रहणीय वस्तुओं पर नज़र रखेगा।

   
   

6. अब, totalSupply मान 0 से प्रारंभ करें।

इतना ही! हमने अपने Collectibles अनुबंध की नींव तैयार की है। अब, हम इसे और अधिक रोमांचक बनाने के लिए और अधिक सुविधाएँ और कार्यक्षमताएँ जोड़ना शुरू कर सकते हैं।

आगे बढ़ने से पहले, कृपया यह समझने के लिए कोड स्निपेट देखें कि हम कैडेंस में वेरिएबल्स को कैसे परिभाषित करते हैं:

संसाधन एनएफटी

अपने स्मार्ट अनुबंध में निम्नलिखित कोड जोड़ें:

 import NonFungibleToken from "./NonFungibleToken.cdc" pub contract Collectibles: NonFungibleToken{ // above code… pub resource NFT: NonFungibleToken.INFT{ pub let id: UInt64 pub var name: String pub var image: String init(_id:UInt64, _name:String, _image:String){ self.id = _id self.name = _name self.image = _image } } // init()... }

जैसा कि आपने पहले देखा है, अनुबंध एनएफटी मानक इंटरफ़ेस लागू करता है, जिसे pub contract Collectibles: NonFungibleToken द्वारा दर्शाया जाता है। इसी प्रकार, संसाधन विभिन्न संसाधन इंटरफेस को भी कार्यान्वित कर सकते हैं।

तो, आइए एनएफटी संसाधन में NonFungibleToken.INFT इंटरफ़ेस जोड़ें, जो संसाधन के भीतर आईडी नामक सार्वजनिक संपत्ति के अस्तित्व को अनिवार्य करता है।

यहां वे वेरिएबल हैं जिनका उपयोग हम एनएफटी संसाधन में करेंगे:

• id: एनएफटी की आईडी बनाए रखता है
• name: एनएफटी का नाम।
• image: एनएफटी का छवि यूआरएल।

वेरिएबल को परिभाषित करने के बाद, init() फ़ंक्शन में वेरिएबल को प्रारंभ करना सुनिश्चित करें।

आइए आगे बढ़ें और Collection Resource नामक एक और संसाधन बनाएं।

संग्रह संसाधन

सबसे पहले, आपको यह समझने की ज़रूरत है कि Collection Resources कैसे काम करते हैं।

यदि आपको अपने लैपटॉप पर एक संगीत फ़ाइल और कई तस्वीरें संग्रहीत करने की आवश्यकता है, तो आप क्या करेंगे?

आमतौर पर, आप एक स्थानीय ड्राइव (मान लें कि आपका डी-ड्राइव) पर नेविगेट करेंगे और एक music फ़ोल्डर और photos फ़ोल्डर बनाएंगे। फिर आप संगीत और फोटो फ़ाइलों को कॉपी करके अपने गंतव्य फ़ोल्डर में पेस्ट करेंगे।

इसी प्रकार, फ़्लो पर आपकी डिजिटल संग्रहणीय वस्तुएँ इसी प्रकार काम करती हैं।

अपने लैपटॉप को Flow Blockchain Account के रूप में, अपने डी-ड्राइव को Account Storage के रूप में और फोल्डर को एक Collection के रूप में कल्पना करें।

इसलिए जब एनएफटी खरीदने के लिए किसी प्रोजेक्ट के साथ इंटरैक्ट किया जाता है, तो प्रोजेक्ट आपके डी-ड्राइव पर एक फ़ोल्डर बनाने के समान, आपके account storage में अपना collection बनाता है। जब आप 10 अलग-अलग एनएफटी परियोजनाओं के साथ बातचीत करते हैं, तो आपके खाते में 10 अलग-अलग संग्रह होंगे।

यह आपके अनूठे डिजिटल खजाने को संग्रहीत करने और व्यवस्थित करने के लिए एक निजी स्थान की तरह है!

 import NonFungibleToken from "./NonFungibleToken.cdc" pub contract Collectibles: NonFungibleToken{ //Above code NFT Resource… // Collection Resource pub resource Collection{ } // Below code… }

प्रत्येक collection NFT Resources रखने के लिए एक ownedNFTs वैरिएबल होता है।

 pub resource Collection { pub var ownedNFTs: @{UInt64: NonFungibleToken.NFT} init(){ self.ownedNFTs <- {} } }

संसाधन इंटरफ़ेस

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

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

NonFungibleToken मानक में, INFT , Provider , Receiver और CollectionPublic जैसे कई संसाधन इंटरफेस हैं।

इनमें से प्रत्येक इंटरफ़ेस में विशिष्ट कार्य और फ़ील्ड होते हैं जिन्हें उनका उपयोग करने वाले संसाधन द्वारा कार्यान्वित करने की आवश्यकता होती है।

इस अनुबंध में, हम NonFungibleToken: Provider , Receiver , और CollectionPublic । ये इंटरफ़ेस deposit , withdraw , borrowNFT और getIDs जैसे कार्यों को परिभाषित करते हैं। जैसे-जैसे हम आगे बढ़ेंगे, इनमें से प्रत्येक के बारे में विस्तार से बताएंगे।

हम कुछ इवेंट भी जोड़ेंगे जो हम इन फ़ंक्शंस से उत्सर्जित करेंगे, साथ ही कुछ वेरिएबल्स भी घोषित करेंगे जिनका उपयोग हम ट्यूटोरियल में आगे करेंगे।

 pub contract Collectibles:NonFungibleToken{ // rest of the code… pub event ContractInitialized() pub event Withdraw(id: UInt64, from: Address?) pub event Deposit(id: UInt64, to: Address?) pub let CollectionStoragePath: StoragePath pub let CollectionPublicPath: PublicPath pub resource interface CollectionPublic{ pub fun deposit(token: @NonFungibleToken.NFT) pub fun getIDs(): [UInt64] pub fun borrowNFT(id: UInt64): &NonFungibleToken.NFT } pub resource Collection: CollectionPublic, NonFungibleToken.Provider, NonFungibleToken.Receiver, NonFungibleToken.CollectionPublic{ pub var ownedNFTs: @{UInt64: NonFungibleToken.NFT} init(){ self.ownedNFTs <- {} } } }

निकालना

अब, आइए इंटरफ़ेस के लिए आवश्यक withdraw() फ़ंक्शन बनाएं।

 pub resource Collection: CollectionPublic, NonFungibleToken.Provider, NonFungibleToken.Receiver, NonFungibleToken.CollectionPublic{ // other code pub fun withdraw(withdrawID: UInt64): @NonFungibleToken.NFT { let token <- self.ownedNFTs.remove(key: withdrawID) ?? panic("missing NFT") emit Withdraw(id: token.id, from: self.owner?.address) return <- token } init()... }

इस फ़ंक्शन की सहायता से, आप एनएफटी संसाधन को संग्रह से बाहर ले जा सकते हैं। अगर यह:

• विफल : घबरा जाता है और एक त्रुटि उत्पन्न करता है।

• सफल : यह एक निकासी घटना उत्सर्जित करता है और कॉलर को संसाधन लौटाता है।

फिर कॉल करने वाला इस संसाधन का उपयोग कर सकता है और इसे अपने खाते के भंडारण में सहेज सकता है।

जमा

अब, NonFungibleToken.Receiver द्वारा आवश्यक deposit() फ़ंक्शन का समय आ गया है।

 pub resource Collection: CollectionPublic, NonFungibleToken.Provider, NonFungibleToken.Receiver, NonFungibleToken.CollectionPublic{ // other code pub fun withdraw(withdrawID: UInt64): @NonFungibleToken.NFT { let token <- self.ownedNFTs.remove(key: withdrawID) ?? panic("missing NFT") emit Withdraw(id: token.id, from: self.owner?.address) return <- token } pub fun deposit(token: @NonFungibleToken.NFT) { let id = token.id let oldToken <- self.ownedNFTs[id] <-token destroy oldToken emit Deposit(id: id, to: self.owner?.address) } init()... }

उधार लें और आईडी प्राप्त करें

अब, आइए NonFungibleToken.CollectionPublic: borrowNFT() और getID() ।

 pub resource Collection: CollectionPublic, NonFungibleToken.Provider, NonFungibleToken.Receiver, NonFungibleToken.CollectionPublic{ // other code pub fun withdraw(withdrawID: UInt64): @NonFungibleToken.NFT { let token <- self.ownedNFTs.remove(key: withdrawID) ?? panic("missing NFT") emit Withdraw(id: token.id, from: self.owner?.address) return <- token } pub fun deposit(token: @NonFungibleToken.NFT) { let id = token.id let oldToken <- self.ownedNFTs[id] <-token destroy oldToken emit Deposit(id: id, to: self.owner?.address) } pub fun borrowNFT(id: UInt64): &NonFungibleToken.NFT { if self.ownedNFTs[id] != nil { return (&self.ownedNFTs[id] as &NonFungibleToken.NFT?)! } panic("NFT not found in collection.") } pub fun getIDs(): [UInt64]{ return self.ownedNFTs.keys } init()... }

नाशक

संग्रह संसाधन के लिए हमें जिस आखिरी चीज़ की आवश्यकता है वह एक विध्वंसक है।

 destroy (){ destroy self.ownedNFTs }

चूंकि संग्रह संसाधन में अन्य संसाधन (एनएफटी संसाधन) शामिल हैं, इसलिए हमें एक विध्वंसक निर्दिष्ट करने की आवश्यकता है। जब वस्तु नष्ट हो जाती है तो एक विध्वंसक चलता है। यह सुनिश्चित करता है कि जब उनके मूल संसाधन नष्ट हो जाते हैं तो संसाधन "बेघर" नहीं रह जाते हैं। हमें एनएफटी संसाधन के लिए किसी विध्वंसक की आवश्यकता नहीं है क्योंकि इसमें कोई अन्य संसाधन नहीं हैं।

आइए संपूर्ण संग्रह संसाधन स्रोत कोड देखें:

 import NonFungibleToken from "./NonFungibleToken.cdc" pub contract Collectibles: NonFungibleToken{ pub var totalSupply: UInt64 pub resource NFT: NonFungibleToken.INFT{ pub let id: UInt64 pub var name: String pub var image: String init(_id:UInt64, _name:String, _image:String){ self.id = _id self.name = _name self.image = _image } } pub resource interface CollectionPublic{ pub fun deposit(token: @NonFungibleToken.NFT) pub fun getIDs(): [UInt64] pub fun borrowNFT(id: UInt64): &NonFungibleToken.NFT } pub event ContractInitialized() pub event Withdraw(id: UInt64, from: Address?) pub event Deposit(id: UInt64, to: Address?) pub let CollectionStoragePath: StoragePath pub let CollectionPublicPath: PublicPath pub resource Collection: CollectionPublic, NonFungibleToken.Provider, NonFungibleToken.Receiver, NonFungibleToken.CollectionPublic{ pub var ownedNFTs: @{UInt64: NonFungibleToken.NFT} init(){ self.ownedNFTs <- {} } destroy (){ destroy self.ownedNFTs } pub fun withdraw(withdrawID: UInt64): @NonFungibleToken.NFT { let token <- self.ownedNFTs.remove(key: withdrawID) ?? panic("missing NFT") emit Withdraw(id: token.id, from: self.owner?.address) return <- token } pub fun deposit(token: @NonFungibleToken.NFT) { let id = token.id let oldToken <- self.ownedNFTs[id] <-token destroy oldToken emit Deposit(id: id, to: self.owner?.address) } pub fun borrowNFT(id: UInt64): &NonFungibleToken.NFT { if self.ownedNFTs[id] != nil { return (&self.ownedNFTs[id] as &NonFungibleToken.NFT?)! } panic("NFT not found in collection.") } pub fun getIDs(): [UInt64]{ return self.ownedNFTs.keys } } init(){ self.CollectionPublicPath = /public/NFTCollection self.CollectionStoragePath = /storage/NFTCollection self.totalSupply = 0 emit ContractInitialized() } }

अब हमारे पास सारे संसाधन ख़त्म हो गए हैं. इसके बाद, हम वैश्विक फ़ंक्शन को देखेंगे।

वैश्विक कार्य

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

1. createEmptyCollection : यह फ़ंक्शन कॉलर अकाउंट स्टोरेज में एक खाली Collectibles.Collection प्रारंभ करता है।

   
   

2. checkCollection : यह सुविधाजनक फ़ंक्शन आपको यह पता लगाने में मदद करता है कि आपके खाते में पहले से ही collection संसाधन है या नहीं।

   
   

3. मिंटएनएफटी : यह फ़ंक्शन बहुत अच्छा है क्योंकि यह किसी को भी एनएफटी बनाने की अनुमति देता है।

 // pub resource Collection… pub fun createEmptyCollection(): @Collection{ return <- create Collection() } pub fun checkCollection(_addr: Address): Bool{ return getAccount(_addr) .capabilities.get<&{Collectibles.CollectionPublic}> (Collectibles.CollectionPublicPath)! .check() } pub fun mintNFT(name:String, image:String): @NFT{ Collectibles.totalSupply = Collectibles.totalSupply + 1 let nftId = Collectibles.totalSupply var newNFT <- create NFT(_id:nftId, _name:name, _image:image) return <- newNFT } init()...

स्मार्ट अनुबंध समाप्त करना

और अब, अंततः, सब कुछ ठीक होने पर, हमने अपना स्मार्ट अनुबंध लिखना पूरा कर लिया है। यहां अंतिम कोड पर एक नजर डालें।

अब, आइए देखें कि उपयोगकर्ता फ़्लो ब्लॉकचेन पर तैनात स्मार्ट अनुबंधों के साथ कैसे इंटरैक्ट करता है।

फ़्लो ब्लॉकचेन के साथ इंटरैक्ट करने के दो चरण हैं:

1. लेनदेन चलाकर राज्य को बदलें।
2. एक स्क्रिप्ट चलाकर ब्लॉकचेन को क्वेरी करें।

लेन-देन चलाकर राज्य को परिवर्तित करें

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

एक लेन-देन में कई वैकल्पिक चरण शामिल होते हैं: prepare , pre , execute और post चरण।

आप लेनदेन पर कैडेंस संदर्भ दस्तावेज़ में इसके बारे में अधिक पढ़ सकते हैं । प्रत्येक चरण का एक उद्देश्य होता है; दो सबसे महत्वपूर्ण चरण हैं prepare और execute ।

Prepare Phase : इस चरण का उपयोग हस्ताक्षरकर्ता के खाते के अंदर डेटा और जानकारी तक पहुंचने के लिए किया जाता है (AuthAccount प्रकार द्वारा अनुमत)।

Execute Phase : इस चरण का उपयोग क्रियाओं को निष्पादित करने के लिए किया जाता है।

अब, आइए अपने प्रोजेक्ट के लिए एक लेनदेन बनाएं।

अपने प्रोजेक्ट फ़ोल्डर में लेनदेन बनाने के लिए नीचे दिए गए चरणों का पालन करें।

चरण 1: एक फ़ाइल बनाएं.

सबसे पहले प्रोजेक्ट फोल्डर में जाएं और cadence फोल्डर खोलें। इसके अंदर, transaction फ़ोल्डर खोलें, और Create_Collection.cdc और mint_nft.cdc नाम से एक नई फ़ाइल बनाएं।

चरण 2: संग्रह लेनदेन कोड बनाएं जोड़ें।

 import Collectibles from "../contracts/Collectibles.cdc" transaction { prepare(signer: AuthAccount) { if signer.borrow<&Collectibles.Collection>(from: Collectibles.CollectionStoragePath) == nil { let collection <- Collectibles.createEmptyCollection() signer.save(<-collection, to: Collectibles.CollectionStoragePath) let cap = signer.capabilities.storage.issue<&{Collectibles.CollectionPublic}>(Collectibles.CollectionStoragePath) signer.capabilities.publish( cap, at: Collectibles.CollectionPublicPath) } } }

आइए इस कोड को पंक्ति दर पंक्ति तोड़ें:

1. यह लेनदेन संग्रहणीय स्मार्ट अनुबंध के साथ इंटरैक्ट करता है। फिर, यह जांचता है कि निर्दिष्ट भंडारण पथ Collectibles.CollectionStoragePath से संग्रह संसाधन का संदर्भ उधार लेकर प्रेषक (हस्ताक्षरकर्ता) के पास उनके खाते में संग्रह संसाधन संग्रहीत है या नहीं। यदि संदर्भ शून्य है, तो इसका मतलब है कि हस्ताक्षरकर्ता के पास अभी तक कोई संग्रह नहीं है।

   
   

2. यदि हस्ताक्षरकर्ता के पास कोई संग्रह नहीं है, तो वह createEmptyCollection() फ़ंक्शन को कॉल करके एक खाली संग्रह बनाता है।

   
   

3. खाली संग्रह बनाने के बाद, इसे निर्दिष्ट भंडारण पथ Collectibles.CollectionStoragePath के अंतर्गत हस्ताक्षरकर्ता के खाते में रखें।

यह link() का उपयोग करके हस्ताक्षरकर्ता के खाते और नव निर्मित संग्रह के बीच एक लिंक स्थापित करता है।

चरण 3: मिंट एनएफटी लेनदेन कोड जोड़ें।

 import NonFungibleToken from "../contracts/NonFungibleToken.cdc" import Collectibles from "../contracts/Collectibles.cdc" transaction(name:String, image:String){ let receiverCollectionRef: &{NonFungibleToken.CollectionPublic} prepare(signer:AuthAccount){ self.receiverCollectionRef = signer.borrow<&Collectibles.Collection>(from: Collectibles.CollectionStoragePath) ?? panic("could not borrow Collection reference") } execute{ let nft <- Collectibles.mintNFT(name:name, image:image) self.receiverCollectionRef.deposit(token: <-nft) } }

आइए इस कोड को पंक्ति दर पंक्ति तोड़ें:

1. हम सबसे पहले NonFungibleToken और Collectibles contract आयात करते हैं।

   
   

2. transaction(name: String, image: String) यह पंक्ति एक नए लेनदेन को परिभाषित करती है। इसमें दो तर्क, नाम और छवि, दोनों प्रकार के स्ट्रिंग लगते हैं। इन तर्कों का उपयोग ढाले जा रहे एनएफटी के नाम और छवि को पारित करने के लिए किया जाता है।

   
   

3. let receiverCollectionRef: &{NonFungibleToken.CollectionPublic} यह लाइन एक नया वेरिएबल receiverCollectionRef. यह NonFungibleToken.CollectionPublic प्रकार के एनएफटी के सार्वजनिक संग्रह का संदर्भ है। इस संदर्भ का उपयोग उस संग्रह के साथ बातचीत करने के लिए किया जाएगा जहां हम नवनिर्मित एनएफटी जमा करेंगे।

   
   

4. prepare(signer: AuthAccount) यह पंक्ति तैयार ब्लॉक शुरू करती है, जिसे लेनदेन से पहले निष्पादित किया जाता है। यह AuthAccount प्रकार का एक तर्क हस्ताक्षरकर्ता लेता है। AuthAccount लेनदेन के हस्ताक्षरकर्ता के खाते का प्रतिनिधित्व करता है।

   
   

5. यह तैयार ब्लॉक के अंदर हस्ताक्षरकर्ता के भंडारण से Collectibles.Collection का संदर्भ लेता है। यह संग्रह के संदर्भ तक पहुंचने और इसे receiverCollectionRef वैरिएबल में संग्रहीत करने के लिए उधार फ़ंक्शन का उपयोग करता है।

   
   

   यदि संदर्भ नहीं मिलता है (उदाहरण के लिए, यदि संग्रह हस्ताक्षरकर्ता के भंडारण में मौजूद नहीं है), तो यह त्रुटि संदेश फेंक देगा "संग्रह संदर्भ उधार नहीं ले सका।"

   
   

6. execute ब्लॉक में लेनदेन के लिए मुख्य निष्पादन तर्क शामिल है। इस ब्लॉक के अंदर का कोड prepare ब्लॉक के सफलतापूर्वक पूरा होने के बाद निष्पादित किया जाएगा।

   
   

7. nft <- Collectibles.mintNFT(_name: name, image: image) execute ब्लॉक के अंदर, यह लाइन दिए गए नाम और छवि तर्कों के साथ Collectibles अनुबंध से mintNFT फ़ंक्शन को कॉल करती है। इस फ़ंक्शन से दिए गए नाम और छवि के साथ एक नया एनएफटी बनाने की उम्मीद है। <- प्रतीक इंगित करता है कि एनएफटी एक ऐसी वस्तु के रूप में प्राप्त किया जा रहा है जिसे स्थानांतरित किया जा सकता है (एक संसाधन)।

   
   

8. self.receiverCollectionRef.deposit(token: <-nft) यह लाइन नव निर्मित एनएफटी को निर्दिष्ट संग्रह में जमा करती है। यह लेनदेन के निष्पादन खाते से संग्रह में एनएफटी के स्वामित्व को स्थानांतरित करने के लिए receiverCollectionRef पर जमा फ़ंक्शन का उपयोग करता है। यहां <- प्रतीक यह भी इंगित करता है कि deposit प्रक्रिया के दौरान एनएफटी को एक संसाधन के रूप में ले जाया जा रहा है।

एक स्क्रिप्ट चलाकर ब्लॉकचेन को क्वेरी करें

हम ब्लॉकचेन से डेटा देखने या पढ़ने के लिए एक स्क्रिप्ट का उपयोग करते हैं। स्क्रिप्ट निःशुल्क हैं और उन पर हस्ताक्षर करने की आवश्यकता नहीं है।

अपने प्रोजेक्ट फ़ोल्डर में स्क्रिप्ट बनाने के लिए नीचे दिए गए चरणों का पालन करें।

चरण 1: एक फ़ाइल बनाएं.

सबसे पहले प्रोजेक्ट फोल्डर में जाएं और cadence फोल्डर खोलें। इसके अंदर, script फ़ोल्डर खोलें, और view_nft.cdc नाम से एक नई फ़ाइल बनाएं।

चरण 2: एनएफटी स्क्रिप्ट देखें

 import NonFungibleToken from "../contracts/NonFungibleToken.cdc" import Collectibles from "../contracts/Collectibles.cdc" pub fun main(user: Address, id: UInt64): &NonFungibleToken.NFT? { let collectionCap= getAccount(user).capabilities .get<&{Collectibles.CollectionPublic}>(/public/NFTCollection) ?? panic("This public capability does not exist.") let collectionRef = collectionCap.borrow()! return collectionRef.borrowNFT(id: id) }

आइए इस कोड को पंक्ति दर पंक्ति तोड़ें:

1. सबसे पहले, हम NonFungibleToken और Collectibles अनुबंध आयात करते हैं।

   
   

2. pub fun main(acctAddress: Address, id: UInt64): &NonFungibleToken.NFT? यह पंक्ति स्क्रिप्ट के प्रवेश बिंदु को परिभाषित करती है, जो कि मुख्य नाम का एक सार्वजनिक फ़ंक्शन है। फ़ंक्शन दो पैरामीटर लेता है:

   
   

• acctAddress : फ्लो ब्लॉकचेन पर एक खाते के पते का प्रतिनिधित्व करने वाला एक Address प्रकार पैरामीटर।

  
  

• id : संग्रह के भीतर एनएफटी के विशिष्ट पहचानकर्ता का प्रतिनिधित्व करने वाला एक UInt64 प्रकार पैरामीटर।

  
  

3. फिर हम निर्दिष्ट acctAddress के लिए Collectibles.Collection क्षमता लाने के लिए getCapability उपयोग करते हैं। क्षमता एक संसाधन का संदर्भ है जो इसके कार्यों और डेटा तक पहुंच की अनुमति देता है। इस मामले में, यह Collectibles.Collection संसाधन प्रकार के लिए क्षमता ला रहा है।

   
   

4. फिर, हम borrowNFT फ़ंक्शन का उपयोग करके collectionRef से एक एनएफटी उधार लेते हैं। borrowNFT फ़ंक्शन id पैरामीटर लेता है, जो संग्रह के भीतर एनएफटी का विशिष्ट पहचानकर्ता है। किसी क्षमता पर borrow फ़ंक्शन संसाधन डेटा को पढ़ने की अनुमति देता है।

   
   

5. अंत में, हम फ़ंक्शन से एनएफटी लौटाते हैं।

चरण 3: टेस्टनेट परिनियोजन

अब, हमारे स्मार्ट अनुबंध को फ़्लो टेस्टनेट पर तैनात करने का समय आ गया है।

1. एक फ़्लो खाता सेट करें.

फ़्लो खाता बनाने के लिए टर्मिनल में निम्नलिखित कमांड चलाएँ:

 flow keys generate

अपनी सार्वजनिक कुंजी और निजी कुंजी लिखना सुनिश्चित करें।

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

1. निर्दिष्ट इनपुट फ़ील्ड में अपनी सार्वजनिक कुंजी चिपकाएँ।

   
   

2. सिग्नेचर और हैश एल्गोरिदम को डिफ़ॉल्ट पर सेट रखें।

   
   

3. कैप्चा पूरा करें.

   
   

4. क्रिएट अकाउंट पर क्लिक करें.

खाता स्थापित करने के बाद, हमें अपने नए फ़्लो पते के साथ एक संवाद प्राप्त होता है जिसमें 1,000 परीक्षण फ़्लो टोकन होते हैं। पते की प्रतिलिपि बनाएँ ताकि हम आगे चलकर इसका उपयोग कर सकें ।

2. प्रोजेक्ट कॉन्फ़िगर करें.

अब, आइए अपने प्रोजेक्ट को कॉन्फ़िगर करें। प्रारंभ में, जब हमने प्रोजेक्ट सेट किया, तो इसने एक flow.json फ़ाइल बनाई।

यह फ़्लो सीएलआई के लिए कॉन्फ़िगरेशन फ़ाइल है और उन कार्यों के लिए कॉन्फ़िगरेशन को परिभाषित करता है जो फ़्लो सीएलआई आपके लिए कर सकता है। इसे एथेरियम पर लगभग hardhat.config.js के बराबर समझें।

अब, अपना कोड संपादक खोलें, और नीचे दिए गए कोड को कॉपी करके अपनी flow.json फ़ाइल में पेस्ट करें।

 { "contracts": { "Collectibles": "./cadence/contracts/Collectibles.cdc", "NonFungibleToken": { "source": "./cadence/contracts/NonFungibleToken.cdc", "aliases": { "testnet": "0x631e88ae7f1d7c20" } } }, "networks": { "testnet": "access.devnet.nodes.onflow.org:9000" }, "accounts": { "testnet-account": { "address": "ENTER YOUR ADDRESS FROM FAUCET HERE", "key": "ENTER YOUR GENERATED PRIVATE KEY HERE" } }, "deployments": { "testnet": { "testnet-account": [ "Collectibles" ] } } }

3. कॉपी और पेस्ट।

अपनी जेनरेट की गई निजी कुंजी को कोड में उस स्थान पर चिपकाएं (कुंजी: “अपनी जेनरेट की गई निजी कुंजी यहां दर्ज करें”)।

4. निष्पादित करना।

अब, टेस्टनेट पर कोड निष्पादित करें। टर्मिनल पर जाएँ, और निम्नलिखित कोड चलाएँ:

 flow project deploy --network testnet

5. पुष्टि की प्रतीक्षा करें.

लेनदेन सबमिट करने के बाद, आपको एक लेनदेन आईडी प्राप्त होगी। टेस्टनेट पर लेनदेन की पुष्टि होने तक प्रतीक्षा करें, यह दर्शाता है कि स्मार्ट अनुबंध सफलतापूर्वक तैनात किया गया है।

यहां अपना तैनात अनुबंध जांचें।

GitHub पर पूरा कोड जांचें।

अंतिम विचार और बधाई!

बधाई हो! अब आपने फ़्लो ब्लॉकचेन पर एक संग्रहणीय पोर्टल बनाया है और इसे टेस्टनेट पर तैनात किया है। आगे क्या होगा? अब, आप फ्रंटएंड के निर्माण पर काम कर सकते हैं जिसे हम इस श्रृंखला के भाग 2 में शामिल करेंगे।

आपका दिन सचमुच बहुत अच्छा हो!

यहाँ भी प्रकाशित किया गया