I am getting error while calling requestNft function in randomIpfsNft (timestamp 23:28:45)

[SatamSai]

RandomIpfsNft.sol

    // SPDX-License-Identifier: MIT
    
    pragma solidity ^0.8.8;
    
    import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
    import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
    import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";
    import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
    import "@openzeppelin/contracts/access/Ownable.sol";
    import "hardhat/console.sol";
    
    error RandomIpfsNft__RangeOutOfBounds();
    error RandomIpfsNft__NeedMoreETHSent();
    error RandomIpfsNft__TransferFailed();
    
    contract RandomIpfsNft is ERC721URIStorage,VRFConsumerBaseV2,Ownable{
    
        enum Breed{
            PUG,
            SHIBA_INU,
            ST_BERBARD
        }
    
        VRFCoordinatorV2Interface private immutable i_vrfCoordinator;
        uint64 private immutable i_subscriptionId;
        bytes32 private immutable i_gasLane;
        uint32 private immutable i_callbackGasLimit;
        uint16 private constant REQUEST_CONFIRMATIONS=3;
        uint32 private constant NUM_WORDS=1;
        
        mapping (uint256=> address) public s_requestIdToSender;
    
        uint256 public s_tokenCounter;
        uint256 internal constant MAX_CHANCE_VALUE=100;
        string[] internal s_dogTokenUris;
        uint256 internal immutable i_mintFee;
    
    
        event NftRequested(uint256 indexed requestId,address requester);
        event NftMinted(Breed dogBreed,address minter);
    
        constructor(address vrfCoordinatorV2,uint64 subscriptionId,bytes32 gasLane,uint32 callbackGasLimit,string[3] memory dogTokenUris,uint256 mintFee) VRFConsumerBaseV2(vrfCoordinatorV2) ERC721("Random IPFS NFT","RIN"){
            i_vrfCoordinator=VRFCoordinatorV2Interface(vrfCoordinatorV2);
            i_subscriptionId=subscriptionId;
            i_gasLane=gasLane;
            i_callbackGasLimit=callbackGasLimit;
            s_tokenCounter=0;
            s_dogTokenUris=dogTokenUris;
            i_mintFee=mintFee;
        }
    
    
        function requestNft() public payable  {
            if(msg.value<i_mintFee){
                revert RandomIpfsNft__NeedMoreETHSent();
            }
            uint256 requestId=i_vrfCoordinator.requestRandomWords(i_gasLane, i_subscriptionId, 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 dogOwner=s_requestIdToSender[requestId];
            uint256 moddedRng=randomWords[0]%MAX_CHANCE_VALUE;
            Breed dogBreed=getBreedFromModdedRng(moddedRng);
            _safeMint(dogOwner,s_tokenCounter);
            _setTokenURI(s_tokenCounter,s_dogTokenUris[uint256(dogBreed)]);
            s_tokenCounter++;
            emit NftMinted(dogBreed, dogOwner);
        }
    
        function withdraw() public onlyOwner{
            uint256 amount =address(this).balance;
            (bool success,)=payable(msg.sender).call{value:amount}("");
            if(!success){
                revert RandomIpfsNft__TransferFailed();
            }
        }
    
        function getBreedFromModdedRng(uint256 moddedRng) public pure returns(Breed){
            uint256 cumulativeSum=0;
            uint256[3] memory chanceArray=getChanceArray();
            for(uint256 i=0;i<chanceArray.length;i++)
            {
                if (moddedRng>= cumulativeSum && moddedRng< cumulativeSum +chanceArray[i]){
                    return Breed(i);
                }
                cumulativeSum+=chanceArray[i];
            }
            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 getDogTokenUris(uint256 index) public view returns(string memory){
            return s_dogTokenUris[index];
        }
        function getTokenCounter() public view returns(uint256){
            return s_tokenCounter;
        }
    }

04-mint.js

    const {ethers,network,getNamedAccounts}=require("hardhat")
    const {developmentChains}=require("../helper-hardhat-config")
    module.exports=async function(){
        const {deployer}=await getNamedAccounts()
        console.log(deployer)
        //Basic NFT
        const basicNft=await ethers.getContract("BasicNFT",deployer)
        const basicMintTx=await basicNft.mintNFT()
        await basicMintTx.wait(1)
        console.log(`Basic NFT index 0 has tokenURI: ${await basicNft.tokenURI(0)}`)
        console.log("*************************************************************************")
        // Random IPFS NFT
        const randomIpfsNft=await ethers.getContract("RandomIpfsNft",deployer)
        console.log(randomIpfsNft.address)
        const mintFee=await randomIpfsNft.getMintFee()
        console.log(deployer)
        await new Promise(async (res,rej)=>{
            setTimeout(res,300000)
            randomIpfsNft.once("NftMinted",async function(){
                res()
            })
            console.log("*************")
            const randomIpfsMintTx=await randomIpfsNft.requestNft({value:mintFee.toString(),gasLimit:"250000"})
            const randomIpfsMintTxReceipt=await randomIpfsMintTx.wait(1)
            if(developmentChains.includes(network.name)){
                const requestId=randomIpfsMintTxReceipt.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)}`)
        console.log("*************************************************************************")
        
        // Dynamic SVG NFT
        const highValue=ethers.utils.parseEther("4000")
        console.log(deployer)
        const dynamicSvgNft=await ethers.getContract("DynamicSvgNft",deployer)
        const dynamicSvgNftMintTx=await dynamicSvgNft.mintNFT(highValue.toString())
        await dynamicSvgNftMintTx.wait(1)
        console.log(`Dynamic SVG NFT index 0 tokenURI: ${await dynamicSvgNft.tokenURI(0)}`)
    }
    
    module.exports.tags=["all","mint"]

Error I am getting is

Contract is deployed and verifed here : https://rinkeby.etherscan.io/address/0x925e128f18653f4F41f91C47F383736d429631Fc#code

I tried calling requestNft function from etherscan.

Am I missing something?
Please someone help me out !!

[SatamSai]

@krakxn pls help me out

[krakxn]

Before looking into your code, I would recommend going through the common causes for CALL_EXCEPTION.

I've seen it quite frequently here (usually gas limit). Follow attentively:

• Method reverts during its execution.
• Method is not present in your contract.
• Contract not deployed on the network you're connected to, or address etc. put is incorrect (check this properly).
• Your network has some temporary outages (use Goerli too and let me know)

From Ethers:

Common Causes

• The code does not exist on-chain. This may happen if you failed to wait until the contract was deployed, the address is incorrect or if you are connected to a different network than the contract has been deployed. Check the code exists using provider.getCode(address).

• The wrong code is being accessed, for example if an artifact file was not correctly updated so an older instance of the contract is being called

• The contract is failing during a require statement. For example, if a contract method requires an admin account to be used, but the contract is connected to another Signer.

• The wrong ABI is being used to interact with a contract.
  Debugging

• Always double check the address and network you are connected to and use provider.getCode(address) to verify the deployed code matches your most recent version.

• Try accessing other, simpler contract methods to verify the account is correct.

[SatamSai]

I tried deploying it on Goerli, rinkeby, polygon mumbai testnet. It should atleast work when I call the function through etherscan (non programatic way)
Here is my contract on goerli
https://goerli.etherscan.io/address/0x6dd3f211e31ccd1eaf69b8ac129ef49be0f16477

[krakxn]

Thank you, I will look into it soon.

[SatamSai]

yes please. I am stuck on this since 2 weeks.