7. स्क्रैच/शुरुआत से एनएफटी मार्केटप्लेस कैसे बनाएं

इस ट्यूटोरियल के लिए उपयोग की जाने वाली गीटहब रिपॉजिटरी

git clone https://github.com/alchemyplatform/RTW3-Week7-NFT-Marketplace.git
cd RTW3-Week7-NFT-Marketplace
npm install
npm start

REACT_APP_ALCHEMY_API_URL="<YOUR_API_URL>"
REACT_APP_PRIVATE_KEY="<YOUR_PRIVATE_KEY>"

npm install dotenv --save

require("@nomiclabs/hardhat-waffle");
require("@nomiclabs/hardhat-ethers");
const fs = require('fs');
// const infuraId = fs.readFileSync(".infuraid").toString().trim() || "";
require('dotenv').config();

task("accounts", "Prints the list of accounts", async (taskArgs, hre) => {
  const accounts = await hre.ethers.getSigners();

  for (const account of accounts) {
    console.log(account.address);
  }
});

module.exports = {
  defaultNetwork: "hardhat",
  networks: {
    hardhat: {
      chainId: 1337
    },
    goerli: {
      url: process.env.REACT_APP_ALCHEMY_API_URL,
      accounts: [ process.env.REACT_APP_PRIVATE_KEY ]
    }
  },
  solidity: {
    version: "0.8.4",
    settings: {
      optimizer: {
        enabled: true,
        runs: 200
      }
    }
  }
};

REACT_APP_ALCHEMY_API_URL="<आपका_एपीआई_यूआरएल>"
REACT_APP_PRIVATE_KEY="<आपकी_प्राइवेट_KEY>"
REACT_APP_PINATA_KEY="<आपकी_पिनाटा_KEY>"
REACT_APP_PINATA_SECRET="<आपकी_पिनाटा_सीक्रेट>"

//SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;

//जावास्क्रिप्ट कंसोल की तरह ही स्मार्ट कॉन्ट्रैक्ट को डीबग करने के लिए कंसोल फ़ंक्शंस
import "hardhat/console.sol";
//OpenZeppelin का NFT स्टैण्डर्ड/मानक कॉन्ट्रैक्ट। हम अपने कार्यान्वयन(implementation) में इससे फंक्शन्स को एक्सटेंड करेंगे
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";

contract NFTMarketplace is ERC721URIStorage {
    constructor() ERC721("NFTMarketplace", "NFTM") {
        owner = payable(msg.sender);
    }
}

using Counters for Counters.Counter;
    //_tokenIds वैरिएबल में हाल ही में मिंट किया गया tokenId है
    Counters.Counter private _tokenIds;
    //मार्केटप्लेस में बिकने वाली items की संख्या पर नज़र रखता है
    Counters.Counter private _itemsSold;
    //owner वह कॉन्ट्रैक्ट एड्रेस है जिसने स्मार्ट कॉन्ट्रैक्ट बनाया है
    address payable owner;
    //NFT को सूचीबद्ध करने के लिए मार्केटप्लेस द्वारा लिया जाने वाला शुल्क
    uint256 listPrice = 0.01 ether;

    //सूचीबद्ध(listed) टोकन के बारे में जानकारी संग्रहीत करने की संरचना(structure)
    struct ListedToken {
        uint256 tokenId;
        address payable owner;
        address payable seller;
        uint256 price;
        bool currentlyListed;
    }

    //एक टोकन सफलतापूर्वक सूचीबद्ध(list) होने पर उत्सर्जित(emit) होने वाला इवेंट(event)
    event TokenListedSuccess (
        uint256 indexed tokenId,
        address owner,
        address seller,
        uint256 price,
        bool currentlyListed
    );

    //यह मैपिंग tokenId को token info(टोकन जानकारी) से मैप करती है और टोकन आईडी के बारे में विवरण पुनःप्राप्त करते समय सहायक होती है
    mapping(uint256 => ListedToken) private idToListedToken;

//जब पहली बार एक टोकन बनाया जाता है, वह यहाँ सूचीबद्ध(list) होता है
    function createToken(string memory tokenURI, uint256 price) public payable returns (uint) {
        //टोकनआईड काउंटर बढ़ाएँ, जो मिंट किए गए एनएफटी की संख्या पर नज़र रखता है
        _tokenIds.increment();
        uint256 newTokenId = _tokenIds.current();

        //tokenId, newTokenId के साथ NFT को उस पते पर मिंट करें जिसने createToken को कॉल किया
        _safeMint(msg.sender, newTokenId);

        //tokenId को tokenURI के साथ मैप करें (जो एनएफटी मेटाडेटा के साथ एक आईपीएफएस यूआरएल है)
        _setTokenURI(newTokenId, tokenURI);

        //ग्लोबल वेरिएबल्स को अपडेट करने और किसी ईवेंट को उत्सर्जित करने के लिए हेल्पर फ़ंक्शन
        createListedToken(newTokenId, price);

        return newTokenId;
    }

    function createListedToken(uint256 tokenId, uint256 price) private {
        //सुनिश्चित करें कि sender(प्रेषक) ने लिस्टिंग के लिए भुगतान करने के लिए पर्याप्त ETH भेजा है
        require(msg.value == listPrice, "Hopefully sending the correct price");
        //बस विवेक जांच
        require(price > 0, "Make sure the price isn't negative");

        //tokenId's की मैपिंग को टोकन विवरण/डिटेल्स में अपडेट करें, पुनर्प्राप्ति कार्यों के लिए उपयोगी
        idToListedToken[tokenId] = ListedToken(
            tokenId,
            payable(address(this)),
            payable(msg.sender),
            price,
            true
        );

        _transfer(msg.sender, address(this), tokenId);
        //सफल ट्रांसफर/हस्तांतरण के लिए ईवेंट का उत्सर्जन करें। फ्रंटएंड इस मैसेज को पार्स करता है और अंतिम उपयोगकर्ता को अपडेट करता है
        emit TokenListedSuccess(
            tokenId,
            address(this),
            msg.sender,
            price,
            true
        );
    }

//यह वर्तमान में मार्केटप्लेस पर बेचे जाने के लिए सूचीबद्ध सभी NFT लौटाएगा
    function getAllNFTs() public view returns (ListedToken[] memory) {
        uint nftCount = _tokenIds.current();
        ListedToken[] memory tokens = new ListedToken[](nftCount);
        uint currentIndex = 0;

        //फिलहाल currentlyListed सभी के लिए true है, अगर यह भविष्य में false हो जाता है
				//तो हम currentlyListed == false को यहां से फ़िल्टर कर देंगे
        for(uint i=0;i<nftCount;i++)
        {
            uint currentId = i + 1;
            ListedToken storage currentItem = idToListedToken[currentId];
            tokens[currentIndex] = currentItem;
            currentIndex += 1;
        }
        //'tokens' ऐरे के अंदर मार्केटप्लेस में सभी एनएफटीज की सूची है
        return tokens;
    }

//उन सभी NFTs को लौटाता है जिनका वर्तमान उपयोगकर्ता owner(स्वामी) या seller(विक्रेता) है
    function getMyNFTs() public view returns (ListedToken[] memory) {
        uint totalItemCount = _tokenIds.current();
        uint itemCount = 0;
        uint currentIndex = 0;
        
        //उपयोगकर्ता के लिए एक array(सरणी)बनाने से पहले जो उपयोगकर्ता से संबंधित NFTs हैं उन सभी की गिनती करना महत्वपूर्ण है 
        for(uint i=0; i < totalItemCount; i++)
        {
            if(idToListedToken[i+1].owner == msg.sender || idToListedToken[i+1].seller == msg.sender){
                itemCount += 1;
            }
        }

        //एक बार उपयोगकर्ता से संबंधित एनएफटीज की गिनती होने के बाद, एक सरणी(array) बनाएं और उसमें सभी NFTs स्टोर करें
        ListedToken[] memory items = new ListedToken[](itemCount);
        for(uint i=0; i < totalItemCount; i++) {
            if(idToListedToken[i+1].owner == msg.sender || idToListedToken[i+1].seller == msg.sender) {
                uint currentId = i+1;
                ListedToken storage currentItem = idToListedToken[currentId];
                items[currentIndex] = currentItem;
                currentIndex += 1;
            }
        }
        return items;
    }

function executeSale(uint256 tokenId) public payable {
        uint price = idToListedToken[tokenId].price;
        address seller = idToListedToken[tokenId].seller;
        require(msg.value == price, "Please submit the asking price in order to complete the purchase");

        //टोकन का विवरण(details) अपडेट करें
        idToListedToken[tokenId].currentlyListed = true;
        idToListedToken[tokenId].seller = payable(msg.sender);
        _itemsSold.increment();

        //वास्तव में टोकन को नए owner(स्वामी) को स्थानांतरित करें
        _transfer(address(this), msg.sender, tokenId);
        //मार्केटप्लेस को एनएफटी बेचने की अनुमती दे 
        approve(address(this), tokenId);

        //लिस्टिंग शुल्क को मार्केटप्लेस क्रिएटर को ट्रांसफर करें
        payable(owner).transfer(listPrice);
        //बिक्री से आय को NFT के विक्रेता को स्थानांतरित करें
        payable(seller).transfer(msg.value);
    }

function updateListPrice(uint256 _listPrice) public payable {
        require(owner == msg.sender, "Only owner can update listing price");
        listPrice = _listPrice;
    }

    function getListPrice() public view returns (uint256) {
        return listPrice;
    }

    function getLatestIdToListedToken() public view returns (ListedToken memory) {
        uint256 currentTokenId = _tokenIds.current();
        return idToListedToken[currentTokenId];
    }

    function getListedTokenForId(uint256 tokenId) public view returns (ListedToken memory) {
        return idToListedToken[tokenId];
    }

    function getCurrentToken() public view returns (uint256) {
        return _tokenIds.current();
    }

//SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;

import "hardhat/console.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";

contract NFTMarketplace is ERC721URIStorage {

    using Counters for Counters.Counter;
    //_tokenIds वैरिएबल में हाल ही में मिंट किया गया tokenId है
    Counters.Counter private _tokenIds;
    //मार्केटप्लेस में बिकने वाली वस्तुओं की संख्या पर नज़र रखता है
    Counters.Counter private _itemsSold;
    //owner वह कॉन्ट्रैक्ट एड्रेस है जिसने स्मार्ट कॉन्ट्रैक्ट बनाया है
    address payable owner;
    //NFT को सूचीबद्ध करने के लिए मार्केटप्लेस द्वारा लिया जाने वाला शुल्क
    uint256 listPrice = 0.01 ether;

    //सूचीबद्ध(listed) टोकन के बारे में जानकारी संग्रहीत करने की संरचना
    struct ListedToken {
        uint256 tokenId;
        address payable owner;
        address payable seller;
        uint256 price;
        bool currentlyListed;
    }

    //एक टोकन सफलतापूर्वक सूचीबद्ध(list) होने पर उत्सर्जित होने वाला इवेंट(event)
    event TokenListedSuccess (
        uint256 indexed tokenId,
        address owner,
        address seller,
        uint256 price,
        bool currentlyListed
    );

    //यह मैपिंग tokenId को टोकन जानकारी(token info) से मैप करती है और टोकन आईडी के बारे में विवरण पुनर्प्राप्त करते समय सहायक होती है
    mapping(uint256 => ListedToken) private idToListedToken;

    constructor() ERC721("NFTMarketplace", "NFTM") {
        owner = payable(msg.sender);
    }

    function updateListPrice(uint256 _listPrice) public payable {
        require(owner == msg.sender, "Only owner can update listing price");
        listPrice = _listPrice;
    }

    function getListPrice() public view returns (uint256) {
        return listPrice;
    }

    function getLatestIdToListedToken() public view returns (ListedToken memory) {
        uint256 currentTokenId = _tokenIds.current();
        return idToListedToken[currentTokenId];
    }

    function getListedTokenForId(uint256 tokenId) public view returns (ListedToken memory) {
        return idToListedToken[tokenId];
    }

    function getCurrentToken() public view returns (uint256) {
        return _tokenIds.current();
    }

    //जब पहली बार एक टोकन बनाया जाता है, वह यहाँ सूचीबद्ध(list) होता है
    function createToken(string memory tokenURI, uint256 price) public payable returns (uint) {
        //टोकनआईड काउंटर बढ़ाएँ, जो मिंट किए गए एनएफटी की संख्या पर नज़र रखता है
        _tokenIds.increment();
        uint256 newTokenId = _tokenIds.current();

        //tokenId, newTokenId के साथ NFT को उस पते पर मिंट करें जिसने createToken को कॉल किया
        _safeMint(msg.sender, newTokenId);

        //tokenId को tokenURI के साथ मैप करें (जो एनएफटी मेटाडेटा के साथ एक आईपीएफएस यूआरएल है)
        _setTokenURI(newTokenId, tokenURI);

        //ग्लोबल वेरिएबल्स को अपडेट करने और किसी ईवेंट को उत्सर्जित करने के लिए हेल्पर फ़ंक्शन
        createListedToken(newTokenId, price);

        return newTokenId;
    }

    function createListedToken(uint256 tokenId, uint256 price) private {
        //सुनिश्चित करें कि sender(प्रेषक) ने लिस्टिंग के लिए भुगतान करने के लिए पर्याप्त ETH भेजा है
        require(msg.value == listPrice, "Hopefully sending the correct price");
        //बस विवेक जांच
        require(price > 0, "Make sure the price isn't negative");

        //tokenId's की मैपिंग को टोकन विवरण/डिटेल्स में अपडेट करें, पुनर्प्राप्ति कार्यों के लिए उपयोगी
        idToListedToken[tokenId] = ListedToken(
            tokenId,
            payable(address(this)),
            payable(msg.sender),
            price,
            true
        );

        _transfer(msg.sender, address(this), tokenId);
        //सफल ट्रांसफर/हस्तांतरण के लिए ईवेंट का उत्सर्जन करें। फ्रंटएंड इस मैसेज को पार्स करता है और अंतिम उपयोगकर्ता को अपडेट करता है
        emit TokenListedSuccess(
            tokenId,
            address(this),
            msg.sender,
            price,
            true
        );
    }
    
   //यह वर्तमान में मार्केटप्लेस पर बेचे जाने के लिए सूचीबद्ध सभी NFT लौटाएगा
    function getAllNFTs() public view returns (ListedToken[] memory) {
        uint nftCount = _tokenIds.current();
        ListedToken[] memory tokens = new ListedToken[](nftCount);
        uint currentIndex = 0;

        //फिलहाल currentlyListed सभी के लिए true है, अगर यह भविष्य में false हो जाता है
				//तो हम currentlyListed == false को यहां से फ़िल्टर कर देंगे
        for(uint i=0;i<nftCount;i++)
        {
            uint currentId = i + 1;
            ListedToken storage currentItem = idToListedToken[currentId];
            tokens[currentIndex] = currentItem;
            currentIndex += 1;
        }
        //'tokens' ऐरे के अंदर मार्केटप्लेस में सभी एनएफटीज की सूची है
        return tokens;
    }
    
    //उन सभी NFTs को लौटाता है जिनका वर्तमान उपयोगकर्ता स्वामी(owner) या विक्रेता(seller) है
    function getMyNFTs() public view returns (ListedToken[] memory) {
        uint totalItemCount = _tokenIds.current();
        uint itemCount = 0;
        uint currentIndex = 0;
        
        //उपयोगकर्ता के लिए एक array(सरणी)बनाने से पहले जो उपयोगकर्ता से संबंधित NFTs हैं उन सभी की गिनती करना महत्वपूर्ण है 
        for(uint i=0; i < totalItemCount; i++)
        {
            if(idToListedToken[i+1].owner == msg.sender || idToListedToken[i+1].seller == msg.sender){
                itemCount += 1;
            }
        }

        //एक बार आपके पास उपयोगकर्ता से संबंधित एनएफटी की गिनती होने के बाद, एक सरणी(array) बनाएं और उसमें सभी NFTs स्टोर करें
        ListedToken[] memory items = new ListedToken[](itemCount);
        for(uint i=0; i < totalItemCount; i++) {
            if(idToListedToken[i+1].owner == msg.sender || idToListedToken[i+1].seller == msg.sender) {
                uint currentId = i+1;
                ListedToken storage currentItem = idToListedToken[currentId];
                items[currentIndex] = currentItem;
                currentIndex += 1;
            }
        }
        return items;
    }

    function executeSale(uint256 tokenId) public payable {
        uint price = idToListedToken[tokenId].price;
        address seller = idToListedToken[tokenId].seller;
        require(msg.value == price, "Please submit the asking price in order to complete the purchase");

        //टोकन का विवरण(details) अपडेट करें
        idToListedToken[tokenId].currentlyListed = true;
        idToListedToken[tokenId].seller = payable(msg.sender);
        _itemsSold.increment();

        //वास्तव में टोकन को नए स्वामी को स्थानांतरित करें
        _transfer(address(this), msg.sender, tokenId);
        //मार्केटप्लेस को एनएफटी बेचने की अनुमती दे 
        approve(address(this), tokenId);

        //लिस्टिंग शुल्क को मार्केटप्लेस क्रिएटर को ट्रांसफर करें
        payable(owner).transfer(listPrice);
        //बिक्री से आय को NFT के विक्रेता को स्थानांतरित करें
        payable(seller).transfer(msg.value);
    }

    //हम भविष्य में एक पुनर्विक्रय(resell) टोकन फंक्शन जोड़ सकते हैं
    //उस स्थिति में, टोकन डिफ़ॉल्ट रूप से सूचीबद्ध(list) नहीं होंगे, लेकिन उपयोगकर्ता वास्तव में टोकन सूचीबद्ध करने के लिए अनुरोध भेज सकते हैं
    //वर्तमान में एनएफटी डिफ़ॉल्ट रूप से सूचीबद्ध(listed) हैं
}

const { ethers } = require("hardhat");
const hre = require("hardhat");
const fs = require("fs");

async function main() {
  //signer(हस्ताक्षरकर्ता) प्राप्त करें जिसका उपयोग हम परिनियोजित(deploy) करने के लिए करेंगे
  const [deployer] = await ethers.getSigners();
  
  //NFTMarketplace स्मार्ट कॉन्ट्रैक्ट ऑब्जेक्ट प्राप्त करें और इसे तैनात(deploy) करें
  const Marketplace = await hre.ethers.getContractFactory("NFTMarketplace");
  const marketplace = await Marketplace.deploy();

  await marketplace.deployed();
  
  //तैनाती(deployment) के दौरान पता(Address) और एबीआई(ABI) को स्टोर कर लें, क्योंकि यह बाद में स्मार्ट कॉन्ट्रैक्ट के साथ बातचीत(interact)करने के लिए चाहिए होंगे
  const data = {
    address: marketplace.address,
    abi: JSON.parse(marketplace.interface.format('json'))
  }

  //यह Marketplace.json को ABI और Address(एड्रेस)लिखता है
  //यह डेटा फिर स्मार्ट कॉन्ट्रैक्ट से जुड़ने के लिए फ्रंटएंड फाइलों द्वारा उपयोग किया जाता है
  fs.writeFileSync('./src/Marketplace.json', JSON.stringify(data))
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });

npx hardhat run --network goerli scripts/deploy.js

//require('dotenv').config();
const key = process.env.REACT_APP_PINATA_KEY;
const secret = process.env.REACT_APP_PINATA_SECRET;

const axios = require('axios');
const FormData = require('form-data');

export const uploadJSONToIPFS = async(JSONBody) => {
    const url = `https://api.pinata.cloud/pinning/pinJSONToIPFS`;
    //Pinata ⬇️ के लिए Axios POST request बनाना
    return axios 
        .post(url, JSONBody, {
            headers: {
                pinata_api_key: key,
                pinata_secret_api_key: secret,
            }
        })
        .then(function (response) {
           return {
               success: true,
               pinataURL: "https://gateway.pinata.cloud/ipfs/" + response.data.IpfsHash
           };
        })
        .catch(function (error) {
            console.log(error)
            return {
                success: false,
                message: error.message,
            }

    });
};

export const uploadFileToIPFS = async(file) => {
    const url = `https://api.pinata.cloud/pinning/pinFileToIPFS`;
    //Pinata ⬇️ के लिए Axios POST request बनाना
    
    let data = new FormData();
    data.append('file', file);

    const metadata = JSON.stringify({
        name: 'testname',
        keyvalues: {
            exampleKey: 'exampleValue'
        }
    });
    data.append('pinataMetadata', metadata);

    //pinataOptions वैकल्पिक(optional) हैं
    const pinataOptions = JSON.stringify({
        cidVersion: 0,
        customPinPolicy: {
            regions: [
                {
                    id: 'FRA1',
                    desiredReplicationCount: 1
                },
                {
                    id: 'NYC1',
                    desiredReplicationCount: 2
                }
            ]
        }
    });
    data.append('pinataOptions', pinataOptions);

    return axios 
        .post(url, data, {
            maxBodyLength: 'Infinity',
            headers: {
                'Content-Type': `multipart/form-data; boundary=${data._boundary}`,
                pinata_api_key: key,
                pinata_secret_api_key: secret,
            }
        })
        .then(function (response) {
            console.log("image uploaded", response.data.IpfsHash)
            return {
               success: true,
               pinataURL: "https://gateway.pinata.cloud/ipfs/" + response.data.IpfsHash
           };
        })
        .catch(function (error) {
            console.log(error)
            return {
                success: false,
                message: error.message,
            }

    });
};

//यह फ़ंक्शन NFT इमेज को IPFS में अपलोड करता है
    async function OnChangeFile(e) {
        var file = e.target.files[0];
        //फ़ाइल एक्सटेंशन के लिए जाँच करें
        try {
            //फ़ाइल को IPFS में अपलोड करें
            const response = await uploadFileToIPFS(file);
            if(response.success === true) {
                console.log("Uploaded image to Pinata: ", response.pinataURL)
                setFileURL(response.pinataURL);
            }
        }
        catch(e) {
            console.log("Error during file upload", e);
        }
    }

    //यह फ़ंक्शन मेटाडेटा को IPFS पर अपलोड करता है
    async function uploadMetadataToIPFS() {
        const {name, description, price} = formParams;
        //सुनिश्चित करें कि कोई भी फ़ील्ड खाली नहीं है
        if( !name || !description || !price || !fileURL)
            return;

        const nftJSON = {
            name, description, price, image: fileURL
        }

        try {
            //मेटाडेटा JSON को IPFS पर अपलोड करें
            const response = await uploadJSONToIPFS(nftJSON);
            if(response.success === true){
                console.log("Uploaded JSON to Pinata: ", response)
                return response.pinataURL;
            }
        }
        catch(e) {
            console.log("error uploading JSON metadata:", e)
        }
    }

    async function listNFT(e) {
        e.preventDefault();

        //IPFS में डेटा अपलोड करें
        try {
            const metadataURL = await uploadMetadataToIPFS();
            //आपके हार्डहैट नेटवर्क को मेटामास्क में जोड़ने के बाद, इस कोड को प्रोवाइडर्स एंड साइनर्स(providers and signers) मिल जाएंगे
            const provider = new ethers.providers.Web3Provider(window.ethereum);
            const signer = provider.getSigner();
            updateMessage("Please wait.. uploading (upto 5 mins)")

            //डिप्लोइड कॉन्ट्रैक्ट का इंस्टैंस खीचें
            let contract = new ethers.Contract(Marketplace.address, Marketplace.abi, signer)

            //NFT रिक्वेस्ट बनाने के लिए भेजे जाने वाले पैरामीटर्स मेसेज करे          
            const price = ethers.utils.parseUnits(formParams.price, 'ether')
            let listingPrice = await contract.getListPrice()
            listingPrice = listingPrice.toString()

            //वास्तव में एनएफटी बनाएं
            let transaction = await contract.createToken(metadataURL, price, { value: listingPrice })
            await transaction.wait()

            alert("Successfully listed your NFT!");
            updateMessage("");
            updateFormParams({ name: '', description: '', price: ''});
            window.location.replace("/")
        }
        catch(e) {
            alert( "Upload error"+e )
        }
    }

const [dataFetched, updateFetched] = useState(false);

async function getAllNFTs() {
    const ethers = require("ethers");
    //आपके हार्डहैट नेटवर्क को मेटामास्क में जोड़ने के बाद, इस कोड को प्रोवाइडर्स एंड साइनर्स(providers and signers) मिल जाएंगे
    const provider = new ethers.providers.Web3Provider(window.ethereum);
    const signer = provider.getSigner();
    //डिप्लोयड कॉन्ट्रैक्ट इंस्टैंस(instance)खीचें
    let contract = new ethers.Contract(MarketplaceJSON.address, MarketplaceJSON.abi, signer)
    //एक एनएफटी टोकन बनाएं
    let transaction = await contract.getAllNFTs()

    //कॉन्ट्रैक्ट से प्रत्येक NFT के सभी विवरण(details) प्राप्त करें और प्रदर्शित(display) करें 
    const items = await Promise.all(transaction.map(async i => {
        const tokenURI = await contract.tokenURI(i.tokenId);
        let meta = await axios.get(tokenURI);
        meta = meta.data;

        let price = ethers.utils.formatUnits(i.price.toString(), 'ether');
        let item = {
            price,
            tokenId: i.tokenId.toNumber(),
            seller: i.seller,
            owner: i.owner,
            image: meta.image,
            name: meta.name,
            description: meta.description,
        }
        return item;
    }))

    updateFetched(true);
    updateData(items);
}

if(!dataFetched)
    getAllNFTs();

const [dataFetched, updateFetched] = useState(false);

    async function getNFTData(tokenId) {
        const ethers = require("ethers");
        let sumPrice = 0;

        //आपके हार्डहैट नेटवर्क को मेटामास्क में जोड़ने के बाद, इस कोड को प्रोवाइडर्स एंड साइनर्स(providers and signers) मिल जाएंगे
        const provider = new ethers.providers.Web3Provider(window.ethereum);
        const signer = provider.getSigner();
        const addr = await signer.getAddress();

        //डिप्लोयड कॉन्ट्रैक्ट इंस्टैंस(instance)खीचें
        let contract = new ethers.Contract(MarketplaceJSON.address, MarketplaceJSON.abi, signer)

        //एक एनएफटी टोकन बनाएं
        let transaction = await contract.getMyNFTs()

        /*
        * नीचे दिया गया फ़ंक्शन tokenURI से मेटाडेटा और डेटा जो getMyNFTs() कॉन्ट्रैक्ट फ़ंक्शन द्वारा लौटाया गया है उसे लेता है 
				* और इनफार्मेशन का एक ऑब्जेक्ट बनाता है जिसे प्रदर्शित किया जाना है
        */
        
        const items = await Promise.all(transaction.map(async i => {
            const tokenURI = await contract.tokenURI(i.tokenId);
            let meta = await axios.get(tokenURI);
            meta = meta.data;

            let price = ethers.utils.formatUnits(i.price.toString(), 'ether');
            let item = {
                price,
                tokenId: i.tokenId.toNumber(),
                seller: i.seller,
                owner: i.owner,
                image: meta.image,
                name: meta.name,
                description: meta.description,
            }
            sumPrice += Number(price);
            return item;
        }))

        updateData(items);
        updateFetched(true);
        updateAddress(addr);
        updateTotalPrice(sumPrice.toPrecision(3));
    }

    const params = useParams();
    const tokenId = params.tokenId;
    if(!dataFetched)
        getNFTData(tokenId);

async function getNFTData(tokenId) {
    const ethers = require("ethers");
    //आपके हार्डहैट नेटवर्क को मेटामास्क में जोड़ने के बाद, इस कोड को प्रोवाइडर्स एंड साइनर्स(providers and signers) मिल जाएंगे
    const provider = new ethers.providers.Web3Provider(window.ethereum);
    const signer = provider.getSigner();
    //डिप्लोयड कॉन्ट्रैक्ट इंस्टैंस(instance)खीचें
    let contract = new ethers.Contract(MarketplaceJSON.address, MarketplaceJSON.abi, signer)
    //एक एनएफटी टोकन बनाएं
    const tokenURI = await contract.tokenURI(tokenId);
    const listedToken = await contract.getListedTokenForId(tokenId);
    let meta = await axios.get(tokenURI);
    meta = meta.data;
    console.log(listedToken);

    let item = {
        price: meta.price,
        tokenId: tokenId,
        seller: listedToken.seller,
        owner: listedToken.owner,
        image: meta.image,
        name: meta.name,
        description: meta.description,
    }
    console.log(item);
    updateData(item);
}

async function buyNFT(tokenId) {
    try {
        const ethers = require("ethers");
        //आपके हार्डहैट नेटवर्क को मेटामास्क में जोड़ने के बाद, इस कोड को प्रोवाइडर्स एंड साइनर्स(providers and signers) मिल जाएंगे
        const provider = new ethers.providers.Web3Provider(window.ethereum);
        const signer = provider.getSigner();
         //डिप्लोयड कॉन्ट्रैक्ट इंस्टैंस(instance)खीचें
        let contract = new ethers.Contract(MarketplaceJSON.address, MarketplaceJSON.abi, signer);
        const salePrice = ethers.utils.parseUnits(data.price, 'ether')
        let transaction = await contract.executeSale(tokenId, {value:salePrice});
        await transaction.wait();

        alert('You successfully bought the NFT!');
    }
    catch(e) {
        alert("Upload Error"+e)
    }
}