Lesson 9: Mocha timeOut Error when running Staging test

[DorianDaSilva]

Error: Timeout of 500000ms exceeded. For async tests and hooks, ensure "done()" is called; if returning a Promise, ensure it resolves. (/home/ionmind/hh-fcc/hardhat-SmartContract-Lottery-FCC-V2/test/staging/Raffle.staging.test.js)

The Problem

Code breaks when reaching the following line:
await new Promise(async (resolve, reject) => {}

It enters Raffle properly and fetches starting balance but doesn't resolve promise nor does it call VRF & Keepers.

| VRF / Keepers |

• As instructed I created a new subscription & a new consumer using the Raffle.sol contract address
• Used the same contract address to create a new upkeep
• Funded Both vrf & keeper with 10 LINK

=================================================================================

Debugging

I started the entire lesson over from scratch hoping to pin point the issue or any detail missed but still ended up with the same unresolved issue.

Checked:

• All contracts deploy properly on both local network & rinkeby
• Contract verifies on Etherscan
• Enters Raffle funding contract
• All unit tests pass
• VRF & Keepers funded

I tried:

• Increasing Mocha time out to 500000
• Removing await from Promise declaration (Test passes but skips entire try/catch block)
• Tried to add consumer, create new subscriptions and upkeeps multiple times
• Spent hours looking at documentation & forums

===============================================================================

Code

Deployed contract address: 0x11506f3eb3114f8e977af5a6b3b652fcfa566237

|Staging Test|

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

developmentChains.includes(network.name)
    ? describe
    : describe("Raffle", function () {
          let Raffle, raffleEntranceFee, deployer

          beforeEach(async function () {
              deployer = (await getNamedAccounts()).deployer
              Raffle = await ethers.getContract("Raffle", deployer)
              raffleEntranceFee = await Raffle.getEntranceFee()
          })
          describe("fulfillRandomWords", function () {
              it("works with live Chainlink keepers & Chainlink VRF, we get random winner", async function () {
                  //enter the Raffle
                  console.log("Setting up test...")
                  const startingTimeStamp = await Raffle.getLatestTimestamp()
                  const accounts = await ethers.getSigners()

                  console.log("Setting up Listener...")
                  await new Promise(async (resolve, reject) => {
                      //set up listener before we enter the raffle
                      Raffle.once("WinnerPicked", async () => {
                          console.log("WinnerPicked event fired")
                          try {
                              //asserts
                              console.log("Made it here!!!")
                              const recentWinner = await Raffle.getRecentWinner()
                              const raffleState = await Raffle.getRaffleState()
                              const winnerEndingBalance = await accounts[0].getBalance()
                              const endingTimeStamp = await Raffle.getLatestTimestamp()

                              await expect(Raffle.getPlayer(0)).to.be.reverted
                              assert.equal(recentWinner.toString(), accounts[0].address) //deployer
                              assert.equal(raffleState, 0)
                              assert.equal(
                                  winnerEndingBalance.toString(),
                                  winnerStartingBalance.add(raffleEntranceFee).toString()
                              )
                              assert(endingTimeStamp > startingTimeStamp)
                              resolve()
                          } catch (error) {
                              console.log(error)
                              reject(e)
                          }
                      })
                      //entering the raffle
                      console.log("Entering Raffle...")
                      await Raffle.enterRaffle({ value: raffleEntranceFee })
                      console.log("Time to wait...")
                      const winnerStartingBalance = await accounts[0].getBalance()
                      console.log("Listening to new promise...")
                      //Code won't complete until listener is done
                  })
              })
          })
      })

============================================================================

|Hardhat.config|

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

const RINKEBY_RPC_URL = process.env.RINKEBY_RPC_URL
const PRIVATE_KEY = process.env.PRIVATE_KEY
const COINMARKETCAP_API_KEY = process.env.COINMARKETCAP_API_KEY
const ETHERSCAN_API_KEY = process.env.ETHERSCAN_API_KEY

module.exports = {
    solidity: "0.8.9",
    defaultNetwork: "hardhat",
    networks: {
        hardhat: {
            chainId: 31337,
            blockConfirmtions: 1,
        },
        rinkeby: {
            chainId: 4,
            blockConfirmtions: 6,
            url: RINKEBY_RPC_URL,
            accounts: [PRIVATE_KEY],
        },
    },
    gasReporter: {
        enabled: false,
        currency: "USD",
        outputFile: "gas-report.txt",
        noColors: true,
    },

    namedAccounts: {
        deployer: {
            default: 0,
        },
        player: {
            default: 1,
        },
    },
    mocha: {
        timeout: 500000,
    },
    etherscan: {
        apiKey: {
            rinkeby: ETHERSCAN_API_KEY,
        },
    },
}

==============================================================================

|Helper-hardhat-config|

const { ethers } = require("hardhat")
const networkConfig = {
    4: {
        name: "rinkeby",
        vrfCoordinator: "0x6168499c0cFfCaCD319c818142124B7A15E857ab",
        entranceFee: ethers.utils.parseEther("0.01"),
        gasLane: "0xd89b2bf150e3b9e13446986e571fb9cab24b13cea0a43ea20a6049a85cc807cc",
        subscriptionId: "9392",
        callBackGasLimit: "500000",
        interval: "30",
    },
    31337: {
        name: "hardhat",
        entranceFee: ethers.utils.parseEther("0.01"),
        gasLane: "0xd89b2bf150e3b9e13446986e571fb9cab24b13cea0a43ea20a6049a85cc807cc",
        callBackGasLimit: "500000",
        interval: "30",
    },
}

const developmentChains = ["hardhat", "localhost"]

module.exports = {
    networkConfig,
    developmentChains,
}

=================================================================================
What am I missing?

[krakxn]

Make a repo and reply with the link -- I will look into it

[DorianDaSilva]

@krakxn Here is the repo pushed today: https://github.com/DorianDaSilva/Raffle-SmartContract-Lottery.git

I appreciate it, thank you!

[hobbescodes]

@DorianDaSilva check your upkeep because if I recall correctly you need to fund it with more than 10 LINK (I believe that there is a reference that Patrick makes in the course that it should be 13 LINK instead of the 8 LINK or so that he funds it with during the lesson). I know that caused issues for me when I first tried to deploy.

[DorianDaSilva]

@hobbescodes Following your advice I increased funding to 15 LINK for both vrf & upkeeps but still get the timeout error

[letallan]

For some reason Chainlink Keepers works very slowly on the Rinkeby network. I tried the Kovan network for Keeper, it worked fine, but it has no Chainlink VRF. Rinkeby is the only option unfortunately

[letallan]

Counter example (from docs) also doesn't work with Chainlink Keepers on the Rinkeby network. Keepers just don't call performUpkeeper. @PatrickAlphaC maybe you know what this is about )

[DorianDaSilva]

I understand...It's what I thought, there seems to be an issue with rinkeby for this particular function. So we have no way to properly test vrf & keepers function on rinkeby or any testnet? How are we suppused to test before going live then?

[DEFIdaniel1]

Thanks for sharing. That's too bad we can't test it on rinkeby!

[joffenhopland]

I get this exact same error. Any updates on this?

[Benrockiee]

@DorianDaSilva Honestly ive been on this same issue for days, it seems there is no solution for it..

[Muhammad-Abdullah012]

Yes, The code does problems when using
await new Promise(async (resolve, reject) => {} approach.

I think you should try this approach:

                     //entering the raffle
                      console.log("Entering Raffle...")
                      const txResponse = await Raffle.enterRaffle({ value: raffleEntranceFee })
                      const txReceipt = await txResponse.wait(6);
                      console.log("Time to wait...")
                      // emit accepts two parameters, 1st is contract, which will emit event, 2nd is event name in string form
                      expect(txReceipt).to.emit(Raffle, "WinnerPicked");   // Expect the event to fire, 
                     // Now the event is emitted, we can run our code to test for things after event is fired

                    console.log("WinnerPicked event fired")
                          try {
                              //asserts
                              console.log("Made it here!!!")
                              const recentWinner = await Raffle.getRecentWinner()
                              const raffleState = await Raffle.getRaffleState()
                              const winnerEndingBalance = await accounts[0].getBalance()
                              const endingTimeStamp = await Raffle.getLatestTimestamp()

                              await expect(Raffle.getPlayer(0)).to.be.reverted
                              assert.equal(recentWinner.toString(), accounts[0].address) //deployer
                              assert.equal(raffleState, 0)
                              assert.equal(
                                  winnerEndingBalance.toString(),
                                  winnerStartingBalance.add(raffleEntranceFee).toString()
                              )
                              assert(endingTimeStamp > startingTimeStamp)
                          } catch (error) {
                              console.log(error)
                          }
                     

[Sava-B]

i tried this and the recentWinner address was 0x00000000000000000 so the first assert didn't pass. Since the winnerPicked didn't fire. I am running this on a goerli testnet.

[Ebenezary]

For this approach, the recent winner's address comes out to be 0x00000000000000000. I do not know if that was suppose to be the expected result.

[PatrickAlphaC]

The staging tests are a bit more optional as a lot of stuff can error with them, I'd focus on the local pieces and really only attempt to fix the staging tests if you're going to be deploying to a mainnet.

Some of the testnet errors can be elusive :/

[Sava-B]

I am on this same problem and I really want to get to the bottom of this. What do you suggest I do?

P.S I am on the goerli network

[Sava-B]

I am also having this same exact issue.
raffle.once("WinnerPicked", async () => {

The winnerPicked function doesn't get called. I am running this on a goerli network. Does anyone have a solve for this?

[widespreadtruck]

Getting the same error on Goerli

[A-Mannan]

I faced the same problem and I solved it by replacing await with return and also increasing the timeout for this particular test it(...).timeout(10000000) because on testnet it takes much time to execute or transact

[sl-wxx]

I also encounter the staging test hang problem
When I turn off the gas-report, all things work as expected.
Though I don't know why

[Ebenezary]

I am facing similar issue, check out the discussion I created for it. Mine is happening on the unit test.

#6393

[Gandouye]

Error: Timeout of 400000ms exceeded. For async tests and hooks, ensure "done()" is called; if returning a Promise, ensure it resolves.
It took me some time but I went step by step to fix it.
Finally, I saw it was an issue with the latest version of hardhat, ethers…
I am using the latest versions… "ethers": "^6.10.0», «hardhat": "^2.19.4", solidity ^0.8.19
The whole solution could be found at my repo: My Repo or directly at the raffle.staging.test.js @raffle.staging.test.js
Mainly changes in the latest versions… please note the main changes:

const raffleAddress = (await deployments.get("Raffle")).address
raffle = await ethers.getContractAt("Raffle", raffleAddress) //instead of getContract

setTimeout(resolve, 5000)                      
raffle.on("WinnerPicked", async () => { // instead of raffle.once

Hope this will help.