Lesson 14 RandomIpfsNFT can't call requestRandomWords

[WilliamGiammona]

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

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";

contract RandomIpfsNft is ERC721, Ownable, VRFConsumerBaseV2 {
    using Counters for Counters.Counter;

    Counters.Counter private _tokenIdCounter;

    VRFCoordinatorV2Interface private immutable i_VRFCoordinatorV2Contract;

    bytes32 private immutable i_keyHash;
    uint32 private immutable i_callbackGasLimit;
    uint64 private immutable i_subscriptionId;
    uint16 private constant REQUEST_CONFIRMATIONS = 3;
    uint32 private constant NUMWORDS = 1;
    uint256 public s_requestId;

    mapping(uint256 => address) public s_requestIdToSender;

    constructor(
        address vrfCoordinatorV2Address,
        bytes32 keyHash,
        uint32 callbackGasLimit,
        uint64 subscriptionId
    ) ERC721("MyToken", "MTK") VRFConsumerBaseV2(vrfCoordinatorV2Address) {
        i_VRFCoordinatorV2Contract = VRFCoordinatorV2Interface(
            vrfCoordinatorV2Address
        );
        i_keyHash = keyHash;
        i_callbackGasLimit = callbackGasLimit;
        i_subscriptionId = subscriptionId;
    }

    function requestNft() public onlyOwner returns (uint256) {
        s_requestId = i_VRFCoordinatorV2Contract.requestRandomWords(
            i_keyHash,
            i_subscriptionId,
            REQUEST_CONFIRMATIONS,
            i_callbackGasLimit,
            NUMWORDS
        );
        s_requestIdToSender[s_requestId] = msg.sender;

        return s_requestId;
    }

    function fulfillRandomWords(uint256 requestId, uint256[] memory randomWords)
        internal
        override
    {
        address dogOwner = s_requestIdToSender[requestId];
    }

    function getVRFCoordinatorV2Contract()
        public
        view
        returns (VRFCoordinatorV2Interface)
    {
        return i_VRFCoordinatorV2Contract;
    }

    function getKeyHash() public view returns (bytes32) {
        return i_keyHash;
    }

    function getCallbackGasLimit() public view returns (uint32) {
        return i_callbackGasLimit;
    }

    function getSubscriptionId() public view returns (uint64) {
        return i_subscriptionId;
    }

    function getNumWords() public pure returns (uint32) {
        return NUMWORDS;
    }

    function getRequestConfirmations() public pure returns (uint16) {
        return REQUEST_CONFIRMATIONS;
    }
}

When I test my code on the local hardhat network on this function:

 function requestNft() public onlyOwner returns (uint256) {
        s_requestId = i_VRFCoordinatorV2Contract.requestRandomWords(
            i_keyHash,
            i_subscriptionId,
            REQUEST_CONFIRMATIONS,
            i_callbackGasLimit,
            NUMWORDS
        );
        s_requestIdToSender[s_requestId] = msg.sender;

        return s_requestId;
    }

I'm running into this error:

 Error: VM Exception while processing transaction: reverted with custom error 'InvalidConsumer()'
    at VRFCoordinatorV2Mock.onlyValidConsumer (@chainlink/contracts/src/v0.8/mocks/VRFCoordinatorV2Mock.sol:72)
    at VRFCoordinatorV2Mock.requestRandomWords (@chainlink/contracts/src/v0.8/mocks/VRFCoordinatorV2Mock.sol:147)
    at RandomIpfsNft.requestNft (contracts/RandomIpfsNft.sol:41)
    at HardhatNode._mineBlockWithPendingTxs (node_modules/hardhat/src/internal/hardhat-network/provider/node.ts:1773:23)
    at HardhatNode.mineBlock (node_modules/hardhat/src/internal/hardhat-network/provider/node.ts:466:16)
    at EthModule._sendTransactionAndReturnHash (node_modules/hardhat/src/internal/hardhat-network/provider/modules/eth.ts:1504:18)
    at HardhatNetworkProvider.request (node_modules/hardhat/src/internal/hardhat-network/provider/provider.ts:118:18)
    at EthersProviderWrapper.send (node_modules/@nomiclabs/hardhat-ethers/src/internal/ethers-provider-wrapper.ts:13:20)

I checked the Invalid Consumer error and don't understand why I'm getting it, because when I deploy my contract, I set up the subscriptionId in the following manner:

const txResponse = await mockVRFCoordinatorV2Contract.createSubscription();
  const txReceipt = await txResponse.wait(1);
  const subscriptionId = txReceipt.events[0].args.subId;
  await mockVRFCoordinatorV2Contract.fundSubscription(
    subscriptionId,
    VRF_SUB_FUND_AMOUNT
  );

I also ran a test to make sure that my subscriptionId was returning correctly, which it is:

it("Sets the subscriptionId correctly", async function () {
      assert.equal((await randomIpfsNft.getSubscriptionId()).toString(), "1");
    });

I know my mock and contract are both deploying correctly because all my other tests are working correctly.

For additional information, here is my mock:

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

import "@chainlink/contracts/src/v0.8/mocks/VRFCoordinatorV2Mock.sol";

here are my tests:

const { assert } = require("chai");
const { getNamedAccounts, deployments, ethers } = require("hardhat");

describe("RandomIpfsNft", function () {
  let randomIpfsNft, mockVRFCoordinatorV2, deployer;

  beforeEach(async function () {
    deployer = (await getNamedAccounts()).deployer;
    await deployments.fixture(["all"]);
    mockVRFCoordinatorV2 = await ethers.getContract(
      "VRFCoordinatorV2Mock",
      deployer
    );
    randomIpfsNft = await ethers.getContract("RandomIpfsNft", deployer);
  });

  describe("Constructor", function () {
    it("Sets the VRFCoordinator Address correctly", async function () {
      assert.equal(
        await randomIpfsNft.getVRFCoordinatorV2Contract(),
        mockVRFCoordinatorV2.address
      );
    });

    it("Sets the keyHash correctly", async function () {
      assert.equal(
        (await randomIpfsNft.getKeyHash()).toString(),
        "0xd89b2bf150e3b9e13446986e571fb9cab24b13cea0a43ea20a6049a85cc807cc"
      );
    });

    it("Sets the callbackGasLimit correctly", async function () {
      assert.equal(
        (await randomIpfsNft.getCallbackGasLimit()).toString(),
        "500000"
      );
    });

    it("Sets the subscriptionId correctly", async function () {
      assert.equal((await randomIpfsNft.getSubscriptionId()).toString(), "1");
    });
  });

  describe("safeMint", function () {
    it("Emits an event after calling the requestRandomWords function", async function () {
      await randomIpfsNft.requestNft();
    });
  });
});

Here are my deploy scripts:

const {
  developmentChainNames,
  BASE_FEE,
  GASPRICELINK,
} = require("../helper-hardhat-config");

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

  console.log(deployer, "deployer");
  console.log("Deploying Mocks...");

  await deploy("VRFCoordinatorV2Mock", {
    from: deployer,
    args: [BASE_FEE, GASPRICELINK],
    log: true,
    waitConfirmations: 1,
  });

  console.log("Mocks Deployed!!!");
  console.log("------------------------------------------");
};
module.exports.tags = ["all", "VRFCoordinatorV2Mock"];

const { ethers } = require("hardhat");
const {
  developmentChainNames,
  KEYHASH,
  CALLBACKGASLIMIT,
  VRF_SUB_FUND_AMOUNT,
} = require("../helper-hardhat-config");

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

  const mockVRFCoordinatorV2Contract = await ethers.getContract(
    "VRFCoordinatorV2Mock"
  );

  const mockVRFCoordinatorV2ContractAddress =
    mockVRFCoordinatorV2Contract.address;

  const txResponse = await mockVRFCoordinatorV2Contract.createSubscription();
  const txReceipt = await txResponse.wait(1);
  const subscriptionId = txReceipt.events[0].args.subId;
  await mockVRFCoordinatorV2Contract.fundSubscription(
    subscriptionId,
    VRF_SUB_FUND_AMOUNT
  );

  console.log("Deploying RandomIpfsNft...");

  await deploy("RandomIpfsNft", {
    from: deployer,
    args: [
      mockVRFCoordinatorV2ContractAddress,
      KEYHASH,
      CALLBACKGASLIMIT,
      subscriptionId,
    ],
    log: true,
    waitConfirmations: 1,
  });

  console.log("RandomIpfsNft Deoloyed!!!");
  console.log("-----------------------------------");
};
module.exports.tags = ["all", "RandomIpfsNft"];

and here are my hh config and hh helper config

require("@nomiclabs/hardhat-waffle");
require("hardhat-gas-reporter");
require("@nomiclabs/hardhat-etherscan");
require("dotenv").config();
require("solidity-coverage");
require("hardhat-deploy");

module.exports = {
  solidity: "0.8.4",
  defaultNetwork: "hardhat",
  namedAccounts: {
    deployer: {
      default: 0,
    },
  },
  gasReporter: {
    enabled: false,
    currency: "USD",
    outputFile: "gas-report.txt",
    noColors: true,
  },
};

const developmentChainNames = ["hardhat", "localhost"];

//For VRFCoordinatorV2Mock
const BASE_FEE = ethers.utils.parseEther("0.25");
const GASPRICELINK = 1e9;

//For RandomIpfsNft
const KEYHASH =
  "0xd89b2bf150e3b9e13446986e571fb9cab24b13cea0a43ea20a6049a85cc807cc";
const CALLBACKGASLIMIT = "500000";

//For Funding SubscriptionId
const VRF_SUB_FUND_AMOUNT = ethers.utils.parseEther("30");

module.exports = {
  developmentChainNames,
  BASE_FEE,
  GASPRICELINK,
  KEYHASH,
  CALLBACKGASLIMIT,
  VRF_SUB_FUND_AMOUNT,
};

[alymurtazamemon]

@WilliamGiammona add the older version of chainlink contracts npm i @chainlink/contracts@0.4.1

[WilliamGiammona]

It worked, thank you so much!

[PCWCFA]

@alymurtazamemon @WilliamGiammona Thank you so much for providing a solution. Just out of curiosity, do we know why the new version doesn't work?

[alymurtazamemon]

@WilliamGiammona It is in beta, May be due to that.