Lesson 9 : Staging Test - Error : Timeout of 500000ms exceeded

[Ahmadfareedkhan]

I am stuck at this part from several days and I tried @PatrickAlphaC troubleshooting process but still can't fix my error. I also copy code from @alymurtazamemon repo but still stuck on same error. I read many discussion but not get the desired result. Please consider this and help to get out of this. Thanks!

My staging test

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

developmentChains.includes(network.name)
    ? describe.skip
    : describe("Raffle Staging Tests", 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 and Chainlink VRF, we get a random winner", async function () {
                  // enter the raffle
                  console.log("Setting up test...")
                  const startingTimeStamp = await raffle.getLastTimeStamp()
                  const accounts = await ethers.getSigners()

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

                              await expect(raffle.getPlayer(0)).to.be.reverted
                              assert.equal(recentWinner.toString(), accounts[0].address)
                              assert.equal(raffleState, 0)
                              assert.equal(
                                  winnerEndingBalance.toString(),
                                  winnerStartingBalance.add(raffleEntranceFee).toString()
                              )
                              assert(endingTimeStamp > startingTimeStamp)
                              resolve()
                          } catch (error) {
                              console.log(error)
                              reject(error)
                          }
                      })
                      // Then entering the raffle
                      console.log("Entering Raffle...")
                      const tx = await raffle.enterRaffle({ value: raffleEntranceFee })
                      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 Raffle Contract

pragma solidity ^0.8.9;

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

error Raffle__NotEnoughEthEntered();
error Raffle__TransferFailed();
error Raffle__NotOpen();
error Raffle__upkeepNotNeed(uint256 currentBalance, uint256 numPlayers, uint256 raffleState);

/**@title A sample Raffle Contract
 * @author Ahmad Fareed Khan
 * @notice This contract is for creating a sample raffle contract
 * @dev This implements the Chainlink VRF Version 2
 */
contract Raffle is VRFConsumerBaseV2, KeeperCompatibleInterface {
    /* Type Declarations */
    enum RaffleState {
        OPEN,
        CALCULATING
    }

    /* States 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 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(
        uint32 callbackGasLimit,
        uint64 subscriptionId,
        bytes32 gasLane,
        address vrfCoordinatorV2, // This is contract address
        uint256 entranceFee,
        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 event when we udate a dynamic array or mapping
        // Named events with the funtion name reversed
        emit RaffleEnter(msg.sender);
    }

    /**
     * @dev This is the function that the Chainlink Keeper nodes call
     * they look for `upkeepNeeded` to return True.
     * the following should be true for this to return true:
     * 1. The time interval has passed between raffle runs.
     * 2. The lottery is open.
     * 3. The contract has ETH.
     * 4. Implicity, your subscription is funded with LINK.
     */
    function checkUpkeep(
        bytes memory /* check data */
    )
        public
        override
        returns (
            //view
            bool upkeepNeeded,
            bytes memory /* perfom data */
        )
    {
        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 /* perfom data */
    ) external override {
        (bool upkeepNedeed, ) = checkUpkeep("");
        if (!upkeepNedeed) {
            revert Raffle__upkeepNotNeed(
                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.CALCULATING;
        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);
    }

    /* View / Pure functions */

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

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

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

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

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

My hardhat.config

require("@nomiclabs/hardhat-etherscan")
require("hardhat-deploy")
require("solidity-coverage")
require("hardhat-gas-reporter")
require("hardhat-contract-sizer")
require("dotenv").config()
//require("https").globalAgent.options.ca = require("ssl-root-cas/latest").create()

/**
 * @type import('hardhat/config').HardhatUserConfig
 */

const MAINNET_RPC_URL =
    process.env.MAINNET_RPC_URL ||
    process.env.ALCHEMY_MAINNET_RPC_URL ||
    "https://eth-mainnet.alchemyapi.io/v2/your-api-key"
const RINKEBY_RPC_URL =
    process.env.RINKEBY_RPC_URL || "https://eth-rinkeby.alchemyapi.io/v2/your-api-key"
const KOVAN_RPC_URL = process.env.KOVAN_RPC_URL || "https://eth-kovan.alchemyapi.io/v2/your-api-key"
const POLYGON_MAINNET_RPC_URL =
    process.env.POLYGON_MAINNET_RPC_URL || "https://polygon-mainnet.alchemyapi.io/v2/your-api-key"
const PRIVATE_KEY = process.env.PRIVATE_KEY || "0x"
// optional
const MNEMONIC = process.env.MNEMONIC || "your mnemonic"

// Your API key for Etherscan, obtain one at https://etherscan.io/
const ETHERSCAN_API_KEY = process.env.ETHERSCAN_API_KEY || "Your etherscan API key"
const POLYGONSCAN_API_KEY = process.env.POLYGONSCAN_API_KEY || "Your polygonscan API key"
const REPORT_GAS = process.env.REPORT_GAS || false

module.exports = {
    defaultNetwork: "hardhat",
    networks: {
        hardhat: {
            // // If you want to do some forking, uncomment this
            // forking: {
            //   url: MAINNET_RPC_URL
            // }
            chainId: 31337,
        },
        localhost: {
            chainId: 31337,
        },
        kovan: {
            url: KOVAN_RPC_URL,
            accounts: PRIVATE_KEY !== undefined ? [PRIVATE_KEY] : [],
            //accounts: {
            //     mnemonic: MNEMONIC,
            // },
            saveDeployments: true,
            chainId: 42,
        },
        rinkeby: {
            url: RINKEBY_RPC_URL,
            accounts: PRIVATE_KEY !== undefined ? [PRIVATE_KEY] : [],
            //   accounts: {
            //     mnemonic: MNEMONIC,
            //   },
            saveDeployments: true,
            chainId: 4,
        },
        mainnet: {
            url: MAINNET_RPC_URL,
            accounts: PRIVATE_KEY !== undefined ? [PRIVATE_KEY] : [],
            //   accounts: {
            //     mnemonic: MNEMONIC,
            //   },
            saveDeployments: true,
            chainId: 1,
        },
        polygon: {
            url: POLYGON_MAINNET_RPC_URL,
            accounts: PRIVATE_KEY !== undefined ? [PRIVATE_KEY] : [],
            saveDeployments: true,
            chainId: 137,
        },
    },
    etherscan: {
        // yarn hardhat verify --network <NETWORK> <CONTRACT_ADDRESS> <CONSTRUCTOR_PARAMETERS>
        apiKey: {
            rinkeby: ETHERSCAN_API_KEY,
            kovan: ETHERSCAN_API_KEY,
            polygon: POLYGONSCAN_API_KEY,
        },
    },
    gasReporter: {
        enabled: false,
        currency: "USD",
        outputFile: "gas-report.txt",
        noColors: true,
        // coinmarketcap: process.env.COINMARKETCAP_API_KEY,
    },
    contractSizer: {
        runOnCompile: false,
        only: ["Raffle"],
    },
    namedAccounts: {
        deployer: {
            default: 0, // here this will by default take the first account as deployer
            1: 0, // similarly on mainnet it will take the first account as deployer. Note though that depending on how hardhat network are configured, the account 0 on one network can be different than on another
            4: 0,
        },
        player: {
            default: 1,
        },
    },
    solidity: {
        compilers: [
            {
                version: "0.8.9",
            },
            {
                version: "0.4.24",
            },
        ],
    },
    mocha: {
        timeout: 500000, // 500 seconds max for running tests
        //500000
    },
}

[othaime-en]

How about you try increasing the wait value in tx.wait() in your staging test
Try await tx.wait(2)

[Ahmadfareedkhan]

I tried as you instruction but still got same error

[othaime-en]

Push your code to github and leave a link here

[Ahmadfareedkhan]

This is the link of my repo:
https://github.com/Ahmadfareedkhan/Hardhat-Raffle

[krakxn]

Verify if .env is correct or not.

Also, use this instead as testnets are really slow:

await tx.wait(6)

If the above does not work, please push to GitHub.

[Ahmadfareedkhan]

Still get same error.

[krakxn]

I see. The link to your repo does not work by the way.

[Ahmadfareedkhan]

Ahh, sorry my bad I changed the name of my repo recently.
here's the new link:
https://github.com/Ahmadfareedkhan/hardhat-smartcontract-lottery.git

[krakxn]

It does not work still. :(

[Ahmadfareedkhan]

check now :)

[nebelmeerwanderer1]

I am also stuck here, so would be very interested to hear if someone has found a solution. There are quite a few posts on this topic but none that seem to end up with a smooth execution of the staging test. Nothing like a Sunday afternoon with troubleshooting...

Issue 1:
My staging script times out after "Ok, time to wait..." if I just passively wait. I can go to Etherscan where you can run the individual functions on rinkeby. If i execute

checkUpkeep

then nothing changes, but if I execute

performUpkeep

then the staging test moves on to "WinnerPicked event fired". So far so good. The issue seems to be with checkUpkeep (see also #729 and these troubleshooting guidelines. but I don't know how to solve it.

Issue 2:
Still trouble. The second issue is with WinnerStartingBalance (see #988 )

ReferenceError: Cannot access 'winnerStartingBalance' before initialization

If I try the solution in #988 with setTimeout then it again times out. I have set the mocha timeout to 700 seconds.

Any suggestions or solutions to these problems that are have worked?

here is my code. Unit tests execute like a dream..

[Ahmadfareedkhan]

@nebelmeerwanderer1 have u check with goerli network? If yes then what was the result?

[nebelmeerwanderer1]

Migrating to Goerli now - will keep you posted.

@Ahmadfareedkhan : did you check the solution to issue 1 - changing the import package? that solved the application issue for me and i can test it manually.

[Ahmadfareedkhan]

@nebelmeerwanderer1 I apply as per your instruction on issue no.1, but unfortunately got same error.
Could you please check my repo to see if any thing going wrong from my side.
Here's my repo link:
https://github.com/Ahmadfareedkhan/hardhat-smartcontract-lottery.git

[nebelmeerwanderer1]

Deployed to goerli and what a start: The application works and it passes the test!

[nebelmeerwanderer1]

My repo

[nebelmeerwanderer1]

@Ahmadfareedkhan The link to your repo doesn't work

[nebelmeerwanderer1]

hi @Ahmadfareedkhan

I now have a working version of your repo:

did 3 changes in addition to what was mentioned above:

1. added the magik-sdk package: https://www.npmjs.com/package/magic-sdk - then the verification doesn't throw an error during the deployment. (used yarn add - npm install failed for me)

2. you have one crucial change to make that i only discovered when i ran the staging test on goerli:

in row 139 of your Raffle.sol. Change,

s_raffleState = RaffleState.CALCULATING;

to

s_raffleState = RaffleState.OPEN;

Otherwise it is stuck forever..

3. not sure it is essential but i changed the solidity version from 8.9.0 to 8.7.0

I hope you can get it to work

[nebelmeerwanderer1]

here is the adjusted code: https://github.com/nebelmeerwanderer1/ahmadslottery

change the vrf subscriptionID on goerli to your own ID

[Ahmadfareedkhan]

@nebelmeerwanderer1 I check my code from your repo and copy to my code. I also create new vrf and keepers account with goerli network but still stuck on same error. I updated my repo could u please check it and thanks for guiding me through all of this. :)

[nebelmeerwanderer1]

Hi @Ahmadfareedkhan

I can deploy the code in this repo to Goerli and execute the test. It runs here 0xa357AB5d777f7fC46222941511487443D89403AE

I don't know why it doesn't run with you, i have pushed a new version with a few non-essential changes and it runs even without doing them:

1. unit.test.js: row 161: "assert.equal(raffleState, "1")" change to "assert.equal(raffleState, "0")" as we want the rafflestate to be open. (only relates to the unit test: this was why the unit test didn't catch the Raffle.calculating issue)

2. Raffle.sol: deleted 'view' in checkUpkeep (Now you can call checkUpkeep in etherscan)

One last thing that might make a difference: The deploy might throw an error if you use the newest node version. Run 'nvm use --lts' in your terminal to switch to the latest supported version.

and finally: perhaps there is still an improvement to be made in one of the scripts - the contract runs fine in goerli but for some reason, etherscan does not show the internal txns.

[ashrth]

@nebelmeerwanderer1 I have been working on the same issue since last three days,
My staging test gets stuck at the last console message, I have tried every solution provided in discussions, I also tried changing my import to what you have mentioned above.
Could you please have a look at my repo?
https://github.com/ashrth/Hardhat-Raffle

[DorianDaSilva]

Same issue here...There is a section of the repo that talks about deploying ConsumerV2 and using this contract address to create VRF consumer and upkeep.

I was under the impression that ConsumerV2 would run as a part of Raffle.sol hence no need to deploy it unilaterally but maybe that is the solution, deploying it as a stand alone contract and using that for vrf/keepers.

The issue I find with Goerli is that it is hard to find enough test ETH and LINK to work with it...Maybe something to work on for the future...

[nebelmeerwanderer1]

@DorianDaSilva I hope I am not misunderstood. I don't suggest deploying anything separately.

You should follow Patrick's steps, but the configuration values for goerli are different than for rinkeby.