Lesson 9: Staging test get stucked and exced timeout

[ErKable]

Good morning everyone,

i'm curently at lesson 9, specifically at the staging test and I'm stucked in a very weird situation. Here what is happening: basically when i run yarn hardhat test everything work perfectly and all the test are passed. The problem is when i run the staging test with yarn hardhat test --network rinkeby because the test keeps getting stucked and exceeds the timeout, i'm coding along with Patrick - pausing him when i can't write as fast as him. In addition, i have also tried to copy and paste the test in the repo but it happens the same, the code gets blocked while entering the raffle (it seems like it cannot enter) and the goes for the timeout.
The first time i wrote it the test could not get into the try ad verify the expects and the asserts, but it seemed that he could enter the raffle and on the vrf and keeper page i could indeed see the transactions, but it seemed that the test could not get info about this fulfillment and it went for timeout error even though the function were called.

does anyone had the same problem? I checked multiple time the hardhat-config and helper-hardat-config and there aren't differences. Please help me :)

That'is the contract:

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 Io
    @notice Lottery
    @dev oracoli
 */

contract Raffle is VRFConsumerBaseV2, KeeperCompatibleInterface {
    //type declaration
    enum RaffleState {
        OPEN,
        CALCULATING
    } //uint256 0 = OPEN, 1 = CALCULATING
    //state variables
    address payable[] private s_players;
    uint256 private immutable i_entranceFee;
    VRFCoordinatorV2Interface private immutable i_vrfCoordinator;
    bytes32 private immutable i_gasLane;
    uint64 private immutable i_subscriptionId;
    uint32 private immutable i_callbackGasLimit;
    uint32 private constant NUM_WORDS = 1;
    uint16 private constant REQUEST_CONFIMATIONS = 3;

    //lottery variable
    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 Raffle__NotOpen();
        }
        s_players.push(payable(msg.sender));
        emit RaffleEnter(msg.sender);
    }


    function checkUpkeep(
        bytes memory /*checkData*/
    )
        public
        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);
    }

    function performUpkeep(
        bytes memory /*performData */
    ) external override {
        (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_CONFIMATIONS,
            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}("");
        if (!success) {
            revert Raffle__TransferFailed();
        }
        emit winnerPicked(recentWinner);
    }

    //view / pure function

    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; //possiamo dichiarare la funzione come pure peche NUM_WORD è una costante e quindi è scritta nel bytecode del contratto
        //di conseguenza non andiamo a leggere nello storage
    }

    function getNumberOfPlayers() 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_CONFIMATIONS;
    }

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

Thats the test written by me:

const { developmentChains, networkConfig } = require("../../helper-hardhat-congif")
const { assert, expect } = require("chai")

developmentChains.includes(network.name)
    ? describe.skip
    : describe("Raflfe Unit test", function () {
          let raffle, raffleEntranceFee, deployer

          beforeEach(async function () {
              accounts = await ethers.getSigners()
              deployer = await getNamedAccounts().deployer
              raffle = await ethers.getContract("Raffle", deployer)
              raffleEntranceFee = await raffle.getEntranceFee()
          })
          describe("fulfill randomwords", function () {
              it("work with live chainlink keeper and chainlink vrf", async function () {
                  const startingTimeStamp = await raffle.getLatestTimestamp()
                  const accounts = await ethers.getSigners()
                  await new Promise(async (resolve, reject) => {
                      raffle.once("winnerPicked", async () => {
                          console.log("Winner picked and event emitted")
                          try {
                              console.log("nel try")
                              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)
                              assert.equal(raffleState, 0)
                              assert.equal(
                                  winnerEndingBalance.toString(),
                                  winnerStartingBalance.add(raffleEntranceFee).toString()
                              )
                              assert(endingTimestamp > startingTimeStamp)
                              resolve()
                          } catch (e) {
                              console.log(e)
                              reject(e)
                          }
                      })
                      console.log("prima di entrare")
                      await raffle.enterRaffle({ value: raffleEntranceFee })
                      console.log("aspettando...")
                      const winnerStartingBalance = await accounts[0].getBalance()
                  })
              })
          })
      })

it gets stucked at "prima di entrare" and seems that the enterRaffle function doesn't work.

That is what the console prints me:

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


  0 passing (5m)
  1 failing

  1) Raffle Unit 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. (C:\Users\Er Kable.. sePopoLui\Desktop\hardhat-smartcontract-lottery\test\staging\Raffle.Staging.Test.js)
      at listOnTimeout (node:internal/timers:559:17)
      at processTimers (node:internal/timers:502:7)



error Command failed with exit code 1.
info Visit https://yarnpkg.com/en/docs/cli/run for documentation about this command.
PS C:\Users\Er Kable.. sePopoLui\Desktop\hardhat-smartcontract-lottery>

Thanks in advantage to who will answer/help me

EDIT:

After having changed the compiler version as suggested here #300 i have deployed everything again and, as you can see here (https://rinkeby.etherscan.io/address/0xb4d2f16038249cf6269bdfb5bba009b8aa111a48) from the contract side seems that all works, there is the transaction to enter the raffle, also there are the internal transactions to VRF and Keeper and the emits, but the test keeps getting stucked.

[PatrickAlphaC]

Compiler changed worked

#300

[ErKable]

I tried it but still get stucked before the event get fired, in the "edit" I posted what I have made after the compiler changing. On rinkeby eth scan the transaction are shown but the code keeps getting stuck

[PatrickAlphaC]

Try bumping up the timeout amount? I also just updated the code, could you check?

[Tosinkoa]

How did you solve this issue? @ErKable
Pls am facing samething right now