Lesson 9: Getting Event Data into Foundry Scripts [FAIL. Reason: panic: array out-of-bounds access (0x32)] testPerformUpkeepUpdatesRaffleStateAndEmitsRequestId()

[MainKlain]

I'm coding along Patrick, those are the codes so far that i was coding along:

Raffle.sol:

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.18;

import {VRFCoordinatorV2Interface} from "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
import {VRFConsumerBaseV2} from "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";

/**
 * @title A sample Raffle Contract
 * @author Manolis Emmanouil
 * @notice This contract is for creating a sample raffle
 * @dev Implements ChainLink VRFv2
 */
contract Raffle is VRFConsumerBaseV2 {
    error Raffle__NotEnoughEthSent();
    error Raffle__TransferFailed();
    error Raffle__RaffleNotOpen();
    error Raffle__UpkeepNotNeeded(
        uint256 currentBalance,
        uint256 numPlayers,
        uint256 raffleState
    );

    /** Type Declarations */
    enum RaffleState {
        OPEN, // 0
        CALCULATING // 1
    }

    /** State Variables */
    uint16 private constant REQUEST_CONFIRMATIONS = 3;
    uint32 private constant NUM_WORDS = 1;

    uint256 private immutable i_entranceFee;
    uint256 private immutable i_interval;
    VRFCoordinatorV2Interface private immutable i_vrfCoordinator;
    bytes32 private immutable i_gasLane;
    uint64 private immutable i_subscriptionId;
    uint32 private immutable i_callBackGasLimit;

    address payable[] private s_players;
    uint256 private s_lastTimeStamp;
    address private s_recentWinner;
    RaffleState private s_raffleState;

    /** Events */
    event EnteredRaffle(address indexed player);
    event PickedWinner(address indexed winner);
    event RequestRaffleWinner(uint256 indexed requestId);

    constructor(
        uint64 subscriptionId,
        bytes32 gasLane, // keyHash
        uint256 interval,
        uint256 entranceFee,
        uint32 callbackGasLimit,
        address vrfCoordinator
    ) VRFConsumerBaseV2(vrfCoordinator) {
        i_vrfCoordinator = VRFCoordinatorV2Interface(vrfCoordinator);
        i_gasLane = gasLane;
        i_interval = interval;
        i_subscriptionId = subscriptionId;
        i_entranceFee = entranceFee;
        i_callBackGasLimit = callbackGasLimit;

        s_raffleState = RaffleState.OPEN;
        s_lastTimeStamp = block.timestamp;
    }

    function enterRaffle() external payable {
        //require(msg.value >= i_entranceFee, "Not Enough ETH Sent!");
        if (msg.value < i_entranceFee) {
            revert Raffle__NotEnoughEthSent();
        }
        if (s_raffleState != RaffleState.OPEN) {
            revert Raffle__RaffleNotOpen();
        }
        s_players.push(payable(msg.sender));
        // 1. Make migration easier
        // 2. Makes front end "indexing" easier
        emit EnteredRaffle(msg.sender);
    }

    /**
     * @dev This is the function that the ChainLink Automation nodes call
     * to see if it's time to perform an upKepp.
     * The The following should be true for this to return true
     * 1. The time interval has passed between raffle runs
     * 2. The raffle is in the OPEN state
     * 3. The contract has ETH (aka, players)
     * 4. (Implicit) the subscription is funded with LINK
     */

    function checkUpKeep(
        bytes memory /* checkData */
    ) public view returns (bool upkeepNeeded, bytes memory /* performData */) {
        bool timeHasPassed = (block.timestamp - s_lastTimeStamp) >= i_interval;
        bool isOpen = RaffleState.OPEN == s_raffleState;
        bool hasBalance = address(this).balance > 0;
        bool hasPlayers = s_players.length > 0;
        upkeepNeeded = (timeHasPassed && isOpen && hasBalance && hasPlayers);
        return (upkeepNeeded, "0x0");
    }

    function performUpkeep(bytes calldata /* performData */) external {
        (bool upkeepNeeded, ) = checkUpKeep("");
        if (!upkeepNeeded) {
            revert Raffle__UpkeepNotNeeded(
                address(this).balance,
                s_players.length,
                uint256(s_raffleState)
            );
        }
        // check to see if enough time passed
        s_raffleState = RaffleState.CALCULATING;
        uint256 requestId = i_vrfCoordinator.requestRandomWords(
            i_gasLane,
            i_subscriptionId,
            REQUEST_CONFIRMATIONS,
            i_callBackGasLimit,
            NUM_WORDS
        );
        emit RequestRaffleWinner(requestId);
    }

    function fulfillRandomWords(
        uint256 /*requestId*/,
        uint256[] memory randomWords
    ) internal override {
        // s_players = 10
        // rng = 12
        // 12 % 10 = 2 <-
        // 183878753994814984199809309485 % 10 = 5
        uint256 indexOfWinner = randomWords[0] % s_players.length;
        address payable winner = s_players[indexOfWinner];
        s_recentWinner = winner;
        s_raffleState = RaffleState.OPEN;
        s_players = new address payable[](0);
        s_lastTimeStamp = block.timestamp;
        (bool success, ) = winner.call{value: address(this).balance}("");
        if (!success) {
            revert Raffle__TransferFailed();
        }
        emit PickedWinner(winner);
    }

    /** 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];
    }
}

HelperConfig.s.sol:

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.18;

import {Script} from "forge-std/Script.sol";
import {VRFCoordinatorV2Mock} from "@chainlink/contracts/src/v0.8/mocks/VRFCoordinatorV2Mock.sol";
import {LinkToken} from "../test/mocks/LinkToken.sol";

contract HelperConfig is Script {
    struct NetworkConfig {
        uint64 subscriptionId;
        bytes32 gasLane; // keyHash
        uint256 interval;
        uint256 entranceFee;
        uint32 callbackGasLimit;
        address vrfCoordinator;
        address link;
    }

    NetworkConfig public activeNetworkConfig;

    constructor() {
        if (block.chainid == 11155111) {
            activeNetworkConfig = getSepoliaEthConfig();
        } else {
            activeNetworkConfig = getOrCreateAnvilEthConfig();
        }
    }

    function getSepoliaEthConfig() public pure returns (NetworkConfig memory) {
        return
            NetworkConfig({
                entranceFee: 0.01 ether,
                interval: 30,
                vrfCoordinator: 0x8103B0A8A00be2DDC778e6e7eaa21791Cd364625,
                gasLane: 0x474e34a077df58807dbe9c96d3c009b23b3c6d0cce433e59bbf5b34f823bc56c,
                subscriptionId: 8250, // Update this with our subId!
                callbackGasLimit: 500000, // 500,000 gas!
                link: 0x779877A7B0D9E8603169DdbD7836e478b4624789
            });
    }

    function getOrCreateAnvilEthConfig() public returns (NetworkConfig memory) {
        if (activeNetworkConfig.vrfCoordinator != address(0)) {
            return activeNetworkConfig;
        } else {
            uint96 baseFee = 0.25 ether; // 0,25 LINK
            uint96 gasPriceLink = 1e9; // 1 gwei LINK

            vm.startBroadcast();
            VRFCoordinatorV2Mock vrfCoordinatorMock = new VRFCoordinatorV2Mock(
                baseFee,
                gasPriceLink
            );
            LinkToken link = new LinkToken();
            vm.stopBroadcast();

            return
                NetworkConfig({
                    entranceFee: 0.01 ether,
                    interval: 30,
                    vrfCoordinator: address(vrfCoordinatorMock),
                    gasLane: 0x474e34a077df58807dbe9c96d3c009b23b3c6d0cce433e59bbf5b34f823bc56c,
                    subscriptionId: 0, // our script will add this!
                    callbackGasLimit: 500000, // 500,000 gas!
                    link: address(link)
                });
        }
    }
}

RaffleTest.t.sol:

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.18;

import {DeployRaffle} from "../../script/DeployRaffle.s.sol";
import {Raffle} from "../../src/Raffle.sol";
import {Test, console} from "forge-std/Test.sol";
import {HelperConfig} from "../../script/HelperConfig.s.sol";
import {Vm} from "forge-std/Vm.sol";

contract RaffleTest is Test {
    /* Events */
    event EnteredRaffle(address indexed player);

    Raffle raffle;
    HelperConfig helperConfig;

    uint64 subscriptionId;
    bytes32 gasLane; // keyHash
    uint256 interval;
    uint256 entranceFee;
    uint32 callbackGasLimit;
    address vrfCoordinator;
    address link;

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

    function setUp() external {
        DeployRaffle deployer = new DeployRaffle();
        (raffle, helperConfig) = deployer.run();
        (
            subscriptionId,
            gasLane, // keyHash
            interval,
            entranceFee,
            callbackGasLimit,
            vrfCoordinator,
            link
        ) = helperConfig.activeNetworkConfig();
        vm.deal(PLAYER, STARTING_USER_BALANCE);
    }

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

    function testRaffleRevertsWhenYouDontPayEnough() public {
        // Arrange
        vm.prank(PLAYER);
        // Act/ Assert
        vm.expectRevert(Raffle.Raffle__NotEnoughEthSent.selector);
        raffle.enterRaffle();
    }

    function testRaffleRecordsPlayerWhenTheyEnter() public {
        vm.prank(PLAYER);
        raffle.enterRaffle{value: entranceFee}();
        address playerRecorded = raffle.getPlayer(0);
        assert(playerRecorded == PLAYER);
    }

    function testEmitsEventOnEntrance() public {
        vm.prank(PLAYER);
        vm.expectEmit(true, false, false, false, address(raffle));
        emit EnteredRaffle(PLAYER);
        raffle.enterRaffle{value: entranceFee}();
    }

    function testCantEnterWhenRaffleIsCalculating() public {
        vm.prank(PLAYER);
        raffle.enterRaffle{value: entranceFee}();
        vm.warp(block.timestamp + interval + 1);
        vm.roll(block.number + 1);
        raffle.performUpkeep("");

        vm.expectRevert(Raffle.Raffle__RaffleNotOpen.selector);
        vm.prank(PLAYER);
        raffle.enterRaffle{value: entranceFee}();
    }

    ///////////////////////
    // checkUpkeep      //
    /////////////////////
    function testCheckUpkeepReturnsFalseIfItHasNoBalance() public {
        // Arrange
        vm.warp(block.timestamp + interval + 1);
        vm.roll(block.number + 1);

        //Act
        (bool upkeepNeeded, ) = raffle.checkUpKeep("hasBalance");

        // Assert
        assert(!upkeepNeeded);
    }

    function testCheckUpkeepReturnsFalseIfRaffleNotOpen() public {
        // Arrange
        vm.prank(PLAYER);
        raffle.enterRaffle{value: entranceFee}();
        vm.warp(block.timestamp + interval + 1);
        vm.roll(block.number + 1);
        raffle.performUpkeep("isOpen");

        // Act
        (bool upkeepNeeded, ) = raffle.checkUpKeep("isOpen");

        // Assert
        assert(upkeepNeeded == false);
    }

    function testCheckUpkeepReturnsFalseIfEnoughTimeHasPassed() public {
        // Arrange
        vm.prank(PLAYER);
        raffle.enterRaffle{value: entranceFee}();
        vm.warp(block.timestamp + interval + 1); // Ensure enough time has passed
        vm.roll(block.number + 1);
        raffle.performUpkeep("timeHasPassed");

        // Act: Check the condition after enough time has passed
        (bool upkeepNeeded, ) = raffle.checkUpKeep("timeHasPassed");

        // Assert
        assert(upkeepNeeded == false); // Assuming upkeep is not needed after time passed
    }

    function testCheckUpkeepReturnsTrueWhenParametersGood() public {
        // Arrange
        vm.prank(PLAYER);
        raffle.enterRaffle{value: entranceFee}();
        vm.warp(block.timestamp + interval + 1);
        vm.roll(block.number + 1);

        // Act
        (bool upkeepNeeded, ) = raffle.checkUpKeep("");

        // Assert
        assert(upkeepNeeded);
    }

    /////////////////////////
    // performUpkeep       //
    /////////////////////////

    function testPerformUpkeepCabOnlyRunIfCheckUpkeepIsTrue() public {
        // Arrange
        vm.prank(PLAYER);
        raffle.enterRaffle{value: entranceFee}();
        vm.warp(block.timestamp + interval + 1);
        vm.roll(block.number + 1);

        // Act / Assert
        // It doesnt revert
        raffle.performUpkeep("");
    }

    function testPerformUpkeepRevertsIfCheckUpkeepIsFalse() public {
        // Arrange
        uint256 currentBalance = 0;
        uint256 numPlayers = 0;
        uint256 raffleState = 0;

        // Act / Assert
        vm.expectRevert(
            abi.encodeWithSelector(
                Raffle.Raffle__UpkeepNotNeeded.selector,
                currentBalance,
                numPlayers,
                raffleState
            )
        );
        raffle.performUpkeep("");
    }

    modifier raffleEnteredAndTimePassed() {
        vm.prank(PLAYER);
        raffle.enterRaffle{value: entranceFee}();
        vm.warp(block.timestamp + interval + 1);
        vm.roll(block.number + 1);
        _;
    }

    function testPerformUpkeepUpdatesRaffleStateAndEmitsRequestId()
        public
        raffleEnteredAndTimePassed
    {
        // Act
        vm.recordLogs();
        raffle.performUpkeep(""); // emits requestId
        Vm.Log[] memory entries = vm.getRecordedLogs();
        bytes32 requestId = entries[1].topics[1];

        // Assert
        Raffle.RaffleState raffleState = raffle.getRaffleState();
        // requestId = raffle.getLastRequestId();
        assert(uint256(requestId) > 0);
        assert(uint(raffleState) == 1); // 0 = open, 1 = calculating
    }
}

And i encounter this FAIL:

~/foundry-f23/foundry-smart-contract-lottery-f23$ forge test --mt testPerformUpkeepUpdatesRaffleStateAndEmitsRequestId 
[⠔] Compiling...
[⠑] Compiling 1 files with 0.8.19
[⠘] Solc 0.8.19 finished in 7.11s
Compiler run successful!

Running 1 test for test/unit/RaffleTest.t.sol:RaffleTest
[FAIL. Reason: panic: array out-of-bounds access (0x32)] testPerformUpkeepUpdatesRaffleStateAndEmitsRequestId() (gas: 145684)
Test result: FAILED. 0 passed; 1 failed; 0 skipped; finished in 9.33ms

This is the FAIL with -vvvvv:

~/foundry-f23/foundry-smart-contract-lottery-f23$ forge test --mt testPerformUpkeepUpdatesRaffleStateAndEmitsRequestId -vvvvv
[⠑] Compiling...
No files changed, compilation skipped

Running 1 test for test/unit/RaffleTest.t.sol:RaffleTest
[FAIL. Reason: panic: array out-of-bounds access (0x32)] testPerformUpkeepUpdatesRaffleStateAndEmitsRequestId() (gas: 145684)
Logs:
  Creating subscribtion on ChainId 31337
  Your sub Id is:  1
  Please update subscribtionId in HelperConfig.s.sol
  Funding subscription:  1
  Using vrfCoordinator:  0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496
  On ChainID:  31337
  Adding Consumer Contract:  0x62c20Aa1e0272312BC100b4e23B4DC1Ed96dD7D1
  Using vrfCoordinator:  0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496
  On ChainID:  31337

Traces:
  [45375093] RaffleTest::setUp()
    ├─ [22702831] → new DeployRaffle@0xFEfC6BAF87cF3684058D62Da40Ff3A795946Ab06
    │   └─ ← 113175 bytes of code
    ├─ [22434148] DeployRaffle::run()
    │   ├─ [4950613] → new HelperConfig@0x6d2eed85750d316088343D6d5e91ca59eb052768
    │   │   ├─ [0] VM::startBroadcast()
    │   │   │   └─ ← ()
    │   │   ├─ [1398705] → new VRFCoordinatorV2Mock@0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496
    │   │   │   ├─ emit ConfigSet()
    │   │   │   └─ ← 6636 bytes of code
    │   │   ├─ [746241] → new LinkToken@0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3
    │   │   │   ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: DefaultSender: [0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38], amount: 1000000000000000000000000 [1e24])
    │   │   │   └─ ← 3267 bytes of code
    │   │   ├─ [0] VM::stopBroadcast()
    │   │   │   └─ ← ()
    │   │   └─ ← 12993 bytes of code
    │   ├─ [1046] HelperConfig::activeNetworkConfig() [staticcall]
    │   │   └─ ← 0, 0x474e34a077df58807dbe9c96d3c009b23b3c6d0cce433e59bbf5b34f823bc56c, 30, 10000000000000000 [1e16], 500000 [5e5], VRFCoordinatorV2Mock: [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496], LinkToken: [0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3]
    │   ├─ [5495932] → new CreateSubscription@0x8Bbbb5d294c78bd70dd88E6D63498dECa0C7BBCe
    │   │   └─ ← 27336 bytes of code
    │   ├─ [52993] CreateSubscription::createSubscription(VRFCoordinatorV2Mock: [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496])
    │   │   ├─ [0] console::9710a9d0(00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000007a6900000000000000000000000000000000000000000000000000000000000000204372656174696e6720737562736372696274696f6e206f6e20436861696e4964) [staticcall]
    │   │   │   └─ ← ()
    │   │   ├─ [0] VM::startBroadcast()
    │   │   │   └─ ← ()
    │   │   ├─ [46829] VRFCoordinatorV2Mock::createSubscription()
    │   │   │   ├─ emit SubscriptionCreated(subId: 1, owner: DefaultSender: [0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38])
    │   │   │   └─ ← 1
    │   │   ├─ [0] VM::stopBroadcast()
    │   │   │   └─ ← ()
    │   │   ├─ [0] console::9710a9d0(000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000010596f7572207375622049642069733a2000000000000000000000000000000000) [staticcall]
    │   │   │   └─ ← ()
    │   │   ├─ [0] console::log("Please update subscribtionId in HelperConfig.s.sol") [staticcall]
    │   │   │   └─ ← ()
    │   │   └─ ← 1
    │   ├─ [5595473] → new FundSubscription@0xffdcC297C11a15F778e155c20c0b7Ab1D26f5561
    │   │   └─ ← 27833 bytes of code
    │   ├─ [6970] FundSubscription::fundSubscription(VRFCoordinatorV2Mock: [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496], 1, LinkToken: [0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3])
    │   │   ├─ [0] console::9710a9d0(00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000001646756e64696e6720737562736372697074696f6e3a2000000000000000000000) [staticcall]
    │   │   │   └─ ← ()
    │   │   ├─ [0] console::log("Using vrfCoordinator: ", VRFCoordinatorV2Mock: [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496]) [staticcall]
    │   │   │   └─ ← ()
    │   │   ├─ [0] console::9710a9d0(00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000007a69000000000000000000000000000000000000000000000000000000000000000c4f6e20436861696e49443a200000000000000000000000000000000000000000) [staticcall]
    │   │   │   └─ ← ()
    │   │   ├─ [0] VM::startBroadcast()
    │   │   │   └─ ← ()
    │   │   ├─ [3178] VRFCoordinatorV2Mock::fundSubscription(1, 3000000000000000000 [3e18])
    │   │   │   ├─ emit SubscriptionFunded(subId: 1, oldBalance: 0, newBalance: 3000000000000000000 [3e18])
    │   │   │   └─ ← ()
    │   │   ├─ [0] VM::stopBroadcast()
    │   │   │   └─ ← ()
    │   │   └─ ← ()
    │   ├─ [0] VM::startBroadcast()
    │   │   └─ ← ()
    │   ├─ [566579] → new Raffle@0x62c20Aa1e0272312BC100b4e23B4DC1Ed96dD7D1
    │   │   └─ ← 2705 bytes of code
    │   ├─ [0] VM::stopBroadcast()
    │   │   └─ ← ()
    │   ├─ [5535188] → new AddConsumer@0x7C5f18184dbdb4fE367fC3B38AaA576C6B86f2Af
    │   │   └─ ← 27532 bytes of code
    │   ├─ [50957] AddConsumer::addConsumer(Raffle: [0x62c20Aa1e0272312BC100b4e23B4DC1Ed96dD7D1], VRFCoordinatorV2Mock: [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496], 1)
    │   │   ├─ [0] console::log("Adding Consumer Contract: ", Raffle: [0x62c20Aa1e0272312BC100b4e23B4DC1Ed96dD7D1]) [staticcall]
    │   │   │   └─ ← ()
    │   │   ├─ [0] console::log("Using vrfCoordinator: ", VRFCoordinatorV2Mock: [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496]) [staticcall]
    │   │   │   └─ ← ()
    │   │   ├─ [0] console::9710a9d0(00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000007a69000000000000000000000000000000000000000000000000000000000000000c4f6e20436861696e49443a200000000000000000000000000000000000000000) [staticcall]
    │   │   │   └─ ← ()
    │   │   ├─ [0] VM::startBroadcast()
    │   │   │   └─ ← ()
    │   │   ├─ [47240] VRFCoordinatorV2Mock::addConsumer(1, Raffle: [0x62c20Aa1e0272312BC100b4e23B4DC1Ed96dD7D1])
    │   │   │   ├─ emit ConsumerAdded(subId: 1, consumer: Raffle: [0x62c20Aa1e0272312BC100b4e23B4DC1Ed96dD7D1])
    │   │   │   └─ ← ()
    │   │   ├─ [0] VM::stopBroadcast()
    │   │   │   └─ ← ()
    │   │   └─ ← ()
    │   └─ ← 563808366315521888139814758131568062747410028497 [5.638e47]
    ├─ [1046] HelperConfig::activeNetworkConfig() [staticcall]
    │   └─ ← 0, 0x474e34a077df58807dbe9c96d3c009b23b3c6d0cce433e59bbf5b34f823bc56c, 30, 10000000000000000 [1e16], 500000 [5e5], VRFCoordinatorV2Mock: [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496], LinkToken: [0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3]
    ├─ [0] VM::deal(player: [0x44E97aF4418b7a17AABD8090bEA0A471a366305C], 10000000000000000000 [1e19])
    │   └─ ← ()
    └─ ← ()

  [145684] RaffleTest::testPerformUpkeepUpdatesRaffleStateAndEmitsRequestId()
    ├─ [0] VM::prank(player: [0x44E97aF4418b7a17AABD8090bEA0A471a366305C])
    │   └─ ← ()
    ├─ [47734] Raffle::enterRaffle{value: 10000000000000000}()
    │   ├─ emit EnteredRaffle(player: player: [0x44E97aF4418b7a17AABD8090bEA0A471a366305C])
    │   └─ ← ()
    ├─ [0] VM::warp(32)
    │   └─ ← ()
    ├─ [0] VM::roll(2)
    │   └─ ← ()
    ├─ [0] VM::recordLogs()
    │   └─ ← ()
    ├─ [72184] Raffle::performUpkeep(0x)
    │   ├─ [45844] VRFCoordinatorV2Mock::requestRandomWords(0x474e34a077df58807dbe9c96d3c009b23b3c6d0cce433e59bbf5b34f823bc56c, 1, 3, 500000 [5e5], 1)
    │   │   ├─ emit RandomWordsRequested(keyHash: 0x474e34a077df58807dbe9c96d3c009b23b3c6d0cce433e59bbf5b34f823bc56c, requestId: 1, preSeed: 100, subId: 1, minimumRequestConfirmations: 3, callbackGasLimit: 500000 [5e5], numWords: 1, sender: Raffle: [0x62c20Aa1e0272312BC100b4e23B4DC1Ed96dD7D1])
    │   │   └─ ← 1
    │   └─ ← ()
    ├─ [0] VM::getRecordedLogs()
    │   └─ ← [([0x63373d1c4696214b898952999c9aaec57dac1ee2723cec59bea6888f489a9772, 0x474e34a077df58807dbe9c96d3c009b23b3c6d0cce433e59bbf5b34f823bc56c, 0x0000000000000000000000000000000000000000000000000000000000000001, 0x00000000000000000000000062c20aa1e0272312bc100b4e23b4dc1ed96dd7d1], 0x000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000640000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000007a1200000000000000000000000000000000000000000000000000000000000000001, 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496)]
    └─ ← panic: array out-of-bounds access (0x32)

Test result: FAILED. 0 passed; 1 failed; 0 skipped; finished in 11.60ms
 
Ran 1 test suites: 0 tests passed, 1 failed, 0 skipped (1 total tests)

Failing tests:
Encountered 1 failing test in test/unit/RaffleTest.t.sol:RaffleTest
[FAIL. Reason: panic: array out-of-bounds access (0x32)] testPerformUpkeepUpdatesRaffleStateAndEmitsRequestId() (gas: 145684)

Encountered a total of 1 failing tests, 0 tests succeeded

Much help needed!

[Emperal]

Have you saved Raffle.sol before test?

├─ [72184] Raffle::performUpkeep(0x)
    │   ├─ [45844] VRFCoordinatorV2Mock::requestRandomWords(0x474e34a077df58807dbe9c96d3c009b23b3c6d0cce433e59bbf5b34f823bc56c, 1, 3, 500000 [5e5], 1)
    │   │   ├─ emit RandomWordsRequested(keyHash: 0x474e34a077df58807dbe9c96d3c009b23b3c6d0cce433e59bbf5b34f823bc56c, requestId: 1, preSeed: 100, subId: 1, minimumRequestConfirmations: 3, callbackGasLimit: 500000 [5e5], numWords: 1, sender: Raffle: [0x62c20Aa1e0272312BC100b4e23B4DC1Ed96dD7D1])
    │   │   └─ ← 1
    │   └─ ← ()

there is no "RequestRaffleWinner" emitted in the log above

[RaferGuo]

so how to fix it?

[AntoineF4C5]

Looks like this doesn't apply to your case, but I also ran into this issue and figured this might help others looking for solving:
My issue is that, in Raffle.sol, I had forgotten to put the "indexed" keyword in the event to be emitted.

What I had :

    event RequestedNewWinner(uint256 requestId);

What was required :

    event RequestedNewWinner(uint256 indexed requestId);

[EngrPips]

Indeed, this confused me for about a week. Lol.