lesson 09: Error: VM Exception while processing transaction: reverted with custom error 'InvalidConsumer()'

[umairahmed88]

I got 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)

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

!developmentChains.includes(network.name)
? describe.skip
: describe("Raffle", function () {
let raffle, vrfCoordinatorV2Mock, raffleEntranceFee, deployer, interval;
const chainId = network.config.chainId;

		beforeEach(async function () {
			deployer = (await getNamedAccounts()).deployer;
			await deployments.fixture(["all"]);
			raffle = await ethers.getContract("Raffle", deployer);
			vrfCoordinatorV2Mock = await ethers.getContract(
				"VRFCoordinatorV2Mock",
				deployer
			);
			raffleEntranceFee = await raffle.getEntranceFee();
			interval = await raffle.getInterval();
		});

		describe("constructor", function () {
			it("initializes the raffle correctly", async function () {
				const raffleState = await raffle.getRaffleState();
				assert.equal(raffleState.toString(), "0");
				assert.equal(interval.toString(), networkConfig[chainId]["interval"]);
			});
		});

		describe("enterRaffle", function () {
			it("reverts when you don't pay enough", async function () {
				await expect(raffle.enterRaffle()).to.be.revertedWith(
					"Raffle__NotEnoughETHEntered"
				);
			});
			it("records player when they enter", async function () {
				await raffle.enterRaffle({ value: raffleEntranceFee });
				const playerFromContract = await raffle.getPlayer(0);
				assert.equal(playerFromContract, deployer);
			});
			it("emits event on enter", async function () {
				await expect(
					raffle.enterRaffle({ value: raffleEntranceFee })
				).to.emit(raffle, "RaffleEnter");
			});
			it("does not allow entrance when raffle is calculating", async function () {
				await raffle.enterRaffle({ value: raffleEntranceFee });
				await network.provider.send("evm_increaseTime", [
					interval.toNumber() + 1,
				]);
				await network.provider.send("evm_mine", []);
				await raffle.performUpkeep([]);
				await expect(
					raffle.enterRaffle({ value: raffleEntranceFee })
				).to.be.revertedWith("Raffle__NotOpen");
			});
		});
  });

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.17;

import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";
import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
import "@chainlink/contracts/src/v0.8/interfaces/KeeperCompatibleInterface.sol";

error Raffle__NotEnoughETHEntered();
error Raffle__TransferFailed();
error Raffle__NotOpen();
error Raffle__UpkeepNotNeeded(
uint256 currentBalance,
uint256 numPlayers,
uint256 raffleState
);

contract Raffle is VRFConsumerBaseV2, KeeperCompatibleInterface {
enum RaffleState {
OPEN,
CALCULATING
}

/* State Variables */
uint256 private immutable i_entranceFee;
address payable[] private s_players;
VRFCoordinatorV2Interface private immutable i_vrfCoordinator;
bytes32 private immutable i_gasLane;
uint64 private immutable i_subscriptionId;
uint32 private immutable i_callbackGasLimit;
uint16 private constant REQUEST_CONFIRMATIONS = 3;
uint32 private constant NUM_WORDS = 1;

// Lottery Variables
address private s_recentWinner;
RaffleState private s_raffleState;
uint256 private s_lastTimeStamp;
uint256 private immutable i_interval;

/* Events */
event RaffleEnter(address indexed player);
event RequestRaffleWinner(uint256 indexed requestId);
event WinnerPicked(address indexed winner);

constructor(
    address vrfCoordinatorV2,
    uint64 subscriptionId,
    bytes32 gasLane,
    uint256 interval,
    uint32 callbackGasLimit,
    uint256 entranceFee
) VRFConsumerBaseV2(vrfCoordinatorV2) {
    i_vrfCoordinator = VRFCoordinatorV2Interface(vrfCoordinatorV2);
    i_subscriptionId = subscriptionId;
    i_gasLane = gasLane;
    s_raffleState = RaffleState.OPEN;
    s_lastTimeStamp = block.timestamp;
    i_interval = interval;
    i_callbackGasLimit = callbackGasLimit;
    i_entranceFee = entranceFee;
}

function enterRaffle() public payable {
    if (msg.value < i_entranceFee) {
        revert Raffle__NotEnoughETHEntered();
    }
    if (s_raffleState != RaffleState.OPEN) {
        revert Raffle__NotOpen();
    }
    s_players.push(payable(msg.sender));

    emit RaffleEnter(msg.sender);
}

function checkUpkeep(
    bytes memory /*checkData*/
)
    public
    override
    returns (bool upkeepNeeded, bytes memory /* performData */)
{
    bool isOpen = (RaffleState.OPEN == s_raffleState);
    bool timePassed = ((block.timestamp - s_lastTimeStamp) > i_interval);
    bool hasPlayers = (s_players.length > 0);
    bool hasBalance = address(this).balance > 0;
    upkeepNeeded = (isOpen && timePassed && hasPlayers && hasBalance);
}

function performUpkeep(bytes calldata /*performData */) external override {
    (bool upkeepNeeded, ) = checkUpkeep("");
    if (!upkeepNeeded) {
        revert Raffle__UpkeepNotNeeded(
            address(this).balance,
            s_players.length,
            uint256(s_raffleState)
        );
    }
    s_raffleState = RaffleState.CALCULATING;
    uint256 requestId = i_vrfCoordinator.requestRandomWords(
        i_gasLane,
        i_subscriptionId,
        REQUEST_CONFIRMATIONS,
        i_callbackGasLimit,
        NUM_WORDS
    );
    emit RequestRaffleWinner(requestId);
}

function fulfillRandomWords(
    uint256 /*requestId*/,
    uint256[] memory randomWords
) internal override {
    uint256 indexOfWinner = randomWords[0] % s_players.length;
    address payable recentWinner = s_players[indexOfWinner];
    s_recentWinner = recentWinner;
    s_raffleState = RaffleState.OPEN;
    s_players = new address payable[](0);
    s_lastTimeStamp = block.timestamp;
    (bool success, ) = recentWinner.call{value: address(this).balance}("");
    if (!success) {
        revert Raffle__TransferFailed();
    }
    emit WinnerPicked(recentWinner);
}

function getEntranceFee() public view returns (uint256) {
    return i_entranceFee;
}

function getPlayer(uint256 index) public view returns (address) {
    return s_players[index];
}

function getRecentWinner() public view returns (address) {
    return s_recentWinner;
}

function getRaffleState() public view returns (RaffleState) {
    return s_raffleState;
}

function getNumWords() public pure returns (uint256) {
    return NUM_WORDS;
}

function getNumberOfPlayers() public view returns (uint256) {
    return s_players.length;
}

function getLatestTimeStamp() public view returns (uint256) {
    return s_lastTimeStamp;
}

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

function getInterval() public view returns (uint256) {
    return i_interval;
}

}

[pacelliv]

Hello @umairahmed88, you can refer to the following answer in #1565.

[umairahmed88]

Thank you! It worked

[mscbr]

Saved my day 🙏

[pratokko]

nice one

[nagrarohit]

@pacelliv that was very helpful
thanks a lot.

[sodexx7]

Thanks a lot. You help me fix the problem quickly.