Lesson 9 <====> TypeError: interval.toNumber is not a function

[Ebenezary]

Each time I try to run the test below:

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

!developmentChains.includes(network.name)
    ? describe.skip
    : describe("Raffle Unit Tests", async function () {
          let raffle,
              vrfCoordinatorV2Mock,
              vrfCoordinatorV2MockContractAddress,
              raffleContractAddress,
              chainId,
              raffleEntranceFee,
              deployer,
              interval
          beforeEach(async function () {
              deployer = (await getNamedAccounts()).deployer
              await deployments.fixture(["all"])
              raffleContractAddress = (await deployments.get("Raffle")).address
              vrfCoordinatorV2MockContractAddress = (await deployments.get("VRFCoordinatorV2Mock"))
                  .address
              raffle = await ethers.getContractAt("Raffle", raffleContractAddress)
              vrfCoordinatorV2Mock = await ethers.getContractAt(
                  "VRFCoordinatorV2Mock",
                  raffleContractAddress,
              )
              raffleEntranceFee = await raffle.getEntranceFee()
              interval = await raffle.getInterval()
          })
          describe("constructor", async function () {
              it("It initializes the raffle correctly", async function () {
                  //Ideally we make our test have just 1 assert per it
                  const raffleState = await raffle.getRaffleState()
                  chainId = network.config.chainId
                  assert.equal(raffleState, 0)
                  assert.equal(interval, networkConfig[chainId]["interval"])
              })
          })
          describe("Enter Raffle", async function () {
              it("reverts raffle when you do not pay enough", async function () {
                  await expect(raffle.enterRaffle()).to.be.revertedWithCustomError(
                      raffle,
                      "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("emit event on enter", async function () {
                  await expect(raffle.enterRaffle({ value: raffleEntranceFee })).to.emit(
                      raffle,
                      "RaffleEnter",
                  )
              })
              it.only("doesnt allow entrance when raffle is calculating", async function () {
                  //   console.log(BigInt(1))
                  await raffle.enterRaffle({ value: raffleEntranceFee })
                  await network.provider.send("evm_increaseTime", [interval.toNumber() + 1])
                  await network.provider.send("evm_mine", [])
                  //we pretend to be a chainlink keeper
                  await raffle.performUpkeep([])
                  await expect(
                      await raffle.enterRaffle({ value: raffleEntranceFee }),
                  ).to.be.revertedWithCustomError(raffle, "Raffle__NotEnoughETHEntered")
              })
          })
      })

I keep getting this error TypeError: interval.toNumber is not a function

[Ebenezary]

Also, I converted interval from BigInt to BigNum and I got the below error:

TypeError: invalid BytesLike value (argument="value", value=[ ], code=INVALID_ARGUMENT, version=6.9.1)

[QingRun-Tan]

I also encountered this problem, did you solve it?

[Ebenezary]

Yes, I did

[jumpupjoran]

how did you solve it?

[Ebenezary]

This above error is coming from await raffle.performUpkeep([]) from Raffle.test.js

You can find below the code for Raffle.sol:

//Raffle
//Enter lottery ( paying certain amount )
//Verifiably pick a winner
//Winners expected to be annouced every X minutes
//Chainlink Oracle => Randomness, automated execution(Chainlink Keeper)

// SPDX-License-Identifier: MIT

pragma solidity 0.8.7;

//imports
// import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
import "@chainlink/contracts/src/v0.8/vrf/VRFConsumerBaseV2.sol";
import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
import "@chainlink/contracts/src/v0.8/automation/AutomationCompatible.sol";
// import "@chainlink/contracts/src/v0.8/shared/access/ConfirmedOwner.sol";

error Raffle__NotEnoughETHEntered();
error Raffle__TransferFailed();
error RaffleState__NotOpen();
error Raffle_UpKeepNotNeeded(uint256 currentBalance, uint256 numPlayers, uint256 raffleState);

/**
 * @title A contract for Raffle /Lottery
 * @author GEO
 * @notice This contract is to showcase untamperable decentralized lottery smart contract
 * @dev This makes use of chainlink VRF V2 and chainlink keeper
 */

contract Raffle is VRFConsumerBaseV2, AutomationCompatibleInterface {
    // Type Declaration
    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;
    uint16 private constant REQUEST_CONFIRMATIONS = 3;
    uint32 private immutable i_callbackGasLimit;
    uint32 private constant NUM_WORDS = 1;

    //Lottery Varaibles

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

    constructor(
        address vrfCoordinatorV2,
        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 {
        if (msg.value < i_entranceFee) {
            revert Raffle__NotEnoughETHEntered();
        }
        if (s_raffleState != RaffleState.OPEN) {
            revert RaffleState__NotOpen();
        }

        s_players.push(payable(msg.sender));
        //Name event with the function name reversed
        emit RaffleEnter(msg.sender);
    }

    /**
     * @dev This is the function the chainlink keeeper node call
     * they look for the `upkeepNeeded` to return true
     * The  following should be true in order to return true
     * 1. Our interval should have passed
     * 2. There should be at 1 player, and should have ETH for gas
     * 3. Our subscripttion 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);
        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);
        // return (upkeepNeeded, "0x0");
    }

    function performUpkeep(bytes calldata /*performData*/) external override {
        //Request the random number
        //Do something with it
        //it is a two transaction process
        (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 RequestedRaffleWinner(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}("");
        // require success
        if (!success) {
            revert Raffle__TransferFailed();
        }
        emit WinnerPicked(recentWinner);
    }

    //view / pure functions

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

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

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

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

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

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

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

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

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

[Codensity30]

@Ebenezary Use this instead, it will work Number(raffleInterval) + 1, what this does is it typecast the raffleInterval to Number and then add 1 to it.

[Ebenezary]

Thanks

[Codensity30]

@Ebenezary No worries, just if possible you can mark it as an answer so that if someone gets the same problem can find the answer easily.