No Contract deployed with name: RandomIpfsNft (lesson 14)

[haaarshit]

While running test for my RandomIpfs file getting this error

 1) Randomnftipfstest
       "before each" hook for "should intialize everything":
     Error: No Contract deployed with name: RandomIpfsNft
      at getContract (node_modules/@nomiclabs/hardhat-ethers/src/helpers.ts:149:11)
      at processTicksAndRejections (node:internal/process/task_queues:96:5)
      at runNextTicks (node:internal/process/task_queues:65:3)
      at listOnTimeout (node:internal/timers:528:9)
      at processTimers (node:internal/timers:502:7)
      at Context.<anonymous> (test/unit/randomipfsNfs.test.js:17:29)

Randomipfs.test.js file

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

!developmentChains.includes(network.name) ?
    describe.skip   
    :
    describe('Randomnftipfstest', () => {
        
        let randomIpfsNft, deployer, vrfCoordinatorV2Mock
        
        beforeEach(async () => {
            accounts = await ethers.getSigners()
            deployer = accounts[0]
            await deployments.fixture(["mocks", "randomipfs"])
            vrfCoordinatorV2Mock = await ethers.getContract("VRFCoordinatorV2Mock",deployer)
            randomIpfsNft = await ethers.getContract("RandomIpfsNft",deployer)
        })

        describe("Constructor", () => {
            it("should intialize everything", async () => {
                const mintFee = networkConfig[network.config.chainId]["mintFee"]
                const s_mintFee = await randomIpfsNft.getMintFee()
                const s_tokenCounter = await randomIpfsNft.getTokenCounter()
                assert.equal(mintFee.toString(), s_mintFee.toString())
                assert.equal(s_tokenCounter.toString(), "0")
            })
        })
    })

02 deployment file

const { network, ethers } = require("hardhat")
const { developmentChains, networkConfig } = require("../helper-hardhat-config")
const { storeImages, storeTokenUriMetadata } = require("../utils/uploadToPinata")
const imagesLocation = './images/randomNft'
require("dotenv").config()

// store metadata for tokenuri
const metadataTemplate = {
  name: "",
  description: "",
  image: "",
  attributes: {
    trait_type: "Cuteness",
    value: 100
  }
}


let tokenUris = [
  'ipfs://QmUPppocq3X1eAepEQR3KRgojjpRoS155FsYqwafen5AYo',
  'ipfs://QmVDMaYWYiw1GMbzp3atuqN4Hepu9Wv95wxCAwf24QrL4M',
  'ipfs://QmbMh8o41PqYCzG6vgafUJC7jkE4kpSvU8xu5bNBuUnWdi'
]

const FUND_AMOUNT = "250000000000000000"

module.exports = async ({ getNamedAccounts, deployments }) => {
  const { deploy, log } = deployments
  const { deployer } = await getNamedAccounts()

  const chainId = network.config.chainId
  let vrfCoordinatorV2Address, subscriptionId, vrfCoordinatorV2Mock

  // deploy nft images
  // -> get the ipfs hashes of images 
  // we will use Pinata ->For developers, Pinata is the easiest way to pin content to IPFS and build web3 applications without having to build and manage your own IPFS nodes
  // NFT.storage -> lets you upload off-chain NFT data for free

  if (process.env.UPLOAD_TO_PINATA == "true") {
    await handleTokenuri()
  }

  if (chainId == 31337) {
    // create VRFV2 Sub scription
    vrfCoordinatorV2Mock = await ethers.getContract("VRFCoordinatorV2Mock")
    vrfCoordinatorV2Address = await vrfCoordinatorV2Mock.getAddress()
    const transactionResponse = await vrfCoordinatorV2Mock.createSubscription()
    const transactionReceipt = await transactionResponse.wait(1)
    subscriptionId = transactionReceipt.logs[0].args.subId
    await vrfCoordinatorV2Mock.fundSubscription(subscriptionId, FUND_AMOUNT)
  } else {
    vrfCoordinatorV2Address = networkConfig[chainId].vrfCoordinatorV2
    subscriptionId = networkConfig[chainId].subscriptionId
  }

  log('---------------------------')

  const args = [
    vrfCoordinatorV2Address,
    subscriptionId,
    networkConfig[chainId]["gasLane"],
    networkConfig[chainId]["callbackGasLimit"],
    tokenUris,
    networkConfig[chainId]["mintFee"]
  ]
  const randomIpfsNft = await deploy("RandomIpfsNft", {
    from: deployer,
    args: args,
    log: true,
    waitConfirmations: network.config.blockConfirmations || 1,
  })

  if (chainId == 31337) {
    await vrfCoordinatorV2Mock.addConsumer(subscriptionId, randomIpfsNft.address)
  }

  if (!developmentChains.includes(network.name) && process.env.ETHERSCAN_API_KEY) {
    log("verifying..........")
    await verify(randomIpfsNft.address, args)
  }

  log('----------------------------')
}



module.exports.tags = ["all", "randomipfs", "main"]

RandomIpfsNft.sol file

// SPDX-License-Identifier:MIT
pragma solidity ^0.8.7;
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";

// errors
error RandomIpfsNft__RangeOutOfBounds();
error RandomIpfsNft__NeedMoreEthSent();
error RandomIpfsNft__TransferFailed();

contract RandomIpfsNft is VRFConsumerBaseV2, ERC721URIStorage, Ownable {
    // when we mint and nft we will trigger a chainlink vrf call to get us a random number
    // using that number we will get a random nft

    enum Breed {
        PUG,
        SHIBA_INU,
        ST_BERNARD
    }

    // states
    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 _numWords = 1;
    uint256 internal immutable i_mintFee;

    // NFT variables
    uint256 public s_tokenCounter;
    uint256 internal constant MAX_CHANCE_VALUE = 100;
    string[] internal s_dogTokeUris;

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

    // Events
    event NftRequested(uint256 indexed requestId);
    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_dogTokeUris = dogTokenUris;
        i_mintFee = mintFee;
    }

    function requestNft() public payable returns (uint256 requestId) {
        if (msg.value < i_mintFee) {
            revert RandomIpfsNft__NeedMoreEthSent();
        }
        requestId = i_vrfCoordinator.requestRandomWords(
            i_gasLane,
            i_subscriptionId,
            REQUEST_CONFIRMATIONS,
            i_callbackGasLimit,
            _numWords
        );
        s_requestIdToSender[requestId] = msg.sender;
    }

    function fulfillRandomWords(
        uint256 requestId,
        uint256[] memory randomWords
    ) internal override {
        address dogOwner = s_requestIdToSender[requestId];
        uint256 newTokenId = s_tokenCounter;
        uint256 moddedRng = randomWords[0] % MAX_CHANCE_VALUE;
        Breed dogBreed = getBreedFromModdedRng(moddedRng);
        s_tokenCounter=s_tokenCounter+1;
        _safeMint(dogOwner, newTokenId);
        //
        _setTokenURI(newTokenId, s_dogTokeUris[uint256(dogBreed)]);
        emit NftMinted(dogBreed, dogOwner);
    }


    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 withDraw() public onlyOwner {
        uint256 amount = address(this).balance;
        (bool success, ) = payable(msg.sender).call{value: amount}("");
        if (!success) {
            revert RandomIpfsNft__TransferFailed();
        }
    }

    function getChanceArray() public pure returns (uint256[3] memory) {
        return [10, 30, MAX_CHANCE_VALUE]; // chances of happining :=> index 0 -> 10% | index 1 -> 30% | index-> 60%
    }

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

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

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

[Astronaut828]

You could try to run yarn hardhat clean and then recompile, maybe there is a problem in with the name somewhere.

[haaarshit]

@Astronaut828 I tried this for several time it's not the problem I checked the artifacts folder there was the same contract name as in deploy and test script

[Astronaut828]

Have you tried to console log "randomIpfsNft" to see its values? From what i see most people have problems with the ethers version and ethers.getContract() or ethers.getContractAt()

randomIpfsNft = await ethers.getContract("RandomIpfsNft",deployer)
console.log(randomIpfsNft)

[haaarshit]

Code is not executing further the line

   randomIpfsNft = await ethers.getContract("RandomIpfsNft",deployer)

It's the line where the error is occuring

[Astronaut828]

have you tried:

randomIpfsNft = await ethers.getContractAt("RandomIpfsNft")

[haaarshit]

Yes its working

 randomIpfsNft = await ethers.getContractAt("RandomIpfsNft","0x5FC8d32690cc91D4c39d9d3abcBD16989F875707")

[haaarshit]

have you tried:

randomIpfsNft = await ethers.getContractAt("RandomIpfsNft")