Lesson 9: Error: Timeout of 300000ms exceeded

[margelatufml]

Hi, I am currently in the testing phase, when we connect both, the VRF and keepers to test if the contract execute correctly all the actions behind a lottery app. Currently at (16:28:12)
In my code, I replace raffle with lottery, as names in files, variables, and more

When trying to run the staging test, this error drop:

Error: Timeout of 300000ms exceeded. For async tests and hooks, ensure "done()" is called; if returning a Promise, ensure it resolves.

Trying to verify all the syntax errors without any success, the code looks great based on my verifications with the Patrick's code
My repository: lottery-contract
My staging test file:

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

developmentChains.includes(network.name)
    ? describe.skip
    : describe("Lottery Staging Tests", function () {
          let lottery, lotteryEntranceFee, deployer

          beforeEach(async function () {
              deployer = (await getNamedAccounts()).deployer
              lottery = await ethers.getContract("lottery", deployer)
              lotteryEntranceFee = await lottery.getEntranceFee()
          })

          describe("fulfillRandomWords", function () {
              it("works with live Chainlink Keepers and Chainlink VRF, we get a random winner", async function () {
                  // enter the lottery
                  console.log("Setting up test...")
                  const startingTimeStamp = await lottery.getLatestTimeStamp()
                  const accounts = await ethers.getSigners()

                  console.log("Setting up Listener...")
                  await new Promise(async (resolve, reject) => {
                      // setup listener before we enter the lottery
                      // Just in case the blockchain moves REALLY fast
                      lottery.once("WinnerPicked", async () => {
                          console.log("WinnerPicked event fired!")
                          try {
                              // add our asserts here
                              const recentWinner = await lottery.getRecentWinner()
                              const lotteryState = await lottery.getLotteryState()
                              const winnerEndingBalance = await accounts[0].getBalance()
                              const endingTimeStamp = await lottery.getLatestTimeStamp()

                              await expect(lottery.getPlayer(0)).to.be.reverted
                              assert.equal(recentWinner.toString(), accounts[0].address)
                              assert.equal(lotteryState, 0)
                              assert.equal(
                                  winnerEndingBalance.toString(),
                                  winnerStartingBalance.add(lotteryEntranceFee).toString()
                              )
                              assert(endingTimeStamp > startingTimeStamp)
                              resolve()
                          } catch (error) {
                              console.log(error)
                              reject(error)
                          }
                      })
                      // Then entering the lottery
                      console.log("Entering lottery...")
                      const tx = await lottery.enterlottery({ value: lotteryEntranceFee })
                      await tx.wait(1)
                      console.log("Ok, time to wait...")
                      const winnerStartingBalance = await accounts[0].getBalance()

                      // and this code WONT complete until our listener has finished listening!
                  })
              })
          })
      })

My contract (lottery.sol) :

//Lottery

//Enter the lottery(paying some amount)
//Pick a random winner
//Winner to be selected every x minutes->completely automate
//Chainlink Oracle

//SPDX-License-Identifier:MIT

pragma solidity >=0.8.4;

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 lottery__NotEnoughtETHEntered();
error lottery_TransferFailed();
error lottery_NotOpen();
error lottery_UpkeepNotNeeded(uint256 currentBalance, uint256 numPlayers, uint256 lotteryState);

/**
 * @title A simple lotytery contract
 * @author Air_trader
 * @notice This is a contract for a lottery website
 * @dev This implements ChainlinkVRF adn Keepers
 */

contract lottery is VRFConsumerBaseV2, KeeperCompatibleInterface {
    /**Type declarations*/
    enum LotteryState {
        OPEN,
        CALCULATING
    } //uint256 0=OPEN ,1=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_subscribtionId;
    uint16 private constant REQUEST_CONFIRMATIONS = 3;
    uint32 private immutable i_callbackgasLimit;
    uint32 private constant NUM_WORDS = 1;

    //Lottery Variables
    address private s_recentWinner;
    LotteryState private s_lotterystate;
    uint256 private s_lastTimeStamp;
    uint256 private s_interval;
    /*Events*/
    event LotteryEnter(address indexed player);
    event RequestedLotteryWinner(uint256 indexed requestId);
    event WinnerPicked(address indexed winner);

    constructor(
        address vfrCoordinatorV2, //contract
        uint256 entranceFee,
        bytes32 gasLane,
        uint64 subscribtionId,
        uint32 callbackGasLimit,
        uint256 interval
    ) VRFConsumerBaseV2(vfrCoordinatorV2) {
        i_entranceFee = entranceFee;
        i_vrfCoordinator = VRFCoordinatorV2Interface(vfrCoordinatorV2);
        i_gasLane = gasLane;
        i_subscribtionId = subscribtionId;
        i_callbackgasLimit = callbackGasLimit;
        s_lotterystate = LotteryState.OPEN;
        s_lastTimeStamp = block.timestamp;
        s_interval = interval;
    }

    function enterlottery() public payable {
        //require msg.value>i_entranceFee
        if (msg.value < i_entranceFee) {
            revert lottery__NotEnoughtETHEntered();
        }
        s_players.push(payable(msg.sender));
        //Events
        emit LotteryEnter(msg.sender);
        if (s_lotterystate != LotteryState.OPEN) {
            revert lottery_NotOpen();
        }
    }

    /**
     * @dev This is a function that take thar "UpkeepNeede" to return true
     * The folowing should be true in order to return true:
     * 1.Out time interval should have passed
     * 2.The lottery shold have at least 1 player, and have some ETH
     * 3.Our subsribtion should be founded with LINK
     * 4.Lottery should be in open state
     */
    function checkUpkeep(
        bytes memory /*checkData*/
    ) public override returns (bool upkeepNeeded, bytes memory /*performData*/) {
        bool isOpen = (LotteryState.OPEN == s_lotterystate);
        //block.timestamp- last block timestamp > interval
        bool timePassed = ((block.timestamp - s_lastTimeStamp) > s_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 lottery_UpkeepNotNeeded(
                address(this).balance,
                s_players.length,
                uint256(s_lotterystate)
            );
        }
        s_lotterystate = LotteryState.CALCULATING;
        uint256 requestId = i_vrfCoordinator.requestRandomWords(
            i_gasLane, //gasLane
            i_subscribtionId,
            REQUEST_CONFIRMATIONS,
            i_callbackgasLimit,
            NUM_WORDS
        );
        emit RequestedLotteryWinner(requestId);
    }

    //This will send the money to the winner
    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_lotterystate = LotteryState.OPEN;
        s_players = new address payable[](0);
        s_lastTimeStamp = block.timestamp;
        (bool succes, ) = recentWinner.call{value: address(this).balance}("");
        //require(succes)
        if (!succes) {
            revert lottery_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 getLotteryState() public view returns (LotteryState) {
        return s_lotterystate;
    }

    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 view returns (uint256) {
        return REQUEST_CONFIRMATIONS;
    }

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

For further informations, this repository contain all my code that I use:
lottery-contract repository

As further explanations, this is my terminal output when I run (yarn hardhat test --network goerli)

Lottery Staging Tests
fulfillRandomWords
Setting up test...
Setting up Listener...
Entering lottery...
1) works with live Chainlink Keepers and Chainlink VRF, we get a random winner

0 passing (5m)
1 failing

1. Lottery Staging Tests
   fulfillRandomWords
   works with live Chainlink Keepers and Chainlink VRF, we get a random winner:
   Error: Timeout of 300000ms exceeded. For async tests and hooks, ensure "done()" is called; if returning a Promise, ensure it resolves.

[Yannickdjoa]

hey mate,
check the balance of your wallet. I had the same issue and realised I didnt had enough goerliETH to enter the raffle.
maybe you need to lower the amount to enter the raffle. I had mine at 0.1ETH then changed it to 0.01ETH then I was able to enter the raffle.
you can also just request more testnet ETH
hope it helps

[margelatufml]

I am so glad that this community exist, but unfortunately, I was using 0.01 eth as an entrance fee, with all the changes, verifying the code, again I could not find a solution to my problem. It is so horrible that, in fact it is still taking 0.01 from my wallet, it does absolutely nothing

[alymurtazamemon]

@margelatufml Do not use goerli now. See this announcement #5079.

Also on the Chainlink VRF subscription dashboard, in the History tab, check failed transactions to see the reason for failing transactions.

[margelatufml]

Thx so much for your response and your time, but, after I encounter the same error and take it is taken from my wallet 0.011 eth, it does not show any failed transaction in the history o VRF

[alymurtazamemon]

@margelatufml Are you sure you have given the correct repository link because it shows a fund me project?

[margelatufml]

I am rlly sorry, I created a new repository, this one is the good one: https://github.com/margelatufml/lottery-error

[alymurtazamemon]

@margelatufml I have checked your repo, it still contains the goerli network, please use sepolia and use all the configurations of the sepolia network.

[Mohit20Kumar]

Hey Bro,

follow this discussion, it will help you : #3961