Lesson 9 | Receiving .addConsumer() error when running unit test

[vatsaljain27]

This is the error that I am getting:

Error: call revert exception; VM Exception while processing transaction: reverted with reason string "not implemented" [ See: https://links.ethers.org/v5-errors-CALL_EXCEPTION ] (method="addConsumer(uint64,address)", data="0x08c379a00000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000f6e6f7420696d706c656d656e7465640000000000000000000000000000000000", errorArgs=["not implemented"], errorName="Error", errorSignature="Error(string)", reason="not implemented", code=CALL_EXCEPTION, version=abi/5.7.0)

Here is the code:

01-deploy.js
`
const { network, ethers } = require("hardhat")
const {
networkConfig,
developmentChains,
VERIFICATION_BLOCK_CONFIRMATIONS,
} = require("../helper-hardhat-config")
const { verify } = require("../utils/verify")

const FUND_AMOUNT = ethers.utils.parseEther("1") // 1 Ether, or 1e18 (10^18) Wei

module.exports = async ({ getNamedAccounts, deployments }) => {
const { deploy, log } = deployments
const { deployer } = await getNamedAccounts()
const chainId = network.config.chainId
let vrfCoordinatorV2Address, subscriptionId, vrfCoordinatorV2Mock

if (chainId == 31337) {
    // create VRFV2 Subscription
    vrfCoordinatorV2Mock = await ethers.getContract("VRFCoordinatorV2Mock")
    vrfCoordinatorV2Address = vrfCoordinatorV2Mock.address
    const transactionResponse = await vrfCoordinatorV2Mock.createSubscription()
    const transactionReceipt = await transactionResponse.wait()
    // console.log(transactionReceipt.events[0].args)
    subscriptionId = transactionReceipt.events[0].args.subId
    // Fund the subscription
    // Our mock makes it so we don't actually have to worry about sending fund
    await vrfCoordinatorV2Mock.fundSubscription(subscriptionId, FUND_AMOUNT)
} else {
    vrfCoordinatorV2Address = networkConfig[chainId]["vrfCoordinatorV2"]
    subscriptionId = networkConfig[chainId]["subscriptionId"]
}
const waitBlockConfirmations = developmentChains.includes(network.name)
    ? 1
    : VERIFICATION_BLOCK_CONFIRMATIONS

log("----------------------------------------------------")
const arguments = [
    vrfCoordinatorV2Address,
    networkConfig[chainId]["raffleEntranceFee"],
    networkConfig[chainId]["gasLane"],
    subscriptionId,
    networkConfig[chainId]["callbackGasLimit"],
    networkConfig[chainId]["keepersUpdateInterval"],
]
const raffle = await deploy("Raffle", {
    from: deployer,
    args: arguments,
    log: true,
    waitConfirmations: waitBlockConfirmations,
})

console.log("Adding Consumer...")

// Ensure the Raffle contract is a valid consumer of the VRFCoordinatorV2Mock contract.
if (developmentChains.includes(network.name)) {
    await vrfCoordinatorV2Mock.addConsumer(subscriptionId, raffle.address)
}

console.log("Starting the verification process...")
// Verify the deployment
if (!developmentChains.includes(network.name) && process.env.ETHERSCAN_API_KEY) {
    log("Verifying...")
    await verify(raffle.address, arguments)
}

// log("Enter lottery with command:")
// const networkName = network.name == "hardhat" ? "localhost" : network.name
// log(`yarn hardhat run scripts/enterRaffle.js --network ${networkName}`)
// log("----------------------------------------------------")

}

module.exports.tags = ["all", "raffle"]
`

raffle.sol

`
// Raffle
// Enter the Lottery (paying some amount)
// pick a random winner (verifiably random)
// Winner to be selected every X minutes -> completely automated
// Chainlink Oracle -> Randomness, Automated Execution (Chainlink Keepers)

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

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);

/**

• @title A sample Raffle contract

• @author Vatsal Jain

• @notice This contract is for creating an untampable decentralized smart contract

• @dev This implements Chainlink VRFv2 and Chainlink Keepers
  /
  contract Raffle is VRFConsumerBaseV2, KeeperCompatibleInterface {
  / Type Declarations */
  enum RaffleState {
  OPEN,
  CALCULATING
  } //uint256 OPEN=0, CLACULATING=1

  /* 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 RequestedRaffleWinner(uint256 indexed requestId);
  event WinnerPicked(address indexed winner);

  /* Functions */
  constructor(
  address vrfCoordinatorV2, // Contract Address
  uint256 entranceFee,
  bytes32 gasLane,
  uint64 subscriptionId,
  uint32 callBackGasLimit,
  uint256 interval
  ) VRFConsumerBaseV2(vrfCoordinatorV2) {
  i_entranceFee = entranceFee;
  i_vrfCoordinator = VRFCoordinatorV2Interface(vrfCoordinatorV2);
  i_gasLane = gasLane;
  i_subscriptionId = subscriptionId;
  i_callBackGasLimit = callBackGasLimit;
  s_raffleState = RaffleState.OPEN;
  s_lastTimeStamp = block.timestamp;
  i_interval = interval;
  }

  function enterRaffle() public payable {
  // require (msg.value > i_entranceFee, "Not enough ETH")
  if (msg.value < i_entranceFee) {
  revert Raffle__NotEnoughETHEntered();
  }
  if (s_raffleState != RaffleState.OPEN) {
  revert Raffle__NotOpen();
  }
  s_players.push(payable(msg.sender));
  // Emit an Events when we update a dynamic array or mapping
  // Name events with function name reversed
  emit RaffleEnter(msg.sender);
  }

  /**

  • @dev This is the function that the Chainlink Keeper nodes call
  • they look for the "UpkeepNeeded" to return true
  • The following should be true in order to return true
  • 1. Our time interval should have passed.
  • 2. The lottery should have atleast one player, and have some ETH.
  • 3. our Subscription is funded with LINK.
  • 4. The lottery should be in an open state
       /
       function checkUpkeep(
       bytes memory / checkData /
       )
       public
       view
       override
       returns (
       bool upkeepNeeded,
       bytes memory / performData */
       )
       {
       bool isOpen = (RaffleState.OPEN == s_raffleState);
       // (block.timestamp - last block.timestamp) > interval
       bool timePassed = ((block.timestamp - s_lastTimeStamp) > i_interval);
       bool hasPlayers = (s_players.length > 0);
       bool hasBalance = (address(this).balance > 0);
       upkeepNeeded = (isOpen && timePassed && hasBalance && hasPlayers);
       }

  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;
  // Request the random number
  // Once we get it, do something with it
  // 2 Transaction process
  uint256 requestId = i_vrfCoordinator.requestRandomWords(
  i_gasLane, // gasLane
  i_subscriptionId,
  REQUEST_CONFIRMATIONS,
  uint32(i_callBackGasLimit),
  NUM_WORDS
  );
  emit RequestedRaffleWinner(requestId);
  }

  function fulfillRandomWords(
  uint256, /requestId/
  uint256[] memory randomWords
  ) internal override {
  // s_players size = 10
  // random number = 202
  // 202 % 10 = 2
  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;
  s_lastTimeStamp = block.timestamp;
  (bool success, ) = recentWinner.call{value: address(this).balance}("");
  if (!success) {
  revert Raffle__TransferFailed();
  }
  emit WinnerPicked(recentWinner);
  }

  /* View / Pure Functions */

  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;
  }
  }
  `

unit test - Raffle.test.js

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

!developmentChains.includes(network.name)
? describe.skip
: describe("Raffle unit Tests", 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("initialize the raffle correctly", async function () {
              // Ideally we make our tests 1 assert per "it"
              const raffleState = await raffle.getRaffleState()
              assert.equal(raffleState.toString(), "0")
              assert.equal(interval.toString(), networkConfig[chainId]["interval"])
          })
      })

      describe("enter raffle", function () {
          it("reverts when you dont pay enough", async function () {
              await expect(raffle.enterRaffle()).to.be.revertedWith(
                  "Raffle__NotEnoughETHEntered"
              )
          })
          it("record players 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("doesnt 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", [])
              // We pretend to be Chainlink Keeper
              await raffle.performUpkeep([])
              await expect(raffle.enterRaffle({ value: raffleEntranceFee })).to.be.revertedWith(
                  "Raffle__NotOpen"
              )
          })
      })

      describe("checkUpkeep", function () {
          it("returns false if people havent sent any ETH", async function () {
              await network.provider.send("evm_increaseTime", [interval.toNumber() + 1])
              await network.provider.send("evm_mine", [])
              const { upkeepNeeded } = await raffle.callStatic.checkUpkeep([])
              assert(!upkeepNeeded)
          })
          it("returns false if raffle isnt open", 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([])
              const raffleState = await raffle.getRaffleState()
              const { upkeepNeeded } = await raffle.callStatic.checkUpkeep([])
              assert.equal(raffleState.toString(), "1")
              assert(!upkeepNeeded)
          })
          it("returns false if enough time hasn't passed", async () => {
              await raffle.enterRaffle({ value: raffleEntranceFee })
              await network.provider.send("evm_increaseTime", [interval.toNumber() - 5]) // use a higher number here if this test fails
              await network.provider.request({ method: "evm_mine", params: [] })
              const { upkeepNeeded } = await raffle.callStatic.checkUpkeep([]) // upkeepNeeded = (timePassed && isOpen && hasBalance && hasPlayers)
              assert(!upkeepNeeded)
          })
          it("returns true if enough time has passed, has players, eth, and is open", async () => {
              await raffle.enterRaffle({ value: raffleEntranceFee })
              await network.provider.send("evm_increaseTime", [interval.toNumber() + 1])
              await network.provider.request({ method: "evm_mine", params: [] })
              const { upkeepNeeded } = await raffle.callStatic.checkUpkeep([]) // upkeepNeeded = (timePassed && isOpen && hasBalance && hasPlayers)
              assert(upkeepNeeded)
          })
      })

      describe("performUpkeep", function () {
          it("It can only run if checkUpkeep is true", async function () {
              await raffle.enterRaffle({ value: raffleEntranceFee })
              await network.provider.send("evm_increaseTime", [interval.toNumber() + 1])
              await network.provider.request({ method: "evm_mine", params: [] })
              const tx = await raffle.performUpkeep([])
              assert(tx)
          })
          it("reverts when checkUpkeep is false", async function () {
              await expect(raffle.performUpkeep([])).to.be.revertedWith(
                  "Raffle__UpkeepNotNeeded"
              )
          })
          it("updates the raffle state, emits an event, and calls the vrf coordinator", async function () {
              await raffle.enterRaffle({ value: raffleEntranceFee })
              await network.provider.send("evm_increaseTime", [interval.toNumber() + 1])
              await network.provider.request({ method: "evm_mine", params: [] })
              const txResponse = await raffle.performUpkeep([])
              const txReciept = await txResponse.wait(1)
              const raffleState = await raffle.getRaffleState()
              const requestId = txReciept.events[1].args.requestId
              assert(requestId.toNumber() > 0)
              assert(raffleState.toString() == "1")
          })
      })

      describe("fulfillRandomWords", function () {
          beforeEach(async function () {
              await raffle.enterRaffle({ value: raffleEntranceFee })
              await network.provider.send("evm_increaseTime", [interval.toNumber() + 1])
              await network.provider.request({ method: "evm_mine", params: [] })
          })
          it("can only be called after performUpkeep", async function () {
              await expect(
                  vrfCoordinatorV2Mock.fulfillRandomWords(0, raffle.address)
              ).to.be.revertedWith("nonexistent request")
              await expect(
                  vrfCoordinatorV2Mock.fulfillRandomWords(1, raffle.address)
              ).to.be.revertedWith("nonexistent request")
          })
          it("picks a winner, resets the lottery, and sends money", async function () {
              const additionalEntrants = 3
              const startingAccountIndex = 1 // deployer = 0
              const accounts = await ethers.getSigners()
              for (
                  let i = startingAccountIndex;
                  i < startingAccountIndex + additionalEntrants;
                  i++
              ) {
                  const accountConnectedRaffle = raffle.connect(accounts[i])
                  await accountConnectedRaffle.enterRaffle({ value: raffleEntranceFee })
              }
              const startingTimeStamp = await raffle.getLatestTimeStamp()
              // performUpkeep (mock being Chainlink keepers)
              // fulfillRandomWords (mock being the VRF)
              await new Promise(async (resolve, reject) => {
                  raffle.once("WinnerPicked", async () => {
                      console.log("Found the event!")
                      try {
                          const recentWinner = await raffle.getRecentWinner()
                          console.log(recentWinner)
                          console.log(accounts[0].address)
                          console.log(accounts[1].address)
                          console.log(accounts[2].address)
                          console.log(accounts[3].address)
                          const raffleState = await raffle.getRaffleState()
                          const endingTimeStamp = await raffle.getLatestTimeStamp()
                          const numPlayers = await raffle.getNumberOfPlayers()
                          const winnerEndingBalance = await accounts[1].getBalance()
                          assert.equal(numPlayers.toString(), "0")
                          assert.equal(raffleState.toString(), "0")
                          assert(endingTimeStamp > startingTimeStamp)

                          assert.equal(
                              winnerEndingBalance.toString(),
                              winnerStartingBalance.add(
                                  raffleEntranceFee
                                      .mul(additionalEntrants)
                                      .add(raffleEntranceFee)
                                      .toString()
                              )
                          )
                      } catch (e) {
                          reject(e)
                      }
                      resolve()
                  })
                  const tx = await raffle.performUpkeep([])
                  const txReciept = await tx.wait(1)
                  const winnerStartingBalance = await accounts[1].getBalance()
                  await vrfCoordinatorV2Mock.fulfillRandomWords(
                      txReciept.events[1].args.requestId,
                      raffle.address
                  )
              })
          })
      })
  })

`

Please help. Thank you.