lesson 14: "04-mint.js" Error while deploying Random IPFS NFT

[M-Marcel]

Hello guys, I ran into this error anytime I run the 04-mint.js script from lesson 14

An unexpected error occurred:

Error: ERROR processing /.../nft-full-art/deploy/04-mint.js:
Error: call revert exception; VM Exception while processing transaction: reverted with reason string "ERC721: invalid token ID" [ See: https://links.ethers.org/v5-errors-CALL_EXCEPTION ] (method="tokenURI(uint256)", data="0x08c379a0000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000184552433732313a20696e76616c696420746f6b656e2049440000000000000000", errorArgs=["ERC721: invalid token ID"], errorName="Error", errorSignature="Error(string)", reason="ERC721: invalid token ID", code=CALL_EXCEPTION, version=abi/5.6.4) at Logger.makeError (/.../nft-full-art/node_modules/@ethersproject/logger/src.ts/index.ts:261:28) ...

here is my 04-mint.js

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

module.exports = async ({ getNamedAccounts, deployments }) => {
    const { deployer } = await getNamedAccounts()
    const chainId = network.config.chainId

    // Basic NFT
    const basicNft = await ethers.getContract("BasicNft", deployer)
    const basicMintTx = await basicNft.mintNFT()
    await basicMintTx.wait(1)
    console.log(`Basic NFT index 0 tokenURI: ${await basicNft.tokenURI(0)}`)

    // Dynamic SVG  NFT
    // const lowValue = ethers.utils.parseEther("1")
    const highValue = ethers.utils.parseEther("1")
    const dynamicSvgNft = await ethers.getContract("DynamicSvgNft", deployer)
    const dynamicSvgNftMintTx = await dynamicSvgNft.mintNft(highValue)
    await dynamicSvgNftMintTx.wait(1)
    console.log(`Dynamic SVG NFT index 0 tokenURI: ${await dynamicSvgNft.tokenURI(0)}`)
    console.log(`Dynamic SVG NFT lowImageURI: ${await dynamicSvgNft.getLowSVG()}`)
    console.log(`Dynamic SVG NFT highImageURI: ${await dynamicSvgNft.getHighSVG()}`)

    // Random IPFS NFT
    const randomIpfsNft = await ethers.getContract("RandomIpfsNft", deployer)
    const mintFee = await randomIpfsNft.getMintFee()

    // Need to listen for response
    await new Promise(async (resolve) => {
        setTimeout(resolve, 500000) // 5 minute timeout time
        // setup listener for our event
        randomIpfsNft.once("NftMinted", async () => {
            resolve()
        })
        const randomIpfsNftMintTx = await randomIpfsNft.requestNft({ value: mintFee.toString() })
        const randomIpfsNftMintTxReceipt = await randomIpfsNftMintTx.wait(1)
        // if (developmentChains.includes(network.name)) {
        if (chainId == 31337) {
            const requestId = randomIpfsNftMintTxReceipt.events[1].args.requestId.toString()
            const vrfCoordinatorV2Mock = await ethers.getContract("VRFCoordinatorV2Mock", deployer)
            await vrfCoordinatorV2Mock.fulfillRandomWords(requestId, randomIpfsNft.address)
        }
    })
    console.log(`Random IPFS NFT index 0 tokenURI: ${await randomIpfsNft.tokenURI(0)}`)
}
module.exports.tags = ["all", "mint"]

Here is my RandomIpfsNft.sol

// SPDX-License-Identifier: SEE LICENSE IN LICENSE
pragma solidity ^0.8.9;
import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";
import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

error RandomIpfsNft__RangeOutOfBounds();
error RandomIpfsNft__NeedMoreETHSent();
error RandomIpfsNft__TransferFailed();
error RandomIpfsNft__AlreadyInitialized();

contract RandomIpfsNft is VRFConsumerBaseV2, ERC721URIStorage, Ownable {
    /*Process
    1. When we mint an NFT, we triger a Chainlink VRF call to get us a random number
    2. Using that random number, we will get a random NFT
    3. NFT category are: ROSE, BUTTERFLY and SOUND_OF_MUSIC
    4. ROSE => Super-rare 
    5. BUTTERFLY => sort of rare
    6. SOUND_OF_MUSIC => common
    7. Users have to pay to mint an NFT
    8. Only the owner of the contract can withdraw the ETH
    */

    // Type declaration
    enum Art {
        ROSE,
        BUTTERFLY,
        SOUND_OF_MUSIC
    }
    // Chainlink VRF Variables
    VRFCoordinatorV2Interface private immutable i_vrfCoordinator;
    uint64 private immutable i_subcriptionId;
    bytes32 private immutable i_gasLane;
    uint32 private immutable i_callbackGasLimit;
    uint16 private constant REQUEST_CONFIRMATIONS = 3;
    uint32 private constant NUM_WORDS = 1;

    //VRF Helpers
    mapping(uint256 => address) public s_requestIdToSender;

    // NFT Variable
    uint256 public s_tokenCounter;
    uint256 private constant MAX_CHANCE_VALUE = 100;
    string[] internal s_nenyeTokenUris;
    uint256 internal immutable i_mintFee;
    mapping(uint256 => Art) private s_tokenIdToArt;
    bool private s_initialized;

    //Events
    event NftRequested(uint256 indexed requestId, address minter);
    event NftMinted(Art nenyeArt, address minter);

    constructor(
        address vrfCoordinatorV2,
        uint64 subcriptionId,
        bytes32 gasLane,
        uint32 callbackGasLimit,
        string[3] memory nenyeTokenUris,
        uint256 mintFee
    ) VRFConsumerBaseV2(vrfCoordinatorV2) ERC721("Nenye_NFT", "NNE") {
        i_vrfCoordinator = VRFCoordinatorV2Interface(vrfCoordinatorV2);
        i_subcriptionId = subcriptionId;
        i_gasLane = gasLane;
        i_callbackGasLimit = callbackGasLimit;
        // s_nenyeTokenUris = nenyeTokenUris;
        i_mintFee = mintFee;
        _initializeContract(nenyeTokenUris);
    }

    function requestNft() public payable returns (uint256 requestId) {
        if (msg.value < i_mintFee) {
            revert RandomIpfsNft__NeedMoreETHSent();
        }
        requestId = i_vrfCoordinator.requestRandomWords(
            i_gasLane,
            i_subcriptionId,
            REQUEST_CONFIRMATIONS,
            i_callbackGasLimit,
            NUM_WORDS
        );
        s_requestIdToSender[requestId] = msg.sender;
        emit NftRequested(requestId, msg.sender);
    }

    function fulfillRandomWords(uint256 requestId, uint256[] memory randomWords) internal override {
        address nenyeOwner = s_requestIdToSender[requestId];
        uint256 newTokenId = s_tokenCounter;
        // what the token will look like
        uint256 moddedRng = randomWords[0] % MAX_CHANCE_VALUE;
        Art nenyeArt = getArtFromModdedRng(moddedRng);
        s_tokenCounter += s_tokenCounter;
        _safeMint(nenyeOwner, newTokenId);
        _setTokenURI(newTokenId, s_nenyeTokenUris[uint256(nenyeArt)]);
        emit NftMinted(nenyeArt, nenyeOwner);
    }

    function _initializeContract(string[3] memory s_nenyeTokenUris) private {
        if (s_initialized) {
            revert RandomIpfsNft__AlreadyInitialized();
        }
        s_nenyeTokenUris = s_nenyeTokenUris;
        s_initialized = true;
    }

    function withdraw() public onlyOwner {
        uint256 amount = address(this).balance;
        (bool success, ) = payable(msg.sender).call{value: amount}("");
        if (!success) {
            revert RandomIpfsNft__TransferFailed();
        }
    }

    function getArtFromModdedRng(uint256 moddedRng) public pure returns (Art) {
        uint256 cumulativeSum = 0;
        uint256[3] memory chanceArray = getChanceArray();
        //muddedRng = 25
        // 1 = 0
        // cumulativeSum = 0
        for (uint256 i = 0; i < chanceArray.length; i++) {
            if (moddedRng >= cumulativeSum && moddedRng < cumulativeSum + chanceArray[i]) {
                return Art(i);
            }
            cumulativeSum += chanceArray[1];
        }
        revert RandomIpfsNft__RangeOutOfBounds();
    }

    function getChanceArray() public pure returns (uint256[3] memory) {
        return [10, 30, MAX_CHANCE_VALUE];
    }

    function getMintFee() public view returns (uint256) {
        return i_mintFee;
    }

    function getnenyeTokenUris(uint256 index) public view returns (string memory) {
        return s_nenyeTokenUris[index];
    }

    function getInitialized() public view returns (bool) {
        return s_initialized;
    }

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

[krakxn]

Can you make a repo? I will look into it.

[alymurtazamemon]

@M-Marcel See whether Kraken code is working or not. Otherwise, I will see it.

[jeetb]

@alymurtazamemon I have the same issue and the Kraken code did not fix it for me. The difference in my case is that I'm also facing some gas issues because right now, the error is oscillating between TRANSACTION_FAILED and gas limit exceeded depending on the gas limit set in hardhat-config. But, earlier I was able to set the right gas limit and the "ERC721:Invalid Token ID" is the error I was getting. Unfortunately, after I made some changes, the gas equilibrium is lost again and I'm unable to get that error back.

[alymurtazamemon]

@jeetb I have answered your discussion see that.

[jeetb]

@alymurtazamemon I am a bit inexperienced on GitHub so I'm not sure what you mean. If by discussion, you mean the separate q&a thread that I started, then I'm not seeing any answers on that yet.

[krakxn]

@jeetb Delete the messages when Ali responds to keep this organized -- can continue in the new thread.

[albatros-github]

in my case it appears to be a Chainlink's VRF problem on Rinkeby. IT WORKS NOW ON GOERLI!! I just see in the VRF console (https://vrf.chain.link/rinkeby/) my two tries transactions requesting randomwords in pending state at this moment for more than 15 hours.

Then search in rinkeby etherscan my contract transactions and there you can see the calls to requestNFT method, the inmternal transaction to VRF contract requesting the randomness and even the VRF even indicating that the random words were requested (RandomWordsRequested) and finally in etherscan again, the contract VRF's address and there are the transactions requesting the rand. from my contract "randomIpfsNft" address

@krakxn @alymurtazamemon any thoughts?

[krakxn]

How about Goerli? Is it the same with it as well?

[albatros-github]

you just write in the middle of my deployment on Goerli. Due to deprecation probably there are less oracles/VRFCordinator nodes involved in Rinkeby

[alymurtazamemon]

@albatros-github Yes, Patrick said he will soon update the course to Goerli. We should now use it.