Failed forge test [Foundry Fundamental - Section 4 lesson no. 33 Adding Customer

[RianHodl]

while i forge test --match-test testDontAllowPlayersToEnterWhileRaffleIsCalculating -vvvv
There are errors like this

This is my code on RaffleTest.t.sol

// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;

import {Test} from "lib/chainlink/contracts/src/v0.8/vendor/forge-std/src/Test.sol";
import {DeployRaffle} from "script/DeployRaffle.s.sol";
import {Raffle} from "../../src/Raffle.sol";
import {HelperConfig} from "script/HelperConfig.s.sol";

contract RaffleTest is Test {
    Raffle public raffle;
    HelperConfig public helperConfig;

    uint256 entranceFee;
    uint256 interval;
    address vrfCoordinator;
    bytes32 gasLane;
    uint32 callbackGasLimit;
    uint256 subscriptionId;

    address public PLAYER = makeAddr("player");
    uint256 public constant STARTING_PLAYER_BALANCE = 10 ether;

    event RaffleEntered(address indexed player);
    event WinnerPicked(address indexed winner);

    function setUp() external {
        DeployRaffle deployer = new DeployRaffle();
        (raffle, helperConfig) = deployer.deployContract();
        HelperConfig.NetworkConfig memory config = helperConfig.getConfig();
        entranceFee = config.entranceFee;
        interval = config.interval;
        vrfCoordinator = config.vrfCoordinator;
        gasLane = config.gasLane;
        callbackGasLimit = config.callbackGasLimit;
        subscriptionId = config.subscriptionId;

        vm.deal(PLAYER, STARTING_PLAYER_BALANCE);
    }

    function testRaffleInitializeInOpenState() public view {
        assert(raffle.getRaffleState() == Raffle.RaffleState.OPEN);
    }

    function testRaffleRevertWhenYouDontPayEnough() public {
        // arrange
        vm.prank(PLAYER);
        // act / asset
        vm.expectRevert(Raffle.Raffle_SendMoreToEnterRaffle.selector);
        raffle.enterRaffle();
    }

    function testRaffleRecordsPlayersWhenTheyEnter() public {
        // arrange
        vm.prank(PLAYER);
        // act
        raffle.enterRaffle{value: entranceFee}();
        //Asset
        address playerRecorded = raffle.getPlayer(0);
        assert(playerRecorded == PLAYER);
    }

    function testEnteringRaffleEmitsEvent() public {
        // arrange
        vm.prank(PLAYER);
        // act
        vm.expectEmit(true, false, false, false, address(raffle));
        emit RaffleEntered(PLAYER);
        // Assert
        raffle.enterRaffle{value: entranceFee}();
    }

    function testDontAllowPlayersToEnterWhileRaffleIsCalculating() public {
        // arrange
        vm.prank(PLAYER);
        raffle.enterRaffle{value: entranceFee}();
        vm.warp(block.timestamp + interval + 1);
        vm.roll(block.number + 1);
        raffle.performUpkeep("");
        
        // act // Assert
        vm.expectRevert(Raffle.Raffle_RaffleNotOpen.selector);
        vm.prank(PLAYER);
        raffle.enterRaffle{value: entranceFee}();
    }
}

[KMean]

@RianHodl so is this resolved now?

please share also your Interactions.s.sol

[EngrPips]

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.23;

import {IVRFCoordinatorV2Plus} from "@chainlink/contracts/src/v0.8/vrf/dev/interfaces/IVRFCoordinatorV2Plus.sol";
import {VRFV2PlusClient} from "@chainlink/contracts/src/v0.8/vrf/dev/libraries/VRFV2PlusClient.sol";
import {VRFConsumerBaseV2Plus} from "@chainlink/contracts/src/v0.8/vrf/dev/VRFConsumerBaseV2Plus.sol";
import {AutomationCompatibleInterface} from "@chainlink/contracts/src/v0.8/interfaces/AutomationCompatibleInterface.sol";
import {console2} from "forge-std/Script.sol";

/**
 * @title Raffle
 * @author EngrPips
 * @notice This contract if Particpating in a Raffle and standing the chance to win.
 * @dev This contract heavily implements the chainlink VRF and Automation
 */
// 0x9ddfaca8183c41ad55329bdeed9f6a8d53168b1b => VRFCoordinator 
// 54528670710849503547892655734386820566589065322714869834102560641565075666367 => subId
contract Raffle is VRFConsumerBaseV2Plus, AutomationCompatibleInterface {

    /* ERRORS */
    error Raffle__ValueSentIsLessThanEntryFee();
    error Raffle__NotEnoughTimeHasPassedSinceLastTimeStamp();
    error Raffle__TransferringToWinnerFailed();
    error Raffle__RaffleIsCalculatingWinner();
    error Raffle__RaffleDoesNotNeedUpdate();

    /* USER DEFINED TYPES */
    enum RaffleState {
        OPEN,
        CALCULATING
    }

    /* EVENTS */
    event Raffle__EnteredRaffle(address indexed player);
    event Raffle__winnerSelectedAndPayed(address indexed winner, uint256 indexed amountPaid);
    event Raffle__randomNumberRequested(uint256 indexed requestId);

    /* STATE VARIABLES */

    RaffleState private s_raffleState;
    IVRFCoordinatorV2Plus private immutable i_vrfCoordinatorContract;

    uint16 private constant REQUEST_CONFIRMATIONS = 3;
    uint32 private constant NUM_OF_WORDS = 1;
    uint32 private constant CALLBACK_GAS_LIMIT = 100000;

    uint256 private immutable i_entranceFee;
    uint256 private immutable i_interval;
    uint256 private s_lastTimeStamp;
    uint256 private immutable i_subscriptionId;
    bytes32 private immutable i_gasLane;

    
    address payable private s_recentWinner;
    address payable[] private s_players;

    

    constructor(uint256 _entranceFee, uint256 _interval,address  _vrfCoordinator, bytes32 _gasLane, uint256 _subscriptionId) VRFConsumerBaseV2Plus( _vrfCoordinator) {
        i_entranceFee = _entranceFee;
        i_interval = _interval;
        s_raffleState = RaffleState.OPEN;
        s_lastTimeStamp = block.timestamp;
        i_vrfCoordinatorContract = IVRFCoordinatorV2Plus(_vrfCoordinator);
        i_gasLane = _gasLane;
        i_subscriptionId = _subscriptionId;
    }
    function enter() public payable {
        if (s_raffleState == RaffleState.CALCULATING) revert Raffle__RaffleIsCalculatingWinner();
        if (msg.value < i_entranceFee) revert Raffle__ValueSentIsLessThanEntryFee();
        s_players.push(payable(msg.sender));

        emit Raffle__EnteredRaffle(msg.sender);
    }

    function checkUpkeep(bytes memory /* checkData */ )
        public
        view
        returns (bool upkeepNeeded, bytes memory /* performData */ )
    {
        // We don't use the checkData in this example. The checkData is defined when the Upkeep was registered.
        bool timeHasPassed = block.timestamp - s_lastTimeStamp >= i_interval;
        bool hasPlayer = s_players.length > 0;
        bool hasBalance = address(this).balance > 0;
        bool isOpen = s_raffleState == RaffleState.OPEN;

        upkeepNeeded = (timeHasPassed && hasPlayer && hasBalance && isOpen);
        return(upkeepNeeded, "0x0");
    }

    function performUpkeep(bytes calldata /* performData */) public {
        (bool upkeepNeeded,) = checkUpkeep("");
        if(!upkeepNeeded) revert Raffle__RaffleDoesNotNeedUpdate();
        s_raffleState = RaffleState.CALCULATING;
        console2.log("The address of the lottery contract is: ", address(this));
        uint256 requestId = i_vrfCoordinatorContract.requestRandomWords(VRFV2PlusClient.RandomWordsRequest({
            keyHash: i_gasLane,
            subId: i_subscriptionId,
            requestConfirmations: REQUEST_CONFIRMATIONS,
            callbackGasLimit: CALLBACK_GAS_LIMIT,
            numWords: NUM_OF_WORDS,
            // Set nativePayment to true to pay for VRF requests with Sepolia ETH instead of LINK
            extraArgs: VRFV2PlusClient._argsToBytes(VRFV2PlusClient.ExtraArgsV1({nativePayment: false}))
        }));
        emit Raffle__randomNumberRequested(requestId);
    }

    function fulfillRandomWords(uint256 /* requestId */, uint256[] memory randomWords) internal override {
        uint256 indexOfWinner = randomWords[0] % s_players.length;
        address payable addressOfWinner = s_players[indexOfWinner];
        s_recentWinner = addressOfWinner;
        emit Raffle__winnerSelectedAndPayed(addressOfWinner, address(this).balance);
        s_players = new address payable[](0);
        s_lastTimeStamp = block.timestamp;
        s_raffleState = RaffleState.OPEN;
        (bool success,) = addressOfWinner.call{value: address(this).balance}("");
        if (!success) revert Raffle__TransferringToWinnerFailed();
    }

    /** GETTERS */

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

    function getRaffleState() external view returns(uint256) {
        return uint256(s_raffleState);
    }

    function getPlayerAtGivenIndex(uint256 _index) public view returns(address) {
        return s_players[_index];
    }

    function getRecentWinner() external view returns(address) {
        return s_recentWinner;
    }

    function getLengthOfParticipantsArray() external view returns(uint256) {
        return s_players.length;
    }

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

}

[KMean]

@EngrPips oh yeah that works absolutely fine... he was creating a VRFV2PlusClient.RandomWordsRequest object and then not using it

VRFV2PlusClient.RandomWordsRequest memory request = VRFV2PlusClient.RandomWordsRequest({
            keyHash: i_gasLane,
            subId: i_subscriptionId,
            requestConfirmations: REQUEST_CONFIRMATIONS,
            callbackGasLimit: i_callbackGasLimit,
            numWords: NUM_WORDS,
            extraArgs: VRFV2PlusClient._argsToBytes(
                // Set nativePayment to true to pay for VRF requests with Sepolia ETH instead of LINK
                VRFV2PlusClient.ExtraArgsV1({nativePayment: false})
            )
        });

        uint256 requestId = i_vrfCoordinator.requestRandomWords(
            i_gasLane, uint64(i_subscriptionId), REQUEST_CONFIRMATIONS, i_callbackGasLimit, NUM_WORDS
        );

he could probably just change the request id to

uint256 requestId = i_vrfCoordinator.requestRandomWords(request);

and should work. I think the repo is not using that path though and you probably save a liitle bit of gas by not creating another state variable even if immutable.

[EngrPips]

Yeah. But it is what it is lol.

[RianHodl]

I tried it as you suggested, but it's still not working.

here is my code:

// SPDX-License-Identifier: SEE LICENSE IN LICENSE
pragma solidity 0.8.19;

// import {VRFConsumerBaseV2Plus} from "@chainlink/v0.8/vrf/dev/VRFConsumerBaseV2Plus.sol";
// import {VRFV2PlusClient} from "@chainlink/contracts/src/v0.8/vrf/dev/libraries/VRFV2PlusClient.sol";
import {VRFCoordinatorV2Interface} from "lib/chainlink/contracts/src/v0.8/vrf/interfaces/VRFCoordinatorV2Interface.sol";
import {VRFConsumerBaseV2Plus} from "lib/chainlink/contracts/src/v0.8/vrf/dev/VRFConsumerBaseV2Plus.sol";
import {VRFV2PlusClient} from "lib/chainlink/contracts/src/v0.8/vrf/dev/libraries/VRFV2PlusClient.sol";

/// @title A sample Raffle contract
/// @author Rian
/// @notice this contract is for creating a sample raffle
/// @dev Implements chainlink VRFv2.5

contract Raffle is VRFConsumerBaseV2Plus {
    // error
    error Raffle_SendMoreToEnterRaffle();
    error Raffle_TransferFailed();
    error Raffle_RaffleNotOpen();
    error Raffle_UpkeepNotNeeded(uint256 balance, uint256 playersLenght, uint256 RaffleState);

    event RequestIdGenerated(uint256 requestId);

    // type declarations
    enum RaffleState {


        OPEN, // 0
        CALCULATING // 1

    }

    // state variables
    uint256 private immutable i_entranceFee;
    /// @dev the duration of the lottery in seconds
    
    uint256 private immutable i_interval;

    bytes32 private immutable i_gasLane;
    uint256 private immutable i_subscriptionId;
    uint16 private constant REQUEST_CONFIRMATIONS = 3;
    uint32 private immutable i_callbackGasLimit;
    uint32 private constant NUM_WORDS = 1;
    address payable[] private s_players;
    uint256 private s_lastTimeStamp;
    address private s_recentWinner;
    RaffleState private s_raffleState;

    // events
    event RaffleEntered(address indexed player);
    event WinnerPicked(address indexed winner);

    // what data structure should we use? how to keep track of all players?

    constructor(
        uint256 entranceFee,
        uint256 interval,
        address vrfCoordinator,
        bytes32 gasLane,
        uint256 subscriptionId,
        uint32 callbackGasLimit
    ) VRFConsumerBaseV2Plus(vrfCoordinator) {
        i_entranceFee = entranceFee;
        i_interval = interval;
        s_lastTimeStamp = block.timestamp;
        
        i_gasLane = gasLane;
        i_subscriptionId = subscriptionId;
        i_callbackGasLimit = callbackGasLimit;

        s_raffleState = RaffleState.OPEN;
    }

    function enterRaffle() external payable {
        // require(msg.value >= i_entranceFee, "Not enough ETH sent!");
        // require(msg.value >= i_entranceFee, SendMoreToEnterRaffle());
        if (msg.value < i_entranceFee) {
            revert Raffle_SendMoreToEnterRaffle();
        }

        if (s_raffleState != RaffleState.OPEN) {
            revert Raffle_RaffleNotOpen();
        }

        s_players.push(payable(msg.sender));
        // 1. Makes migration easier
        // 2. makes front end "indexing" easier
        emit RaffleEntered(msg.sender);
    }

    // when should the winner be picked?
    /**
     * @dev this is the function that the chainlink nodes will call to see
     * if the lottery is ready to have a winner picked.
     * the following should be true in order for upkeepNeeded to be true:
     * 1. The time interval has passed between raffle runs
     * 2. the lottery is open
     * 3. the contract has ETH
     * 4 Implicitly, your subscription has LINK
     * @param - ignored
     * @return upkeepNeeded - true if its time to restart the lottery
     * @return - ignored
     */
    function checkUpkeep(bytes memory /* checkData */ )
        public
        view
        returns (bool upkeepNeeded, bytes memory /* performData */ )
    {
        bool timeHasPassed = (block.timestamp - s_lastTimeStamp >= i_interval);
        bool isOpen = s_raffleState == RaffleState.OPEN;
        bool hasBalance = address(this).balance > 0;
        bool hasPlayers = s_players.length > 0;
        upkeepNeeded = timeHasPassed && isOpen && hasBalance && hasPlayers;
        return (upkeepNeeded, "");
    }

    // 1. get a random number
    // 2. use random number to pick a player
    // 3. be automatically called
    function performUpkeep(bytes calldata /* performData */ ) external {
        // check to see if enough time has passed
        (bool upkeepNeeded,) = checkUpkeep("");
        if (!upkeepNeeded) {
            revert Raffle_UpkeepNotNeeded(address(this).balance, s_players.length, uint256(s_raffleState));
        }

        s_raffleState = RaffleState.CALCULATING;

        VRFV2PlusClient.RandomWordsRequest memory request = VRFV2PlusClient.RandomWordsRequest({
            keyHash: i_gasLane,
            subId: i_subscriptionId,
            requestConfirmations: REQUEST_CONFIRMATIONS,
            callbackGasLimit: i_callbackGasLimit,
            numWords: NUM_WORDS,
            extraArgs: VRFV2PlusClient._argsToBytes(
                // Set nativePayment to true to pay for VRF requests with Sepolia ETH instead of LINK
                VRFV2PlusClient.ExtraArgsV1({nativePayment: false})
            )
        });

        uint256 requestId = s_vrfCoordinator.requestRandomWords(request);
    }

    // CEI: Checks, Effects, Interactions Pattern
    function fulfillRandomWords(uint256, /*requestId8*/ uint256[] memory randomWords) internal override {
        // checks

        // effect (internal contract states)
        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;

        // interactions (external contract interaction)
        (bool success,) = recentWinner.call{value: address(this).balance}("");
        if (success) {
            revert Raffle_TransferFailed();
        }
        emit WinnerPicked(recentWinner);
    }

    /**
     * Getter Functions
     */
    function getEntranceFee() external view returns (uint256) {
        return i_entranceFee;
    }

    function getRaffleState() external view returns (RaffleState) {
        return s_raffleState;
    }

    function getPlayer(uint256 indexOfPlayer) external view returns (address) {
        return s_players[indexOfPlayer];
    }
}

this is the error problems

Data locations of parameters have to be the same when overriding non-external functions, but they differ.

[EngrPips]

Your fulfillRandomWords declaration seems a little bit off because you wrote the commented variable /*requestId8* after applying coma to the variable type, I am unsure if that is what is causing the issue.

function fulfillRandomWords(uint256, /*requestId8*/ uint256[] memory randomWords) internal override 

Make your fulfillRandomWords function declaration be the below, and let's see if the issue persists.

function fulfillRandomWords(uint256 /* requestId */, uint256[] memory randomWords) internal override 

[MrRobWeb]

Your error occurs while executing requestRandomWords() from VRFV2PlusClient. And what seems to be odd is your subscription id. The subsciption id should be an uint256. In your execution your subscription Id seems to be an uint64 (the number 15065691140667349564), which was used before chainlink has updated it to uint256.

Thus, have you created a subscription id for chainlink?
And have you used this subsciption id in your Helperconfig?

[RianHodl]

this is my code on HelperConfig:

// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;

import {Script} from "lib/chainlink/contracts/src/v0.8/vendor/forge-std/src/Script.sol";
import {VRFCoordinatorV2_5Mock} from "lib/chainlink/contracts/src/v0.8/vrf/mocks/VRFCoordinatorV2_5Mock.sol";
import {LinkToken} from "test/mocks/LinkToken.sol";

abstract contract CodeConstants {
    /* VRF Mock Values */
    uint96 public MOCK_BASE_FEE = 0.25 ether;
    uint96 public MOCK_GAS_PRICE_LINK = 1e9;
    // LINK / ETH price
    int256 public MOCK_WEI_PER_UINT_LINK = 4e15;

    uint256 public constant ETH_SEPOLIA_CHAIN_ID = 11155111;
    uint256 public constant LOCAL_CHAIN_ID = 31337;
}

contract HelperConfig is CodeConstants, Script {
    error HelperConfig__InvalidChainId();

    struct NetworkConfig {
        uint256 entranceFee;
        uint256 interval;
        address vrfCoordinator;
        bytes32 gasLane;
        uint32 callbackGasLimit;
        uint256 subscriptionId;
        address link;
    }

    NetworkConfig public localNetworkConfig;
    mapping(uint256 chainId => NetworkConfig) public networkConfigs;

    constructor() {
        networkConfigs[11155111] = getSepoliaEthConfig();
    }

    function getConfigByChainId(uint256 chainId) public returns (NetworkConfig memory) {
        if (networkConfigs[chainId].vrfCoordinator != address(0)) {
            return networkConfigs[chainId];
        } else if (chainId == LOCAL_CHAIN_ID) {
            return getCreateAnvilEthConfig();
        } else {
            revert HelperConfig__InvalidChainId();
        }
    }

    function getConfig() public returns (NetworkConfig memory) {
        return getConfigByChainId(block.chainid);
    }

    function getSepoliaEthConfig() public pure returns (NetworkConfig memory) {
        return NetworkConfig({
            entranceFee: 0.01 ether, //1e16
            interval: 30, // 30 seconds
            vrfCoordinator: 0x9DdfaCa8183c41ad55329BdeeD9F6A8d53168B1B,
            gasLane: 0x787d74caea10b2b357790d5b5247c2f63d1d91572a9846f780606e4d953677ae,
            callbackGasLimit: 500000, //500,000 gas
            subscriptionId: 106881395174226492242626717564426048031648470934917560965949812703812917472894,
            link: 0x779877A7B0D9E8603169DdbD7836e478b4624789
        });
    }

    function getCreateAnvilEthConfig() public returns (NetworkConfig memory) {
        // check to see if we set an active network
        if (localNetworkConfig.vrfCoordinator != address(0)) {
            return localNetworkConfig;
        }

        // Deploy mocks and such
        vm.startBroadcast();
        VRFCoordinatorV2_5Mock vrfcoordinatorMock =
            new VRFCoordinatorV2_5Mock(MOCK_BASE_FEE, MOCK_GAS_PRICE_LINK, MOCK_WEI_PER_UINT_LINK);
            LinkToken linkToken = new LinkToken();
        
        vm.stopBroadcast();

        localNetworkConfig = NetworkConfig({
            entranceFee: 0.01 ether,
            interval: 30, // 30 seconds
            vrfCoordinator: address(vrfcoordinatorMock),
            // doesn't matter
            gasLane: 0x787d74caea10b2b357790d5b5247c2f63d1d91572a9846f780606e4d953677ae,
            callbackGasLimit: 500000, //500,000 gas
            subscriptionId: 0, // might to have fix this
            link: address(linkToken)
        });

        return localNetworkConfig;
    }
}