call revert exception (Lesson 15)

[haaarshit]

Getting error while testing my contracts (When calling the ownerOf function)

Error ->

  Error: call revert exception (method="ownerOf(uint256)", errorArgs=null, errorName=null, errorSignature=null, reason=null, code=CALL_EXCEPTION, version=abi/5.4.0)

Test file ->
nftMarketPlace.test.js

const { network, ethers, deployments, getNamedAccounts } = require("hardhat");
const { developmentChains } = require("../../helper-hardhat-config");
const { assert } = require("chai");

!developmentChains.includes(network.name) ?
    describe.skip
    :
    describe("nftMarketPlace", () => {
        let nftMarketPlace, deployer, player, basicNft
        const price = ethers.utils.parseEther("0.1")
        const tokenId = 0
        beforeEach(async () => {
            accounts = await ethers.getSigners()
            deployer = accounts[0]
            player = accounts[1]
            await deployments.fixture['all']
            nftMarketPlace = await ethers.getContractAt("NftMarketPlace", "0x5FbDB2315678afecb367f032d93F642f64180aa3", deployer)
            basicNft = await ethers.getContractAt("BasicNft", "0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512", deployer)
          
            await basicNft.mintNft()
            await basicNft.approve(nftMarketPlace.address, tokenId)
        })
        it("List NFT", async () => {
            await nftMarketPlace.listItem(basicNft.address, tokenId, price)
            const connectPlayerNftMarketPlace = nftMarketPlace.connect(player)
            await connectPlayerNftMarketPlace.buyItem(basicNft.address, tokenId, {
                value: price
            })
            const newOwner = await basicNft.ownerOf(tokenId)
            const deployerProcceds = await nftMarketPlace.getProceeds(deployer)
            assert(newOwner.toString() == player)
            assert(deployerProcceds.toString() == price.toString())
        })
    })

NftMarketPlace.sol file

// SPDX-License-Identifier:MIT
pragma solidity ^0.8.7;

import "@openzeppelin/contracts/token/ERC721/IERC721.sol";

error NftMarketPlace_PriceMustBeAboveZero();
error NftMarketPlace_NotApprovedForMarketPlace();
error NftMarketPlace_NftAlreadyListed(address nftAddress, uint256 tokenId);
error NftMarketPlace_NotOwner();
error NftMarketPlace_NotListed(address nftAddress, uint256 tokenId);
error NftMarketPlace_PriceNotMet(address nftAddress, uint256 tokenId, uint256);
error NftMarketPlace_noProceeds();
error NftMarketPlace_TransferFailed();

contract NftMarketPlace {
    //  custom types
    struct Listing {
        uint256 price;
        address seller;
    }

    // events
    event itemListed(
        address indexed seller,
        address indexed nftAddress,
        uint256 indexed tokenId,
        uint256 price
    );
    event ItemBought(
        address indexed buyer,
        address indexed nftAddress,
        uint256 indexed tokenId,
        uint256 price
    );
    event ListItemCanceled(
        address indexed seller,
        address indexed nftAddress,
        uint256 indexed tokenId
    );

    // states
    // nft address -> nft tokenId -> Listing
    mapping(address => mapping(uint256 => Listing)) private s_listing;
    // seller address -> amount earned
    mapping(address => uint256) private s_proceeds;

    // modifier
    // check if item is already listed
    modifier notListed(
        address nftAddress,
        uint256 tokenId,
        address owner
    ) {
        Listing memory listing = s_listing[nftAddress][tokenId];
        if (listing.price > 0) {
            revert NftMarketPlace_NftAlreadyListed(nftAddress, tokenId);
        }
        _;
    }

    // cheack wheather the sender is owner of the nft or not
    modifier isOwner(
        address nftAddress,
        uint256 tokenId,
        address spender
    ) {
        IERC721 nft = IERC721(nftAddress);
        address owner = nft.ownerOf(tokenId);
        if (spender != owner) {
            revert NftMarketPlace_NotOwner();
        }
        _;
    }

    modifier isListed(address nftAddress, uint256 tokenId) {
        Listing memory listing = s_listing[nftAddress][tokenId];
        if (listing.price <= 0) {
            revert NftMarketPlace_NotListed(nftAddress, tokenId);
        }
        _;
    }

    // function

    /**
     * @notice  method for listing the nft on the market place
     */
    function listItem(
        address nftAddress,
        uint256 tokenId,
        uint256 price
    )
        external
        notListed(nftAddress, tokenId, msg.sender)
        isOwner(nftAddress, tokenId, msg.sender)
    {
        if (price <= 0) {
            revert NftMarketPlace_PriceMustBeAboveZero();
        }
        // Ensure that marketplace has approvel to list the nft -> Owner has given the permission to sell their nft on marketplace
        IERC721 nft = IERC721(nftAddress);
        if (nft.getApproved(tokenId) != address(this)) {
            revert NftMarketPlace_NotApprovedForMarketPlace();
        }
        s_listing[nftAddress][tokenId] = Listing(price, msg.sender);
        emit itemListed(msg.sender, nftAddress, tokenId, price);
    }

    function buyItem(
        address nftAddress,
        uint256 tokenId
    ) external payable isListed(nftAddress, tokenId) {
        Listing memory listedItem = s_listing[nftAddress][tokenId];
        // make sure buyer has send enough money
        if (msg.value < listedItem.price) {
            revert NftMarketPlace_PriceNotMet(
                nftAddress,
                tokenId,
                listedItem.price
            );
        }
        s_proceeds[listedItem.seller] =
            s_proceeds[listedItem.seller] +
            msg.value;
        delete (s_listing[nftAddress][tokenId]);
        // Transfer nft
        IERC721(nftAddress).safeTransferFrom(
            listedItem.seller,
            msg.sender,
            tokenId
        );
        emit ItemBought(msg.sender, nftAddress, tokenId, listedItem.price);
    }

    // only owner can cancel Listing
    function cancelListing(
        address nftAddress,
        uint256 tokenId
    )
        external
        isOwner(nftAddress, tokenId, msg.sender)
        isListed(nftAddress, tokenId)
    {
        delete (s_listing[nftAddress][tokenId]);
        emit ListItemCanceled(msg.sender, nftAddress, tokenId);
    }

    function updateListing(
        address nftAddress,
        uint256 tokenId,
        uint256 newPrice
    )
        external
        isOwner(nftAddress, tokenId, msg.sender)
        isListed(nftAddress, tokenId)
    {
        s_listing[nftAddress][tokenId].price = newPrice;
        emit itemListed(msg.sender, nftAddress, tokenId, newPrice);
    }

    function withdrawProcedds() external {
        uint256 proceeds = s_proceeds[msg.sender];
        if (proceeds <= 0) {
            revert NftMarketPlace_noProceeds();
        }
        s_proceeds[msg.sender] = 0;
        (bool success, ) = payable(msg.sender).call{value: proceeds}("");
        if (!success) {
            revert NftMarketPlace_TransferFailed();
        }
    }

    // getter functions
    function getListing( address nftAddress, uint256 tokenId) external view returns (Listing memory) {
        return s_listing[nftAddress][tokenId];
    }

    function getProceeds(address seller) external view returns (uint256) {
        return s_proceeds[seller];
    }
}

//    `listNft` function : To List NFT on MarketPlace
//    `buyItem` : Buy the NFT
//    `cancelItem` : Cancel the listing
//    `update the listing` :  Update the price
//    `withdrawProceeds` : Withdraw payments for my bought nft

BasicNft.sol File

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";

contract BasicNft is ERC721 {
    string public constant TOKEN_URI =
        "ipfs://bafybeig37ioir76s7mg5oobetncojcm3c3hxasyd4rvid4jqhy4gkaheg4/?filename=0-PUG.json";
    uint256 private s_tokenCounter;
    
    event DogMinted(uint256 indexed tokenId);

    constructor() ERC721("Dogie", "DOG") {
        s_tokenCounter = 0;
    }

    function mintNft() public {
        _safeMint(msg.sender, s_tokenCounter);
        emit DogMinted(s_tokenCounter);
        s_tokenCounter = s_tokenCounter + 1;
    }

    function tokenURI(uint256 tokenId) public view override returns (string memory) {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
        return TOKEN_URI;
    }

    function getTokenCounter() public view returns (uint256) {
        return s_tokenCounter;
    }
}

Deploy scripts
1 -> NftMarketPlace

const { network } = require("hardhat")
const { developmentChains } = require("../helper-hardhat-config")
const verify = require("../utils/verify")

module.exports = async ({ getNamedAccounts, deployments }) => {
    const { deployer } = await getNamedAccounts()
    const { deploy, log } = deployments
    log("-----------------------------------")
    const nftMarketPlace = await deploy("NftMarketPlace", {
        from: deployer,
        log: true,
        args: [],
        waitConfirmations: network.config.blockConfirmations || 1
    })
    if (!developmentChains.includes(network.name) && process.env.ETHERSCAN_API_KEY) {
        verify(await nftMarketPlace.address, [])
    }
    log('------------------------------------')
}
module.exports.tags = ["all", "nftmarketplace"]

2 -> BasicNft

const { network, ethers } = require("hardhat")
const { developmentChains } = require("../helper-hardhat-config")
const verify = require("../utils/verify")

module.exports = async ({ getNamedAccounts, deployments }) => {
    const { deployer } = await getNamedAccounts()
    const { deploy, log } = deployments
    log('-----------------------------------')
    const basicNft = await deploy("BasicNft",{
        from:deployer,
        args:[],
        log:true,
        waitConfirmations:network.config.blockConfirmations || 1
    })

    if (!developmentChains.includes(network.name) && process.env.ETHERSCAN_API_KEY) {
        verify(await basicNft.address, [])
    }
    log('-----------------------------------')
}
module.exports.tags = ["all","basicnft"]

[Nlferu]

Hello @coderharsx1122

Your tokenId is just undefined... In your nftMarketPlace.test.js change following to properly set tokenId:

// Change const to let (you will be able to override this)
let tokenId = 0

// Add following in beforeEach
beforeEach(async () => {
tokenId = 0
})

Your new code should look like this:

const { network, ethers, deployments, getNamedAccounts } = require("hardhat")
const { developmentChains } = require("../../helper-hardhat-config")
const { assert } = require("chai")

!developmentChains.includes(network.name)
    ? describe.skip
    : describe("nftMarketPlace", () => {
          let nftMarketPlace, deployer, player, basicNft
          const price = ethers.utils.parseEther("0.1")
          let tokenId = 0
          beforeEach(async () => {
              accounts = await ethers.getSigners()
              deployer = accounts[0]
              player = accounts[1]
              tokenId = 0

              await deployments.fixture["all"]
              nftMarketPlace = await ethers.getContractAt("NftMarketPlace", "0x5FbDB2315678afecb367f032d93F642f64180aa3", deployer)
              basicNft = await ethers.getContractAt("BasicNft", "0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512", deployer)

              await basicNft.mintNft()
              await basicNft.approve(nftMarketPlace.address, tokenId)
          })
          it("List NFT", async () => {
              await nftMarketPlace.listItem(basicNft.address, tokenId, price)
              const connectPlayerNftMarketPlace = nftMarketPlace.connect(player)
              await connectPlayerNftMarketPlace.buyItem(basicNft.address, tokenId, {
                  value: price,
              })
              const newOwner = await basicNft.ownerOf(tokenId)
              const deployerProcceds = await nftMarketPlace.getProceeds(deployer)
              assert(newOwner.toString() == player)
              assert(deployerProcceds.toString() == price.toString())
          })
      })