Lesson 9 lottery test, can't pass raffle.performUpkeep([])

[tinyhodler]

In Lesson 9 ,video . Patrick made some tests with raffle.performUpkeep([])

              it("doesn't allow entrance when raffle is calculating", async function () {
                  await raffle.enterRaffle({ value: raffleEntranceFee });
                  await network.provider.send("evm_increaseTime", [interval.toNumber() + 1]);
                  await network.provider.send("evm_mine", []);

                  await raffle.performUpkeep([]);
                  await expect(raffle.enterRaffle({ value: raffleEntranceFee })).to.be.revertedWith(
                      "Raffle__NotOpen"
                  );
              });

when I test it, it returns an error

  1) Raffle Unit Tests
       enterRaffle
         doesn't allow entrance when raffle is calculating:
     Error: VM Exception while processing transaction: reverted with custom error 'Raffle__UpkeepNotNeeded(10000000000000000, 1, 0)'
    at Raffle.performUpkeep (contracts/Raffle.sol:100)
    at HardhatNode._mineBlockWithPendingTxs (node_modules\hardhat\src\internal\hardhat-network\provider\node.ts:1773:23)
    at HardhatNode.mineBlock (node_modules\hardhat\src\internal\hardhat-network\provider\node.ts:466:16)        
    at EthModule._sendTransactionAndReturnHash (node_modules\hardhat\src\internal\hardhat-network\provider\modules\eth.ts:1504:18)
    at HardhatNetworkProvider.request (node_modules\hardhat\src\internal\hardhat-network\provider\provider.ts:118:18)
    at EthersProviderWrapper.send (node_modules\@nomiclabs\hardhat-ethers\src\internal\ethers-provider-wrapper.ts:13:20)

Looks like await raffle.performUpkeep([]); doesn't pass. But don't know why

    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;
        bool upkeepNeeded=(isOpen && timePassed && hasPlayers && hasBalance);

    }


    function performUpkeep(bytes calldata /*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_CONFIRMATIONS,
            i_callbackGasLimit,
            NUM_WORDS
            );
        emit RequestedRaffleWinner(requestId);
    }

I modified the code to check await raffle.checkUpkeep([]);

              it("doesn't allow entrance when raffle is calculating", async function () {
                  await raffle.enterRaffle({ value: raffleEntranceFee });
                  await network.provider.send("evm_increaseTime", [interval.toNumber() + 1]);
                  await network.provider.send("evm_mine", []);
                  const test1 = await raffle.checkUpkeep([]);
                  console.log(test1);
                  console.log(test1[0]);
                  console.log(test1[1]);
                  //   await raffle.performUpkeep([]);
                  //   await expect(raffle.enterRaffle({ value: raffleEntranceFee })).to.be.revertedWith(
                  //       "Raffle__NotOpen"
                  //   );
              });

it returns the following

  Raffle Unit Tests
    enterRaffle
{
  hash: '0x91a39444e8f1eb3bd011c47c3e2fb4674790f12516853863efffd08edbe0512c',
  type: 2,
  accessList: [],
  blockHash: '0x50cffb80e879de261d9a5b7979d5e7f72b903831836931b715fa20ef26bdf4da',
  blockNumber: 7,
  transactionIndex: 0,
  confirmations: 1,
  from: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266',
  gasPrice: BigNumber { _hex: '0x53bbc66c', _isBigNumber: true },
  maxPriorityFeePerGas: BigNumber { _hex: '0x3b9aca00', _isBigNumber: true },
  maxFeePerGas: BigNumber { _hex: '0x6bdcc2d8', _isBigNumber: true },
  gasLimit: BigNumber { _hex: '0x01bad598', _isBigNumber: true },
  to: '0xCf7Ed3AccA5a467e9e704C703E8D87F634fB0Fc9',
  value: BigNumber { _hex: '0x00', _isBigNumber: true },
  nonce: 5,
  data: '0x6e04ff0d00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000',
  r: '0x9d6a81075c88fadbb7ef18edd4cea1cba1d6203b5855b7fe261d07502ec44db4',
  s: '0x20a5ca451269dc2c9c1b7fc754ad7e7af42ea34bbcb48fe79223f44ec3de02c1',
  v: 1,
  creates: null,
  chainId: 31337,
  wait: [Function (anonymous)]
}
undefined
undefined
      ✔ doesn't allow entrance when raffle is calculating (46ms)


  1 passing (665ms)

[DmitryLavrov]

May be something wrong with interval. Try temporary hardcoding like this:

await network.provider.send("evm_increaseTime", [31]);

[tinyhodler]

Thank you sir, but it doens't work. Same error.

await raffle.checkUpkeep([])

should return two values, but my output isn't.

[kantoash]

hey dude i have a problem can you solve that out same lesson 9
error on deployment

[kantoash]

error
Error: ERROR processing C:\Users\ASHU\Desktop\Project\lottery\BackEnd\deploy\01-deploy-raffle.js:
Error: invalid arrayify value (argument="value", value="\t0xd89b2bf150e3b9e13446986e571fb9cab24b13cea0a43ea20a6049a85cc807cc", code=INVALID_ARGUMENT, version=bytes/5.6.1)

code here
const { network, ethers } = require("hardhat");
const { developmentChains, networkConfig } = require("../helper-hardhat-config")
const { verify } = require("../utils/verify")

const VRF_SUB_FUND_AMOUNT = ethers.utils.parseEther("30");

module.exports = async function({getNamedAccounts, deployments}) {
const {deploy, log} = deployments;
const { deployer } = await getNamedAccounts();
const chainId = network.config.chainId;

let vrfCoordinatorV2Address, subscriptionId;
if (developmentChains.includes(network.name)) {
   const vrfCoordinatorV2Mock = await ethers.getContract("VRFCoordinatorV2Mock")
   vrfCoordinatorV2Address = vrfCoordinatorV2Mock.address
   const transactionResponse = await vrfCoordinatorV2Mock.createSubscription();
   const transactionReceipt = await transactionResponse.wait(1);
   subscriptionId = transactionReceipt.events[0].args.subId
    //    Fund the Subscription 
    //  Usually you'd need the link token on a real network
    await vrfCoordinatorV2Mock.fundSubscription(subscriptionId, VRF_SUB_FUND_AMOUNT)
} else {
    vrfCoordinatorV2Address = networkConfig[chainId]["vrfCoordinator"]
    subscriptionId = networkConfig[chainId]["subscriptionId"]
}

const entranceFee = networkConfig[chainId]["entranceFee"]
const gasLane = networkConfig[chainId]["gasLane"]
const callbackGasLimit = networkConfig[chainId]["callbackGasLimit"]
const interval =  networkConfig[chainId]["interval"]

const args = [vrfCoordinatorV2Address, 
    entranceFee,
     gasLane,
      subscriptionId,
       callbackGasLimit,
        interval]
const raffle = await deploy("Raffle",{
    from: deployer,
    args: args,
    log: true,
    waitConfirmations: network.config.blockConfirmations || 1,
})

if (!developmentChains.includes(network.name) && process.env.ETHERSCAN_API_KEY) {
    log("Verifying...")
    await verify(raffle.address,args)
}
log("---------------------------------------------")

}

module.exports.tags = ["all", "raffle"]

[DmitryLavrov]

Let's try another way.
For checking upkeepNeeded you can add new function to Raffle.sol

    function checkUpkeepNeeded() public view returns (bool) {
        (bool upkeepNeeded,) = checkUpkeep("");
        return upkeepNeeded;
    }

and check results in raffle.test.js (raffle.test.ts)

        await contractRaffle.enterRuffle({ value: entranceFee })
        await network.provider.send('evm_increaseTime', [parseInt(interval) + 1])
        await network.provider.send('evm_mine', [])
        // await contractRaffle.performUpkeep([])
        const upkeepNeeded = await contractRaffle.checkUpkeepNeeded()
        console.log('upkeepNeeded:',upkeepNeeded)

Result should be like this

upkeepNeeded: true

[tinyhodler]

Thank you sir. upkeepNeeded is false, what should I do?

// Raffle

// Enter the lottery (paying some amount)

// pick a random winner (verifiably random)

// winner to be selected every x minutes -> completely automated

// chainlink oracle -> randomness, automated execution (chainlink keeper)

// SPDX-License-Identifier: MIT

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

contract Raffle is VRFConsumerBaseV2, KeeperCompatibleInterface{

    enum RaffleState{
        OPEN,
        CALCULATING
    }

    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;
    uint32 private immutable i_callbackGasLimit;
    uint16 private constant REQUEST_CONFIRMATIONS=3;
    uint32 private constant NUM_WORDS=1;

    address private s_recentWinner;
    RaffleState private s_raffleState;
    uint256 private s_lastTimeStamp;
    uint256 private immutable i_interval;

    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 an event when we update a dynamic array or mapping
        emit RaffleEnter(msg.sender);
    }

    function checkUpkeepNeeded() public view returns (bool) {
        (bool upkeepNeeded,) = checkUpkeep("");
        return upkeepNeeded;
    }

    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;
        // console.log(hasPlayers);
        bool upkeepNeeded=(isOpen && timePassed && hasPlayers && hasBalance);
    }



    function performUpkeep(bytes calldata /*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_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}("");
        if(!success){
            revert Raffle__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 getRaffleState() public view returns(RaffleState){
        return s_raffleState;
    }

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

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

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

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

[DmitryLavrov]

I think to solve the problem you should replace

bool isOpen=RaffleState.OPEN==s_raffleState;

with

bool isOpen = (s_ruffleState == RaffleState.OPEN);

and

bool hasBalance=address(this).balance>0;

with

bool hasBalance = (address(this).balance > 0);

[vrnezt]

I had the same issue. Solved it by adding:

upkeepNeeded = (timePassed && isOpen && hasBalance && hasPlayers); return (upkeepNeeded, "0x0"); in checkUpkeep function

As shown in the checkUpkeep function on the github repo.

[kantoash]

i figure it out a long ago