🌈🦄 बकलहाऊ के साथ अपनी खुद की एआई-जेनरेटेड आर्ट एनएफटी डीएपी का निर्माण

FVM हाइपरस्पेस टेस्टनेट पर AI-जनित आर्ट NFTs बनाने के लिए अपनी खुद की टेक्स्ट-टू-इमेज स्क्रिप्ट के साथ DApp बनाने, चलाने और तैनात करने के लिए एक संपूर्ण गाइड!

विषयसूची

• 👩‍💻 हम क्या करेंगे...
• 🏛 वास्तुकला आरेख (थोड़े)
• 🥞 डीएपी टेक्नोलॉजी स्टैक
• 🏗️ पायथन टेक्स्ट-टू-इमेज स्क्रिप्ट का निर्माण
• ⚒️ सॉलिडिटी एनएफटी स्क्रिप्ट का निर्माण और तैनाती
• 🎬 फ्रंट-एंड इंटरैक्शन का निर्माण
  • पूर्ण प्रवाह
  • बाकलहाऊ इंटरेक्शन
  • एनएफटी.भंडारण
  • अनुबंध सहभागिता
• 🌟 अंतिम विचार: एआई और ब्लॉकचेन के लिए संभावनाएं
• 🐠 बाकलहाऊ रोडमैप
• ✍️ संपर्क में रहें!

🦄 त्वरित लिंक:

👩‍💻 हम क्या करेंगे...

यह ब्लॉग आपको बताएगा कि कैसे करें

1. Tensorflow पर आधारित एक ओपनसोर्स पायथन-आधारित टेक्स्ट-टू-इमेज स्क्रिप्ट बनाएं (यदि आप इसमें रुचि नहीं रखते हैं, तो आप केवल Bacalhau HTTP समापन बिंदु का उपयोग कर सकते हैं)

2. इस स्क्रिप्ट को बाकलहाऊ (एक खुला पी2पी ऑफ-चेन कंप्यूट प्लेटफॉर्म) पर चलाएं

3. सॉलिडिटी में एक NFT कॉन्ट्रैक्ट बनाएं (एक ओपन ज़ेपेलिन ERC721 कॉन्ट्रैक्ट पर आधारित)

4. फाइलकॉइन वर्चुअल मशीन (FVM) हाइपरस्पेस टेस्टनेट में हार्डहैट के साथ NFT कॉन्ट्रैक्ट तैनात करें

5. फ्रंट-एंड इंटरैक्शन - बकलहाऊ टेक्स्ट-टू-इमेज स्क्रिप्ट और रिएक्ट में अपने एनएफटी अनुबंध के साथ कैसे बातचीत करें

6. अपने NFT मेटाडेटा को NFT.Storage में कैसे सेव करें

7. अपने फ्रंट-एंड डीएपी को फ्लीक में कैसे परिनियोजित करें

   
   

मैंने जानबूझकर इस ढेर में उपलब्ध ओपन-सोर्स और विकेंद्रीकृत तकनीक का उपयोग करने के लिए चुना है।

यह ब्लॉग काफी लंबा होने जा रहा है (अरे - मैं सभी जानकारी देना चाहता हूं और यह सुनिश्चित करना चाहता हूं कि हम शुरुआती-अनुकूल और समावेशी हैं!) - तो बेझिझक उन हिस्सों को छोड़ दें जो तालिका में आपके लिए उपयोगी हैं सामग्री का <3

🏛 वास्तुकला आरेख (थोड़े)

🥞 डीएपी टेक्नोलॉजी स्टैक

(इसे प्राप्त करें - यह एक पैनकेक स्टैक #sorrynotsorry है)

ओपन सोर्स और वेब3-मूल्यवान शुरुआत से :)

• स्मार्ट कॉन्ट्रैक्ट [सॉलिडिटी, ओपन ज़ेपेलिन]
  • एथेरियम (ईवीएम)-संगत ब्लॉकचेन के लिए एक ओओ स्मार्ट कॉन्ट्रैक्ट प्रोग्रामिंग लैंग्वेज है
  • सामान्य स्मार्ट अनुबंध घटकों और अनुबंधों की सुरक्षा-लेखापरीक्षित कार्यान्वयन लाइब्रेरी प्रदान करता है
• स्मार्ट अनुबंध आईडीई [हार्डहट]
  • सॉफ्टवेयर के संपादन, संकलन, डिबगिंग और तैनाती के लिए एक विकास का वातावरण है
• ब्लॉकचेन टेस्टनेट [फाइलकॉइन वर्चुअल मशीन हाइपरस्पेस]
  • एक ईवीएम-संगत टेस्टनेट है जो फाइलकोइन ब्लॉकचैन पर बनाया गया है
• NFT मेटाडेटा संग्रहण [NFT.Storage]
  • IPFS और Filecoin के शीर्ष पर NFT मेटाडेटा को अपरिवर्तनीय रूप से और लगातार स्टोर करने के लिए बनाया गया एक सार्वजनिक अच्छा है और NFTs और एक जावास्क्रिप्ट sdk के लिए मुफ्त विकेन्द्रीकृत भंडारण प्रदान करता है।
• फ्रंट-एंड [नेक्स्टजेएस / रिएक्ट + एनपीएम]
  • हम शायद ये सब जानते हैं... ठीक है? :पी
• क्लाइंट से स्मार्ट कॉन्ट्रैक्ट इंटरैक्शन [मेटामास्क, ईथर, चेनस्टैक आरपीसी नोड]
  • एक का उपयोग करना - मैं अपने ब्लॉकचेन अनुबंध के साथ केवल-पढ़ने के लिए इंटरैक्शन प्राप्त कर सकता हूं।
  • प्रदाता (या इसी तरह के वॉलेट जो द्वारा ब्राउज़र में निर्दिष्ट है) के साथ, हम ब्लॉकचैन अनुबंध को कॉल लिखने में सक्षम बनाते हैं।
  • जेएस ईवीएम-संगत स्मार्ट अनुबंधों के साथ बातचीत करने के लिए एक पुस्तकालय है
• एआई टेक्स्ट-टू-इमेज स्टेबल डिफ्यूजन स्क्रिप्ट [पायथन, टेन्सरफ्लो]
  • एक ओपन-सोर्स मशीन लर्निंग प्लेटफॉर्म और लाइब्रेरी है जो पूर्व-प्रशिक्षित मॉडल और अन्य डेटा और ML टूल प्रदान करता है।
• एआई टेक्स्ट-टू-इमेज जनरेशन के लिए विकेंद्रीकृत ऑफ-चेन कंप्यूट [बाकालहाऊ]
  • एक पीयर-टू-पीयर ओपन कंप्यूटेशन नेटवर्क है जो सार्वजनिक, पारदर्शी और वैकल्पिक रूप से सत्यापन योग्य कंप्यूटेशन प्रक्रियाओं के लिए एक मंच प्रदान करता है। यह एक विकेन्द्रीकृत ऑफ-चेन डेटा संगणना परत है।
• विकेंद्रीकृत डीएपी परिनियोजन [फ्लीक ]
  • IPFS और Filecoin पर वेबसाइटों की तैनाती की पेशकश करता है। यह Vercel या Netlify का वेब3 संस्करण है - यह नहीं कह सकता कि हमारे पास वास्तव में एक विकेन्द्रीकृत ऐप है और फिर इसे वेब2 पर परिनियोजित करें! :डी

🏗️ पायथन टेक्स्ट-टू-इमेज स्क्रिप्ट का निर्माण

💡 टीएलडीआर टिप 💡

यह स्क्रिप्ट पहले से ही बाकलहाऊ के माध्यम से सीएलआई और एक HTTP समापन बिंदु के माध्यम से उपयोग के लिए उपलब्ध है, इसलिए इस भाग को छोड़ने के लिए स्वतंत्र महसूस करें।

स्थिर प्रसार का त्वरित परिचय

स्थिर प्रसार वर्तमान में टेक्स्ट-टू-इमेज प्रोसेसिंग करने के लिए अग्रणी मशीन लर्निंग मॉडल है (और यही मॉडल Dall-E उपयोग करता है)। यह एक प्रकार का डीप लर्निंग है - मशीन लर्निंग का एक सबसेट जो खुद को एक विशिष्ट कार्य करना सिखाता है - इस मामले में टेक्स्ट इनपुट को इमेज आउटपुट में बदलना।

इस उदाहरण में, हम एक प्रसार संभाव्य मॉडल का उपयोग कर रहे हैं जो टेक्स्ट से छवियां उत्पन्न करने के लिए ट्रांसफॉर्मर का उपयोग करता है।

हालांकि चिंता न करें - हमें इसके लिए मशीन लर्निंग मॉडल को जाने और प्रशिक्षित करने की आवश्यकता नहीं है (हालांकि हे - अगर यह आपकी बात है - तो आप पूरी तरह से कर सकते हैं!)

इसके बजाय, हम अपनी पायथन लिपि में Google के TensorFlow ओपन-सोर्स मशीन लर्निंग लाइब्रेरी से एक पूर्व-प्रशिक्षित मॉडल का उपयोग करने जा रहे हैं क्योंकि हमारे लिए ML वज़न की पूर्व-गणना की गई है।

अधिक सही ढंग से, हम मूल एमएल मॉडल के एक अनुकूलित का उपयोग कर रहे हैं।

पायथन स्क्रिप्ट

🦄 आप इस टेक्स्ट-टू-इमेज स्क्रिप्ट को बनाने और डॉकराइज़ करने और इसे बाकलहाऊ और इस दोनों में बाकलहाऊ पर चलाने के बारे में पूरी जानकारी पा सकते हैं। आप इसे इस में भी चला सकते हैं

यहाँ पूरी पायथन स्क्रिप्ट है!

 import argparse from stable_diffusion_tf.stable_diffusion import Text2Image from PIL import Image import os parser = argparse.ArgumentParser(description="Stable Diffusion") parser.add_argument("--h",dest="height", type=int,help="height of the image",default=512) parser.add_argument("--w",dest="width", type=int,help="width of the image",default=512) parser.add_argument("--p",dest="prompt", type=str,help="Description of the image you want to generate",default="cat") parser.add_argument("--n",dest="numSteps", type=int,help="Number of Steps",default=50) parser.add_argument("--u",dest="unconditionalGuidanceScale", type=float,help="Number of Steps",default=7.5) parser.add_argument("--t",dest="temperature", type=int,help="Number of Steps",default=1) parser.add_argument("--b",dest="batchSize", type=int,help="Number of Images",default=1) parser.add_argument("--o",dest="output", type=str,help="Output Folder where to store the Image",default="./") args=parser.parse_args() height=args.height width=args.width prompt=args.prompt numSteps=args.numSteps unconditionalGuidanceScale=args.unconditionalGuidanceScale temperature=args.temperature batchSize=args.batchSize output=args.output generator = Text2Image( img_height=height, img_width=width, jit_compile=False, # You can try True as well (different performance profile) ) img = generator.generate( prompt, num_steps=numSteps, unconditional_guidance_scale=unconditionalGuidanceScale, temperature=temperature, batch_size=batchSize, ) for i in range(0,batchSize): pil_img = Image.fromarray(img[i]) image = pil_img.save(f"{output}/image{i}.png")

ऊपर दी गई स्क्रिप्ट केवल एक टेक्स्ट प्रॉम्प्ट इनपुट तर्क और कुछ अन्य वैकल्पिक मापदंडों को लेती है और फिर फोर्क्ड TensorFlow लाइब्रेरी को इमेज जेनरेट करने के लिए कॉल करती है और उन्हें आउटपुट फ़ाइल में सेव करती है।

यहां किए गए सभी भारी भारोत्तोलन नीचे के खंड में होते हैं - यहीं पर मशीन लर्निंग मॉडल अपना जादू करता है। 🪄

 generator = Text2Image( img_height=height, img_width=width, jit_compile=False, ) img = generator.generate( prompt, num_steps=numSteps, unconditional_guidance_scale=unconditionalGuidanceScale, temperature=temperature, batch_size=batchSize, )

बढ़िया, हम टेक्स्ट प्रॉम्प्ट से छवियां उत्पन्न कर सकते हैं, लेकिन उम... इस GPU-आवश्यक स्क्रिप्ट को कहां चलाना है... 🤔🤔

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

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

न केवल वह केंद्रीकृत है, बल्कि यह अक्षम भी है - गणना मशीन से डेटा अज्ञात दूरी होने के कारण, और यह तेजी से महंगा हो सकता है। मैं इसके लिए जीपीयू प्रोसेसिंग की पेशकश करने वाली किसी भी फ्री-टियर क्लाउड कंप्यूटिंग सेवा को खोजने में विफल रहा (क्या किसी ने क्रिप्टो माइनिंग बैन कहा ..?) और योजनाएं > यूएस $ 400 प्रति माह (नो थैंक्यू) पर आईं।

बकलहाऊ!

हालांकि सौभाग्य से, ये समस्याएं कुछ ऐसे मुद्दे हैं जिन्हें बाकलहाऊ हल करने की कोशिश कर रहे हैं। बाकलहाऊ में डेटा प्रोसेसिंग और कम्प्यूटेशन को खुला और सभी के लिए उपलब्ध बनाना और प्रोसेसिंग समय को तेज करना संभव है, सबसे पहले - कई नोड्स में बैच प्रोसेसिंग का उपयोग करके और दूसरा जहां डेटा रहता है वहां प्रोसेसिंग नोड्स डालकर!

Bacalhau का उद्देश्य IPFS, Filecoin और Web3 में निहित विकेंद्रीकरण मूल्यों को अधिक व्यापक रूप से छोड़े बिना डेटा पर ऑफ-चेन गणना को सक्षम करके डेटा प्रोसेसिंग के भविष्य को लोकतांत्रित करने में मदद करना है।

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

बकलहाऊ पर स्क्रिप्ट चला रहे हैं

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

 bacalhau docker run --gpu 1 ghcr.io/bacalhau-project/examples/stable-diffusion-gpu:0.0.1 -- python main.py --o ./outputs --p "Rainbow Unicorn" 

हालांकि इस उदाहरण में, मैं एक HTTP समापन बिंदु का उपयोग करने जा रहा हूं जो मुझे इस डॉकरीकृत स्थिर प्रसार स्क्रिप्ट से जोड़ता है, जिसे मैं आपको एकीकरण अनुभाग में दिखाऊंगा!

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

हालांकि एनएफटी स्क्रिप्ट पर चलते हैं! :)

⚒️ सॉलिडिटी एनएफटी स्क्रिप्ट का निर्माण और तैनाती

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

NFT स्मार्ट कॉन्ट्रैक्ट पर आधारित है, लेकिन ERC721URIStorage संस्करण का उपयोग करता है, जिसमें मेटाडेटा मानक एक्सटेंशन शामिल हैं (ताकि हम अपने IPFS-पते वाले मेटाडेटा में पास कर सकें - जिसे हम NFT.Storage पर अनुबंध में सहेज लेंगे) .

यह आधार अनुबंध अतिरिक्त रूप से हमें एनएफटी अनुबंध की सामान्य कार्यक्षमता देता है जैसे टकसाल () और स्थानांतरण () हमारे लिए पहले से ही लागू हैं।

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

💡 💡

BacalhauFRC721.sol

 // SPDX-License-Identifier: MIT pragma solidity ^0.8.4; import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol"; import "@openzeppelin/contracts/utils/Counters.sol"; import "@hardhat/console.sol"; contract BacalhauFRC721 is ERC721URIStorage { /** @notice Counter keeps track of the token ID number for each unique NFT minted in the NFT collection */ using Counters for Counters.Counter; Counters.Counter private _tokenIds; /** @notice This struct stores information about each NFT minted */ struct bacalhauFRC721NFT { address owner; string tokenURI; uint256 tokenId; } /** @notice Keeping an array for each of the NFT's minted on this contract allows me to get information on them all with a read-only front end call */ bacalhauFRC721NFT[] public nftCollection; /** @notice The mapping allows me to find NFT's owned by a particular wallet address. I'm only handling the case where an NFT is minted to an owner in this contract - but you'd need to handle others in a mainnet contract like sending to other wallets */ mapping(address => bacalhauFRC721NFT[]) public nftCollectionByOwner; /** @notice This event will be triggered (emitted) each time a new NFT is minted - which I will watch for on my front end in order to load new information that comes in about the collection as it happens */ event NewBacalhauFRC721NFTMinted( address indexed sender, uint256 indexed tokenId, string tokenURI ); /** @notice Creates the NFT Collection Contract with a Name and Symbol */ constructor() ERC721("Bacalhau NFTs", "BAC") { console.log("Hello Fil-ders! Now creating Bacalhau FRC721 NFT contract!"); } /** @notice The main function which will mint each NFT. The ipfsURI is a link to the ipfs content identifier hash of the NFT metadata stored on NFT.Storage. This data minimally includes name, description and the image in a JSON. */ function mintBacalhauNFT(address owner, string memory ipfsURI) public returns (uint256) { // get the tokenID for this new NFT uint256 newItemId = _tokenIds.current(); // Format info for saving to our array bacalhauFRC721NFT memory newNFT = bacalhauFRC721NFT({ owner: msg.sender, tokenURI: ipfsURI, tokenId: newItemId }); //mint the NFT to the chain _mint(owner, newItemId); //Set the NFT Metadata for this NFT _setTokenURI(newItemId, ipfsURI); _tokenIds.increment(); //Add it to our collection array & owner mapping nftCollection.push(newNFT); nftCollectionByOwner[owner].push(newNFT); // Emit an event on-chain to say we've minted an NFT emit NewBacalhauFRC721NFTMinted( msg.sender, newItemId, ipfsURI ); return newItemId; } /** * @notice helper function to display NFTs for frontends */ function getNFTCollection() public view returns (bacalhauFRC721NFT[] memory) { return nftCollection; } /** * @notice helper function to fetch NFT's by owner */ function getNFTCollectionByOwner(address owner) public view returns (bacalhauFRC721NFT[] memory){ return nftCollectionByOwner[owner]; }

आवश्यकताएं

मैं इस अनुबंध को पर तैनात करूंगा, लेकिन आप इस अनुबंध को पॉलीगॉन, बीएससी, ऑप्टिमिज्म, आर्बिट्रम, हिमस्खलन और अन्य सहित किसी भी ईवीएम-संगत श्रृंखला में तैनात कर सकते हैं। मल्टी-चेन एनएफटी बनाने के लिए आप अपने फ्रंट एंड को भी ट्वीक कर सकते हैं (संकेत: )!

हाइपरस्पेस टेस्टनेट पर परिनियोजित करने के लिए हमें इसकी आवश्यकता होगी

1. मेटामास्क वॉलेट को हाइपरस्पेस टेस्टनेट से
2. नल से कुछ परीक्षण tFIL फंड प्राप्त करें ( या )

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

मैं इस अनुबंध को हाइपरस्पेस टेस्टनेट पर तैनात करने के लिए हार्डहैट का उपयोग कर रहा हूं।

🛸 हाइपरस्पेस आरपीसी और ब्लॉक एक्सप्लोरर विकल्प:

सार्वजनिक आरपीसी समापन बिंदु

ब्लॉक एक्सप्लोरर

ओपन एपीआई :

कॉन्फिग सेट-अप के लिए, हम किसी भी उपलब्ध सार्वजनिक RPC एंडपॉइंट में से चुन सकते हैं।

hardhat.config.ts

 import '@nomicfoundation/hardhat-toolbox'; import { config as dotenvConfig } from 'dotenv'; import { HardhatUserConfig } from 'hardhat/config'; import { resolve } from 'path'; //Import our customised tasks // import './pages/api/hardhat/tasks'; const dotenvConfigPath: string = process.env.DOTENV_CONFIG_PATH || './.env'; dotenvConfig({ path: resolve(__dirname, dotenvConfigPath) }); // Ensure that we have all the environment variables we need. const walletPrivateKey: string | undefined = process.env.WALLET_PRIVATE_KEY; if (!walletPrivateKey) { throw new Error('Please set your Wallet private key in a .env file'); } const config: HardhatUserConfig = { solidity: '0.8.17', defaultNetwork: 'filecoinHyperspace', networks: { hardhat: {}, filecoinHyperspace: { url: '//api.hyperspace.node.glif.io/rpc/v1', chainId: 3141, accounts: [process.env.WALLET_PRIVATE_KEY ?? 'undefined'], }, // bleeding edge often-reset FVM testnet filecoinWallaby: { url: '//wallaby.node.glif.io/rpc/v0', chainId: 31415, accounts: [process.env.WALLET_PRIVATE_KEY ?? 'undefined'], //explorer: //wallaby.filscan.io/ and starboard }, }, // I am using the path mapping so I can keep my hardhat deployment within the /pages folder of my DApp and therefore access the contract ABI for use on my frontend paths: { root: './pages/api/hardhat', tests: './pages/api/hardhat/tests', //who names a directory in the singular?!!! Grammarly would not be happy cache: './pages/api/hardhat/cache', }, }; export default config;

और स्मार्ट अनुबंध को तैनात करने के लिए हम एक तैनाती स्क्रिप्ट बनाते हैं - ध्यान दें कि मैं विशेष रूप से यहां हस्ताक्षरकर्ता (स्वामी) के रूप में वॉलेट पता सेट कर रहा हूं - कुछ मैपिंग त्रुटियां हैं जो अभी भी लिखने के समय FEVM में काम कर रही हैं जो कारण बन सकती हैं कुछ अजीब व्यवहार।

deploy/deployBacalhauFRC721.ts

 import hre from 'hardhat'; import type { BacalhauFRC721 } from '../typechain-types/contracts/BacalhauFRC721'; import type { BacalhauFRC721__factory } from '../typechain-types/factories/contracts/BacalhauFRC721__factory'; async function main() { console.log('Bacalhau721 deploying....'); // !!!needed as hardhat's default does not map correctly to the FEVM const owner = new hre.ethers.Wallet( process.env.WALLET_PRIVATE_KEY || 'undefined', hre.ethers.provider ); const bacalhauFRC721Factory: BacalhauFRC721__factory = < BacalhauFRC721__factory > await hre.ethers.getContractFactory('BacalhauFRC721', owner); const bacalhauFRC721: BacalhauFRC721 = <BacalhauFRC721>( await bacalhauFRC721Factory.deploy() ); await bacalhauFRC721.deployed(); console.log('bacalhauFRC721 deployed to ', bacalhauFRC721.address); // optionally log to a file here } main().catch((error) => { console.error(error); process.exitCode = 1; });

तैनात करने के लिए, उपरोक्त स्क्रिप्ट को निम्नलिखित कोड का उपयोग करके टर्मिनल में चलाएं (NB: चूंकि हमने अपने कॉन्फिग में डिफ़ॉल्ट नेटवर्क को फाइलकॉइनहाइपरस्पेस पर सेट किया है, इसलिए नेटवर्क के लिए फ्लैग पास करना आवश्यक नहीं है, हालांकि यह नीचे दिखाया गया है)

> cd ./pages/hardhat/deploy/

 npx hardhat run ./deployBacalhauFRC721.ts --network filecoinHyperspace

जश्न मनाना! हमने अभी-अभी अपने एनएफटी अनुबंध को फिल्कोइन हाइपरस्पेस टेस्टनेट पर तैनात किया है!

🎬 फ्रंट-एंड इंटरैक्शन का निर्माण

सुंदर हिस्से पर वाह ... और वह गोंद भी जो इसे एक साथ रखता है :)

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

टाइपस्क्रिप्ट के लिए ... ठीक है, मैंने इसे थोड़ी हड़बड़ी में बनाया है और यह स्वीकार करना होगा कि यह टाइपस्क्रिप्ट का बहुत अच्छा उदाहरण नहीं है - var हालांकि खुश लगते हैं ...;)

किसी भी तरह - इस खंड का मुख्य बिंदु आपको यह दिखाना नहीं है कि फ्रंट एंड को कैसे कोड करना है, बल्कि आपको यह दिखाने के लिए कि स्मार्ट कॉन्ट्रैक्ट, बाकलहाऊ (हमारे स्थिर प्रसार एमएल मॉडल के साथ) और निश्चित रूप से, NFT.Storage - # के साथ कैसे बातचीत करें। नॉटऑनआईपीएफएसनॉट योरएनएफटी।

पूर्ण प्रवाह

[टूडू: एक प्रवाह चार्ट आरेख बनाएं]

• उपयोगकर्ता इनपुट फ़ील्ड -> में टेक्स्ट प्रॉम्प्ट दर्ज करता है
• इमेज जनरेट बटन पर क्लिक करता है -> इमेज जेनरेट करने के लिए बाकलहाऊ जॉब को कॉल करता है
• Bacalhau कार्य पूरा होता है -> प्रारूप NFT मेटाडेटा JSON ऑब्जेक्ट में वापस आते हैं
• उपयोगकर्ता मिंट NFT बटन पर क्लिक करता है -> NFT.Storage को NFT मेटाडेटा को सहेजने के लिए कॉल किया जाता है और फ़ोल्डर के लिए IPFS CID के साथ वापस आता है -> इस मेटाडेटा के साथ NFT बनाने के लिए स्मार्ट अनुबंध के मिंट NFT फ़ंक्शन को IPFS_URI के साथ कॉल किया जाता है ->
• !! [FEVM Gotcha] -> यहां हम आम तौर पर इस परिणाम के TX (लेन-देन हैश) के लौटने की प्रतीक्षा करेंगे, लेकिन यह वर्तमान में काम नहीं कर रहा है, इसलिए इसके पूरा होने पर पता लगाने के लिए हम एक अनुबंध ईवेंट श्रोता का उपयोग कर रहे हैं।
• पूर्ण! -> अब किसी भी डिस्प्ले डेटा को फिर से ला सकते हैं और मिंटिंग पर यूजर स्टेटस सक्सेस फीडबैक दे सकते हैं।

अच्छा - देखते हैं कि हम इसे कोड में कैसे कार्यान्वित करते हैं!

बाकलहाऊ इंटरेक्शन

बाकलहाऊ के लिए फ्रंट-एंड एपीआई एंडपॉइंट बनाना में इंजीनियर द्वारा प्रलेखित है।

एपीआई वर्तमान में केवल इस ब्लॉग में प्रलेखित स्थिर प्रसार स्क्रिप्ट को सीधे हिट करता है, हालांकि, टीम इसे अधिक सामान्य एपीआई में विस्तारित करने की प्रक्रिया में है ताकि आप किसी भी उदाहरण को कॉल कर सकें, और HTTP से अपनी खुद की तैनात स्क्रिप्ट भी बाकी एपीआई। FilecoinProject slac में या #bacalhau चैनल पर इस पर नज़र रखें

>run/test in terminal

 curl -XPOST -d '{"prompt": "rainbow unicorn"}' '//dashboard.bacalhau.org:1000/api/v1/stablediffusion';

>react / typescript code

 import { CID } from 'multiformats/cid'; export const callBacalhauJob = async (promptInput: string) => { //Bacalahau HTTP Stable Diffusion Endpoint const url = '//dashboard.bacalhau.org:1000/api/v1/stablediffusion'; const headers = { 'Content-Type': 'application/x-www-form-urlencoded', }; const data = { prompt: promptInput, //The user text prompt! }; /* FETCH FROM BACALHAU ENDPOINT */ const cid = await fetch(url, { method: 'POST', body: JSON.stringify(data), headers: headers, }) .then(async (res) => { let body = await res.json(); if (body.cid) { /* Bacalhau returns a V0 CID which we want to convert to a V1 CID for easier usage with http gateways (ie. displaying the image on web), so I'm using the IPFS multiformats package to convert it here */ return CID.parse(body.cid).toV1().toString(); } }) .catch((err) => { console.log('error in bac job', err); }); return cid; };

यह फ़ंक्शन एक फ़ोल्डर संरचना के साथ एक IPFS CID (सामग्री पहचानकर्ता) लौटाएगा, जैसा कि नीचे दिया गया है। छवि को तब /outputs/image0.png के अंतर्गत पाया जा सकता है।

💡 ! 💡

आह इंद्रधनुष यूनिकॉर्न... क्या पसंद नहीं है!

एनएफटी.भंडारण

NFT.Storage एक सार्वजनिक वस्तु (उर्फ़ मुक्त) है जो किसी जावास्क्रिप्ट या HTTP SDK के साथ IPFS और Filecoin पर NFT मेटाडेटा को स्थायी रूप से संग्रहीत करना आसान बनाता है।

NFT मेटाडेटा एक JSON दस्तावेज़ है जो नीचे दिए गए उदाहरण की तरह दिखता है - जो सीधे Open Zeppelin डॉक्स से लिया गया है:

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

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

ओपन ज़ेपेलिन भी कुछ चेतावनी देता है!

NFT.Storage का उपयोग करने का अर्थ है कि हम अपने मेटाडेटा के लिए एक अपरिवर्तनीय IPFS फ़ाइल CID ( सामग्री - स्थान नहीं - आईडी एंटिफायर) प्राप्त करते हैं, जिसे न केवल IPFS पर पिन किया जाता है, बल्कि फिर दृढ़ता के लिए Filecoin में संग्रहीत किया जाता है। आपको केवल इसके लिए साइन अप करने की आवश्यकता होगी। इसके लिए NFT.Storage और एक प्राप्त करें (अपनी .env फ़ाइल में सहेजने के लिए)।

.env example

 NEXT_PUBLIC_NFT_STORAGE_API_KEY=xxx

हमें यह भी सुनिश्चित करने की आवश्यकता है कि हमने एक उचित रूप से गठित मेटाडेटा JSON बनाया है - क्योंकि FVM (अभी!) के पास NFT मार्केटप्लेस नहीं है ... हम यह सुनिश्चित करना चाहते हैं कि जब यह अपनाया जाए तो हमारा NFT अभी भी मानक के अनुरूप हो .

 import { NFTStorage } from 'nft.storage'; //connect to NFT.Storage Client const NFTStorageClient = new NFTStorage({ token: process.env.NEXT_PUBLIC_NFT_STORAGE_API_KEY, }); const createNFTMetadata = async ( promptInput: string, imageIPFSOrigin: string, //the ipfs path eg. ipfs://[CID] imageHTTPURL: string //an ipfs address fetchable through http for the front end to use (ie. including an ipfs http gateway on it like //[CID].ipfs.nftstorage.link) ) => { console.log('Creating NFT Metadata...'); let nftJSON; // let's get the image data Blob from the IPFS CID that was returned from Bacalhau earlier... await getImageBlob(status, setStatus, imageHTTPURL).then( async (imageData) => { // Now let's create a unique CID for that image data - since we don't really want the rest of the data returned from the Bacalhau job.. await NFTStorageClient.storeBlob(imageData) .then((imageIPFS) => { console.log(imageIPFS); //Here's the JSON construction - only name, description and image are required fields- but I also want to save some other properties like the ipfs link and perhaps you have other properties that give your NFT's rarity to add as well nftJSON = { name: 'Bacalhau Hyperspace NFTs 2023', description: promptInput, image: imageIPFSOrigin, properties: { prompt: promptInput, type: 'stable-diffusion-image', origins: { ipfs: `ipfs://${imageIPFS}`, bacalhauipfs: imageIPFSOrigin, }, innovation: 100, content: { 'text/markdown': promptInput, }, }, }; }) .catch((err) => console.log('error creating blob cid', err)); } ); return nftJSON; };

अब इस मेटाडेटा को NFT.Storage में संग्रहीत करते हैं!

 await NFTStorageClient.store(nftJson) .then((metadata) => { // DONE! - do something with this returned metadata! console.log('NFT Data pinned to IPFS & stored on Filecoin!'); console.log('Metadata URI: ', metadata.url); // once saved we can use it to mint the NFT // mintNFT(metadata); }) .catch((err) => { console.log('error uploading to nft.storage'); });

वूट - हमारे पास बाकलहाऊ से हमारी छवि है, हमने अपने मेटाडेटा को अपरिवर्तनीय रूप से और लगातार NFT.Strorage के साथ सहेजा है, अब हम अपने NFT का टकसाल बनाते हैं!

💡 त्वरित युक्ति 💡NFT.Storage अन्य जैसे storeCar और storeDirectory के साथ-साथ एक स्थिति () फ़ंक्शन भी प्रदान करता है - जो एक CID के IPFS पिनिंग और Filecoin स्टोरेज सौदों को लौटाता है -> यह एक बहुत अच्छा जोड़ हो सकता है एनएफटी की स्थिति की जांच के लिए एक एफईवीएम डीएपी (या एफईवीएम मेननेट रिलीज होने पर एफईवीएम पर एनएफटी कार्यान्वयन)।

अनुबंध सहभागिता

यहां 3 प्रकार के इंटरैक्शन हैं (और कुछ एफईवीएम गोचा - बीटा तकनीक में हमेशा कुछ विचित्र बग विशेषताएं होती हैं!)

• केवल-पढ़ने के लिए कॉल श्रृंखला से डेटा को बिना म्यूट किए पुनर्प्राप्त करने के लिए कॉल करता है

• ऐसे कॉल लिखें जिनमें हस्ताक्षर करने और गैस का भुगतान करने के लिए वॉलेट की आवश्यकता हो। कार्य जो श्रृंखला की स्थिति को बदलते हैं, जैसे कि एनएफटी खनन!

• घटना श्रोता - जो अनुबंध से निकलने वाली घटनाओं को सुनते हैं

  
  

इन सभी कार्यों के लिए, हम का उपयोग करेंगे - एथेरियम एपीआई के लिए एक हल्का आवरण, हमारे अनुबंध से जुड़ने और इसे कॉल करने के लिए।

सार्वजनिक RPC के साथ रीड मोड में अनुबंध से जुड़ना:

 //The compiled contract found in pages/api/hardhat/artifacts/contracts import BacalhauCompiledContract from '@Contracts/BacalhauFRC721.sol/BacalhauFRC721.json'; //On-chain address of the contract const contractAddressHyperspace = '0x773d8856dd7F78857490e5Eea65111D8d466A646'; //A public RPC Endpoint (see table from contract section) const rpc = '//api.hyperspace.node.glif.io/rpc/v1'; const provider = new ethers.providers.JsonRpcProvider(rpc); const connectedReadBacalhauContract = new ethers.Contract( contractAddressHyperspace, BacalhauCompiledContract.abi, provider );

अनुबंध पर घटनाओं के लिए सुनना। चूँकि यह केवल-पढ़ने के लिए (प्राप्त) घटना है, हम सार्वजनिक आरपीसी का उपयोग ऑन-चेन घटना उत्सर्जन को सुनने के लिए कर सकते हैं।

 //use the read-only connected Bacalhau Contract connectedReadBacalhauContract.on( // Listen for the specific event we made in our contract 'NewBacalhauFRC721NFTMinted', (sender: string, tokenId: number, tokenURI: string) => { //DO STUFF WHEN AN EVENT COMES IN // eg. re-fetch NFT's, store in state and change page status } );

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

 //Typescript needs to know window is an object with potentially and ethereum value. There might be a better way to do this? Open to tips! declare let window: any; //The compiled contract found in pages/api/hardhat/artifacts/contracts import BacalhauCompiledContract from '@Contracts/BacalhauFRC721.sol/BacalhauFRC721.json'; //On-chain address of the contract const contractAddressHyperspace = '0x773d8856dd7F78857490e5Eea65111D8d466A646'; //check for the ethereum object if (!window.ethereum) { //ask user to install a wallet or connect //abort this } // else there's a wallet provider else { // same function - different provider - this one has a signer - the user's connected wallet address const provider = new ethers.providers.Web3Provider(window.ethereum); const contract = new ethers.Contract( contractAddressHyperspace, BacalhauCompiledContract.abi, provider ); const signer = provider.getSigner(); const connectedWriteBacalhauContract = contract.connect(signer); }

राइट कनेक्टेड कॉन्ट्रैक्ट का उपयोग करके मिंट फंक्शन को कॉल करना।

सबसे पहले, सुनिश्चित करें कि हमारे पास उपयोगकर्ता का वॉलेट पता है और हम FVM हाइपरस्पेस श्रृंखला पर हैं। यहां कुछ उपयोगी वॉलेट फ़ंक्शंस हैं जो आप चाहते हैं, जिसमें चेनआईड की जांच कैसे करें, और मेटामास्क / वॉलेट में हाइपरस्पेस नेटवर्क को प्रोग्रामेटिक रूप से कैसे जोड़ा जाए।

 declare let window: any; const fetchWalletAccounts = async () => { console.log('Fetching wallet accounts...'); await window.ethereum //use ethers? .request({ method: 'eth_requestAccounts' }) .then((accounts: string[]) => { return accounts; }) .catch((error: any) => { if (error.code === 4001) { // EIP-1193 userRejectedRequest error console.log('Please connect to MetaMask.'); } else { console.error(error); } }); }; const fetchChainId = async () => { console.log('Fetching chainId...'); await window.ethereum .request({ method: 'eth_chainId' }) .then((chainId: string[]) => { return chainId; }) .catch((error: any) => { if (error.code === 4001) { // EIP-1193 userRejectedRequest error console.log('Please connect to MetaMask.'); } else { console.error(error); } }); }; //!! This function checks for a wallet connection WITHOUT being intrusive to to the user or opening their wallet export const checkForWalletConnection = async () => { if (window.ethereum) { console.log('Checking for Wallet Connection...'); await window.ethereum .request({ method: 'eth_accounts' }) .then(async (accounts: String[]) => { console.log('Connected to wallet...'); // Found a user wallet return true; }) .catch((err: Error) => { console.log('Error fetching wallet', err); return false; }); } else { //Handle no wallet connection return false; } }; //Subscribe to changes on a user's wallet export const setWalletListeners = () => { console.log('Setting up wallet event listeners...'); if (window.ethereum) { // subscribe to provider events compatible with EIP-1193 standard. window.ethereum.on('accountsChanged', (accounts: any) => { //logic to check if disconnected accounts[] is empty if (accounts.length < 1) { //handle the locked wallet case } if (userWallet.accounts[0] !== accounts[0]) { //user has changed address } }); // Subscribe to chainId change window.ethereum.on('chainChanged', () => { // handle changed chain case }); } else { //handle the no wallet case } }; export const changeWalletChain = async (newChainId: string) => { console.log('Changing wallet chain...'); const provider = window.ethereum; try { await provider.request({ method: 'wallet_switchEthereumChain', params: [{ chainId: newChainId }], //newChainId }); } catch (error: any) { alert(error.message); } }; //AddHyperspaceChain export const addHyperspaceNetwork = async () => { console.log('Adding the Hyperspace Network to Wallet...'); if (window.ethereum) { window.ethereum .request({ method: 'wallet_addEthereumChain', params: [ { chainId: '0xc45', rpcUrls: [ '//hyperspace.filfox.info/rpc/v0', '//filecoin-hyperspace.chainstacklabs.com/rpc/v0', ], chainName: 'Filecoin Hyperspace', nativeCurrency: { name: 'tFIL', symbol: 'tFIL', decimals: 18, }, blockExplorerUrls: [ '//fvm.starboard.ventures/contracts/', '//hyperspace.filscan.io/', '//beryx.zondax.chfor', ], }, ], }) .then((res: XMLHttpRequestResponseType) => { console.log('added hyperspace successfully', res); }) .catch((err: ErrorEvent) => { console.log('Error adding hyperspace network', err); }); } };

राइट मोड में कॉन्ट्रैक्ट मिंट फंक्शन को कॉल करें ....

 // Pass in the metadata return from saving to NFT.Storage const mintNFT = async (metadata: any) => { await connectedWriteBacalhauContract // The name of our function in our smart contract .mintBacalhauNFT( userWallet.accounts[0], //users account to use metadata.url //test ipfs address ) .then(async (data: any) => { console.log('CALLED CONTRACT MINT FUNCTION', data); await data .wait() .then(async (tx: any) => { console.log('tx', tx); //CURRENTLY NOT RETURNING TX - (I use event triggering to know when this function is complete) let tokenId = tx.events[1].args.tokenId.toString(); console.log('tokenId args', tokenId); setStatus({ ...INITIAL_TRANSACTION_STATE, success: successMintingNFTmsg(data), }); }) .catch((err: any) => { console.log('ERROR', err); setStatus({ ...status, loading: '', error: errorMsg(err.message, 'Error minting NFT'), }); }); }) .catch((err: any) => { console.log('ERROR1', err); setStatus({ ...status, loading: '', error: errorMsg( err && err.message ? err.message : null, 'Error minting NFT' ), }); }); }

वू - एनएफटी मिंटेड !! यूनिकॉर्न डांस मोड का समय!

🌟 अंतिम विचार: एआई और ब्लॉकचेन के लिए संभावनाएं

Bacalhau डेटा पर दोहराव, नियतात्मक प्रसंस्करण कार्य करने के लिए खुद को अच्छी तरह से उधार देता है।

• ईटीएल प्रक्रियाएं

• मशीन लर्निंग और एआई

• आईओटी डेटा एकीकरण

• सहित बैच प्रसंस्करण

  • वित्तीय और बाजार डेटा

• वीडियो और इमेज प्रोसेसिंग - क्रिएटिव के लिए बढ़िया

  
  

उपरोक्त में से कुछ को कैसे प्राप्त किया जाए, इसके में कई उदाहरण हैं।

जबकि बाकलहाऊ एफईवीएम स्मार्ट अनुबंधों से सीधे बाकलहाऊ को बुलाने के लिए एक एकीकरण का निर्माण करने में व्यस्त है, यहाँ बाकलहाऊ एक्स एफवीएम सहयोग पर कुछ विचार हैं:

• भविष्य में फिल्कॉइन डेटा की ऑनबोर्डिंग और ऑफबोर्डिंग में मदद करें
• डील और स्टोरेज प्रदाताओं के बारे में ऑन-चेन प्राप्त डेटा को प्रोसेस करके फाइलकोइन के लिए प्रतिष्ठा और सेवा की गुणवत्ता की परत बनाने में मदद करें।
• बाकलहाऊ बाजार और भुगतान डेटा के लिए गणना प्रदान कर सकता है
• Bacalhau DAO और DataDAO के डेटा को प्रोसेस करने में मदद कर सकता है
• बाकलहाऊ वीडियो और इमेज प्रोसेसिंग जैसे रचनात्मक प्रयासों के लिए अधिक स्वचालन को सशक्त बनाने में मदद कर सकता है
• Bacalhau VR और AR सहित गेम और मेटावर्स डेटा प्रोसेसिंग को सक्षम कर सकता है।
• बाकलहाऊ, आईओटी और सिमुलेशन संभव हैं
• एआई और एमएल अनुप्रयोग

🐠 बाकलहाऊ रोडमैप

वर्तमान में हम आपके स्मार्ट अनुबंधों से सीधे बाकलहाऊ को चलाने के लिए एक रास्ता तैयार कर रहे हैं !!!! इस परियोजना को प्रोजेक्ट फ्रॉग/प्रोजेक्ट लिलिपैड कहा जाता है - और यह एक एकीकरण परत होगी जो FEVM स्मार्ट अनुबंधों से बाकलहाऊ नौकरियों को बुलाने में सक्षम होगी।

हमारे न्यूज़लेटर के लिए साइन अप करके या नीचे दिए गए सोशल में शामिल होकर इसकी प्रगति पर नज़र रखें।

✍️ संपर्क में रहें!

यदि आपने पूरा पढ़ा है तो बधाई!!!

अगर यह आपके लिए उपयोगी था तो मैं लाइक, कमेंट, फॉलो या शेयर की सराहना करूंगा! <3

बाकलहाऊ के संपर्क में रहें!

• ट्विटर
• यूट्यूब
• फाइलकॉइन प्रोजेक्ट स्लैक #bacalhau
• जीथब @
• फोरम

♥️ के साथ

क्या आपको यह लेख मूल्यवान लगा?

प्रायोजक बनकर एलिसन हेयर का समर्थन करें। किसी भी राशि की सराहना की जाती है!