Error while getting Random words from VRFC2PlusClient.

[PrashikshitSaini]

In the following function:

    function performUpkeep(bytes calldata /* performData */) external {
        // Check if enough time has passed.
        if ((block.timestamp - s_lastTimeStamp) <= i_interval) {
            revert();
        }

        (bool upkeepNeeded, ) = checkUpkeep(bytes(""));
        if (!upkeepNeeded) {
            revert Raffle__upkeepNotNeeded(
                address(this).balance,
                s_players.length,
                uint256(s_raffleState)
            );
        }
        s_raffleState = RaffleState.CALCULATING;
        // Get our random number
        // It is more like a 2 step process:
        // 1. Request a random number generator
        // 2. Get the random number from the generator.

        VRFV2PlusClient.RandomWordsRequest memory request = VRFV2PlusClient
            .RandomWordsRequest({
                keyHash: i_keyHash,
                subId: i_subscriptionId,
                requestConfirmations: REQUEST_CONFIRMATIONS,
                callbackGasLimit: i_callbackGasLimit,
                numWords: NUM_WORDS, // Number of Random numbers required
                extraArgs: VRFV2PlusClient._argsToBytes(
                    VRFV2PlusClient.ExtraArgsV1({nativePayment: false})
                )
            });

        // Request random words
        uint256 requestId = s_vrfCoordinator.requestRandomWords(request); // Why this doesnot work?
    }

when I am making the last request for the uint256 requestId, I am getting the following error:

Invalid type for argument in function call. Invalid implicit conversion from struct VRFV2PlusClient.RandomWordsRequest memory to struct VRFV2PlusClient.RandomWordsRequest memory requested.solidity(9553)

Can someone help me with this?

[EngrPips]

Hello @PrashikshitSaini, The below is what my own function that works look like

function performUpkeep(bytes calldata /* performData */) public {
        (bool upkeepNeeded,) = checkUpkeep("");
        if(!upkeepNeeded) revert Raffle__LotteryDoesNotNeedUpdate();
        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);
    }

[EngrPips]

Interesting, show your raffle contract. Don't forget to format the code nicely.

[PrashikshitSaini]

Here it is:

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

import {VRFConsumerBaseV2Plus} from "@chainlink/contracts/contracts/src/v0.8/vrf/dev/VRFConsumerBaseV2Plus.sol"; // this is used to generate randomness for the contract
import {VRFV2PlusClient} from "@chainlink/contracts/contracts/src/v0.8/dev/vrf/libraries/VRFV2PlusClient.sol";
import {console, console2} from "forge-std/Script.sol";

/**
 * @title Raffle Contract
 * @author Prashikshit Saini
 * @notice A contract for creating raffle
 * @dev Implements Chainlink VRFv2.5
 */

/**
 * Events
 */
contract Raffle is VRFConsumerBaseV2Plus {
    /**
     * Errors
     */
    error Raffle__insufficientEntranceFee();
    error Raffle__transferFailed();
    error Raffle__raffleNotOpen();
    error Raffle__upkeepNotNeeded(uint256 balance, uint256 playersLength, uint256 raffleState);

    event RaffleEntered(address indexed player); // an event for when the player enters the raffle
    event WinnerPicked(address indexed winner);
    event Raffle__randomNumberRequested(bytes32 requestId);

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

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

    uint256 private immutable i_entranceFee; // i_name is use as a syntax for writing the immutable variables
    // @dev The duration of the lottery in seconds.
    uint256 private immutable i_interval;
    bytes32 private immutable i_keyHash;
    uint256 private immutable i_subscriptionId;
    uint32 private immutable i_callbackGasLimit;
    address payable[] private s_players; // initializing the array of players
    uint256 private s_lastTimeStamp;
    address private s_recentWinner;
    RaffleState private s_raffleState;

    //** Constructor ***/
    //** What is happerning here is that as we have inherited the chainlink contract for randome functions, and we need to have the same constructors a
    //** one in the VRFConsumerBaseV2Plus. ***/

    constructor(
        uint256 entraneFee,
        uint256 interval,
        address vrfCoordinator,
        bytes32 gasLane,
        uint256 subsciptionId,
        uint32 callbackGasLimit
    ) VRFConsumerBaseV2Plus(vrfCoordinator) {
        i_entranceFee = entraneFee;
        i_interval = interval;
        i_keyHash = gasLane;
        i_subscriptionId = subsciptionId;
        i_callbackGasLimit = callbackGasLimit;

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

    function enterRaffle() external payable {
        // require( msg.value >= i_entranceFee, "Raffle: insufficient entrance fee");
        if (msg.value < i_entranceFee) {
            revert Raffle__insufficientEntranceFee();
        }

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

        s_players.push(payable(msg.sender));

        emit RaffleEntered(msg.sender); // emitting the event for when the player enters the raffle.
    }

    /**
     *
     * @dev This is the function that the Chainlink node will call to see
     * if the lottery is ready to have a winner picked.
     * The following should be true in order to upkeepNeeded to be true:
     * 1. The time interval has passed between raffle runs.
     * 2. The raffle is open.
     * 3. The contract has ETH.
     * 4. Implicitly, your subscription has LINK.
     *
     * @param  - ignored
     * @return upkeepNeeded - true if it's time restarting the lottery
     */

    /// @dev this method is called by the Automation Nodes to check if `performUpkeep` should be performed to get the randomness
    // / @param checkData - user-specified extra data to provide context to this upkeep
    function checkUpkeep(bytes memory /* checkData */ )
        public
        view
        returns (bool upkeepNeeded, bytes memory /* performData */ )
    {
        bool timeHasPassed = ((block.timestamp - s_lastTimeStamp) >= i_interval); // 1.
        bool isOpen = s_raffleState == RaffleState.OPEN; // 2.
        bool hasBalance = address(this).balance > 0; // 3.
        bool hasPlayers = s_players.length > 0; // 4. Or there are players

        upkeepNeeded = timeHasPassed && isOpen && hasBalance && hasPlayers;
        return (upkeepNeeded, bytes(""));
    }

    // The contract functionality flow is in the following order:
    // 1. Get a random number.
    // 2. Use the random number to get the winner.
    // 3. Run this automatically.

    /// @dev this method is called by the Automation Nodes.
    /// @dev performUpKeep() will only give us the randomness required by giving the randomeWords to be used in the later function.
    function performUpkeep(bytes calldata /* performData */ ) external {
        // Check if enough time has passed.
        if ((block.timestamp - s_lastTimeStamp) <= i_interval) {
            revert();
        }

        (bool upkeepNeeded,) = checkUpkeep(bytes(""));
        if (!upkeepNeeded) {
            revert Raffle__upkeepNotNeeded(address(this).balance, s_players.length, uint256(s_raffleState));
        }
        s_raffleState = RaffleState.CALCULATING;
        // Get our random number
        // It is more like a 2 step process:
        // 1. Request a random number generator
        // 2. Get the random number from the generator.

        VRFV2PlusClient.RandomWordsRequest memory request = VRFV2PlusClient.RandomWordsRequest({
            keyHash: i_keyHash,
            subId: i_subscriptionId,
            requestConfirmations: REQUEST_CONFIRMATIONS,
            callbackGasLimit: i_callbackGasLimit,
            numWords: NUM_WORDS, // Number of Random numbers required
            extraArgs: VRFV2PlusClient._argsToBytes(VRFV2PlusClient.ExtraArgsV1({nativePayment: false}))
        });

        // Request random words
        uint256 requestId = s_vrfCoordinator.requestRandomWords(request); // Why this doesnot work?
    }

    /**
     * @dev fulfullRandomWords - This is the real function that chooses the randome player based on the randome words given by the perform upkeep.
     *
     */
    function fulfillRandomWords(uint256, uint256[] calldata randomWords) internal override {
        // Checks - more like  conditionals and requires

        // Effect (internal contract state)
        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); // Instead of removing the player one by one, we just reset the array to 0.
        s_lastTimeStamp = block.timestamp;
        emit WinnerPicked(s_recentWinner);

        // Inteactions - External Contract state
        (bool success,) = recentWinner.call{value: address(this).balance}("");
        if (!success) {
            revert Raffle__transferFailed();
        }
    }

    /**
     * Getter Function - for retrieving the private variables
     */
    function getEntranceFee() public view returns (uint256) {
        return i_entranceFee;
    }

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

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

[EngrPips]

Here it is:

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

import {VRFConsumerBaseV2Plus} from "@chainlink/contracts/contracts/src/v0.8/vrf/dev/VRFConsumerBaseV2Plus.sol"; // this is used to generate randomness for the contract
import {VRFV2PlusClient} from "@chainlink/contracts/contracts/src/v0.8/dev/vrf/libraries/VRFV2PlusClient.sol";
import {console, console2} from "forge-std/Script.sol";

/**
 * @title Raffle Contract
 * @author Prashikshit Saini
 * @notice A contract for creating raffle
 * @dev Implements Chainlink VRFv2.5
 */

/**
 * Events
 */
contract Raffle is VRFConsumerBaseV2Plus {
    /**
     * Errors
     */
    error Raffle__insufficientEntranceFee();
    error Raffle__transferFailed();
    error Raffle__raffleNotOpen();
    error Raffle__upkeepNotNeeded(uint256 balance, uint256 playersLength, uint256 raffleState);

    event RaffleEntered(address indexed player); // an event for when the player enters the raffle
    event WinnerPicked(address indexed winner);
    event Raffle__randomNumberRequested(bytes32 requestId);

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

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

    uint256 private immutable i_entranceFee; // i_name is use as a syntax for writing the immutable variables
    // @dev The duration of the lottery in seconds.
    uint256 private immutable i_interval;
    bytes32 private immutable i_keyHash;
    uint256 private immutable i_subscriptionId;
    uint32 private immutable i_callbackGasLimit;
    address payable[] private s_players; // initializing the array of players
    uint256 private s_lastTimeStamp;
    address private s_recentWinner;
    RaffleState private s_raffleState;

    //** Constructor ***/
    //** What is happerning here is that as we have inherited the chainlink contract for randome functions, and we need to have the same constructors a
    //** one in the VRFConsumerBaseV2Plus. ***/

    constructor(
        uint256 entraneFee,
        uint256 interval,
        address vrfCoordinator,
        bytes32 gasLane,
        uint256 subsciptionId,
        uint32 callbackGasLimit
    ) VRFConsumerBaseV2Plus(vrfCoordinator) {
        i_entranceFee = entraneFee;
        i_interval = interval;
        i_keyHash = gasLane;
        i_subscriptionId = subsciptionId;
        i_callbackGasLimit = callbackGasLimit;

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

    function enterRaffle() external payable {
        // require( msg.value >= i_entranceFee, "Raffle: insufficient entrance fee");
        if (msg.value < i_entranceFee) {
            revert Raffle__insufficientEntranceFee();
        }

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

        s_players.push(payable(msg.sender));

        emit RaffleEntered(msg.sender); // emitting the event for when the player enters the raffle.
    }

    /**
     *
     * @dev This is the function that the Chainlink node will call to see
     * if the lottery is ready to have a winner picked.
     * The following should be true in order to upkeepNeeded to be true:
     * 1. The time interval has passed between raffle runs.
     * 2. The raffle is open.
     * 3. The contract has ETH.
     * 4. Implicitly, your subscription has LINK.
     *
     * @param  - ignored
     * @return upkeepNeeded - true if it's time restarting the lottery
     */

    /// @dev this method is called by the Automation Nodes to check if `performUpkeep` should be performed to get the randomness
    // / @param checkData - user-specified extra data to provide context to this upkeep
    function checkUpkeep(bytes memory /* checkData */ )
        public
        view
        returns (bool upkeepNeeded, bytes memory /* performData */ )
    {
        bool timeHasPassed = ((block.timestamp - s_lastTimeStamp) >= i_interval); // 1.
        bool isOpen = s_raffleState == RaffleState.OPEN; // 2.
        bool hasBalance = address(this).balance > 0; // 3.
        bool hasPlayers = s_players.length > 0; // 4. Or there are players

        upkeepNeeded = timeHasPassed && isOpen && hasBalance && hasPlayers;
        return (upkeepNeeded, bytes(""));
    }

    // The contract functionality flow is in the following order:
    // 1. Get a random number.
    // 2. Use the random number to get the winner.
    // 3. Run this automatically.

    /// @dev this method is called by the Automation Nodes.
    /// @dev performUpKeep() will only give us the randomness required by giving the randomeWords to be used in the later function.
    function performUpkeep(bytes calldata /* performData */ ) external {
        // Check if enough time has passed.
        if ((block.timestamp - s_lastTimeStamp) <= i_interval) {
            revert();
        }

        (bool upkeepNeeded,) = checkUpkeep(bytes(""));
        if (!upkeepNeeded) {
            revert Raffle__upkeepNotNeeded(address(this).balance, s_players.length, uint256(s_raffleState));
        }
        s_raffleState = RaffleState.CALCULATING;
        // Get our random number
        // It is more like a 2 step process:
        // 1. Request a random number generator
        // 2. Get the random number from the generator.

        VRFV2PlusClient.RandomWordsRequest memory request = VRFV2PlusClient.RandomWordsRequest({
            keyHash: i_keyHash,
            subId: i_subscriptionId,
            requestConfirmations: REQUEST_CONFIRMATIONS,
            callbackGasLimit: i_callbackGasLimit,
            numWords: NUM_WORDS, // Number of Random numbers required
            extraArgs: VRFV2PlusClient._argsToBytes(VRFV2PlusClient.ExtraArgsV1({nativePayment: false}))
        });

        // Request random words
        uint256 requestId = s_vrfCoordinator.requestRandomWords(request); // Why this doesnot work?
    }

    /**
     * @dev fulfullRandomWords - This is the real function that chooses the randome player based on the randome words given by the perform upkeep.
     *
     */
    function fulfillRandomWords(uint256, uint256[] calldata randomWords) internal override {
        // Checks - more like  conditionals and requires

        // Effect (internal contract state)
        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); // Instead of removing the player one by one, we just reset the array to 0.
        s_lastTimeStamp = block.timestamp;
        emit WinnerPicked(s_recentWinner);

        // Inteactions - External Contract state
        (bool success,) = recentWinner.call{value: address(this).balance}("");
        if (!success) {
            revert Raffle__transferFailed();
        }
    }

    /**
     * Getter Function - for retrieving the private variables
     */
    function getEntranceFee() public view returns (uint256) {
        return i_entranceFee;
    }

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

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

This is the current state of your contract, right?

[PrashikshitSaini]

Right.

[EngrPips]

Yes.

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

Remove this import. This error occurs because the IVRFCoordinatorV2Plus imported VRFV2PlusClient, and your Raffle also imported it, but both imported it from different locations. This is not a serious issue at all.

[EngrPips]

Please replace the below code in your current contract

VRFV2PlusClient.RandomWordsRequest memory request = VRFV2PlusClient.RandomWordsRequest({
            keyHash: i_keyHash,
            subId: i_subscriptionId,
            requestConfirmations: REQUEST_CONFIRMATIONS,
            callbackGasLimit: i_callbackGasLimit,
            numWords: NUM_WORDS, // Number of Random numbers required
            extraArgs: VRFV2PlusClient._argsToBytes(VRFV2PlusClient.ExtraArgsV1({nativePayment: false}))
        });

        // Request random words
        uint256 requestId = s_vrfCoordinator.requestRandomWords(request); // Why this doesnot work?

With this

uint256 requestId = s_vrfCoordinator.requestRandomWords(VRFV2PlusClient.RandomWordsRequest({
            keyHash: i_keyHash,
            subId: i_subscriptionId,
             requestConfirmations: REQUEST_CONFIRMATIONS,
            callbackGasLimit: i_callbackGasLimit,
           numWords: NUM_WORDS, // Number of Random numbers required
           extraArgs: VRFV2PlusClient._argsToBytes(VRFV2PlusClient.ExtraArgsV1({nativePayment: false}))
        }));

Let's see it resolve the error. I am looking forward to hear from you.

[PrashikshitSaini]

Still the same error.

Trust me man, I've tried close to everything, and this is my last resort.

[PrashikshitSaini]

I think it's more like an version issue, because even if I copy paste the complete code from the repo. The error still "LIVES".

[EngrPips]

Remove this import import {VRFV2PlusClient} from "@chainlink/contracts/contracts/src/v0.8/dev/vrf/libraries/VRFV2PlusClient.sol"; in your Raffle file and then use the block of code that i sent earlier.
This

uint256 requestId = s_vrfCoordinator.requestRandomWords(VRFV2PlusClient.RandomWordsRequest({
            keyHash: i_keyHash,
            subId: i_subscriptionId,
             requestConfirmations: REQUEST_CONFIRMATIONS,
            callbackGasLimit: i_callbackGasLimit,
           numWords: NUM_WORDS, // Number of Random numbers required
           extraArgs: VRFV2PlusClient._argsToBytes(VRFV2PlusClient.ExtraArgsV1({nativePayment: false}))
        }));

If your issue persists, then push your code to GitHub and share the link. I will resolve it locally, have it compile, and show you what the files look like.

[PrashikshitSaini]

Thank You mate @EngrPips ,
BUT
Just removing the import won't work because the contract is not aware of the VRFV2PlusClient.sol.
So to remove the redundancy, I imported IVRFCoordinatorV2Plus.sol:

import "lib/chainlink-brownie-contracts/contracts/src/v0.8/vrf/dev/interfaces/IVRFCoordinatorV2Plus.sol";

Again, thanks for fixing it with me.

[EngrPips]

You are welcoming, Keep crushing it.

[PedroSolorzano]

Hey guys! I found an even easier fix. Change:

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

To:

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

The change itself is that the first one is in dev/vrf, and the second one in vrf/dev, which is the same place where VRFConsumerBaseV2Plus comes from:

import {VRFConsumerBaseV2Plus} from "@chainlink/contracts/src/v0.8/vrf/dev/VRFConsumerBaseV2Plus.sol";

I tried @PrashikshitSaini solution in the past and it created a few other problems, this one should be problem free :)

[EngrPips]

Awesome, Thanks for the heads-up @PedroSolorzano.

[notwearingpants1]

Thanks @PedroSolorzano I've been fighting for my life. Tried that and it worked

[Lamma-maihadisi]

@PrashikshitSaini thank you sir. it has work for me

[EngrPips]

Awesome.