Lesson 7: SmartContract Lottery__ Chainlink VRFv2DirectFundingConsumer

[codingJourneyFromUnemployment]

In lesson 7 , I am trying to use Chainlink VRF to generate random numbers in a Solidity contract deployed on the Sepolia testnet. I copied the code from the Chainlink documentation, specifically the VRFv2DirectFundingConsumer contract, and deployed it using Remix.

However, whenever I try to request a random number using the requestRandomWords() function, the transaction fails with a "out of gas" error.

Here's the code I used:

// SPDX-License-Identifier: MIT
// An example of a consumer contract that directly pays for each request.
pragma solidity ^0.8.7;

import "@chainlink/contracts/src/v0.8/ConfirmedOwner.sol";
import "@chainlink/contracts/src/v0.8/VRFV2WrapperConsumerBase.sol";

/**
 * Request testnet LINK and ETH here: https://faucets.chain.link/
 * Find information on LINK Token Contracts and get the latest ETH and LINK faucets here: https://docs.chain.link/docs/link-token-contracts/
 */

/**
 * THIS IS AN EXAMPLE CONTRACT THAT USES HARDCODED VALUES FOR CLARITY.
 * THIS IS AN EXAMPLE CONTRACT THAT USES UN-AUDITED CODE.
 * DO NOT USE THIS CODE IN PRODUCTION.
 */

contract VRFv2DirectFundingConsumer is
    VRFV2WrapperConsumerBase,
    ConfirmedOwner  
{   
    event RequestSent(uint256 requestId, uint32 numWords);
    event RequestFulfilled(
        uint256 requestId,
        uint256[] randomWords,
        uint256 payment
    );

    struct RequestStatus {
        uint256 paid; // amount paid in link
        bool fulfilled; // whether the request has been successfully fulfilled
        uint256[] randomWords;
    }
    mapping(uint256 => RequestStatus)
        public s_requests; /* requestId --> requestStatus */

    // past requests Id.
    uint256[] public requestIds;
    uint256 public lastRequestId;

    // Depends on the number of requested values that you want sent to the
    // fulfillRandomWords() function. Test and adjust
    // this limit based on the network that you select, the size of the request,
    // and the processing of the callback request in the fulfillRandomWords()
    // function.
    uint32 callbackGasLimit = 1000000;

    // The default is 3, but you can set this higher.
    uint16 requestConfirmations = 3;

    // For this example, retrieve 2 random values in one request.
    // Cannot exceed VRFV2Wrapper.getConfig().maxNumWords.
    uint32 numWords = 1;

    // Address LINK - hardcoded for sepolia
    address linkAddress = 0x779877A7B0D9E8603169DdbD7836e478b4624789;

    // address WRAPPER - hardcoded for sepolia
    address wrapperAddress = 0xab18414CD93297B0d12ac29E63Ca20f515b3DB46;

    constructor()
        ConfirmedOwner(msg.sender)
        VRFV2WrapperConsumerBase(linkAddress, wrapperAddress)
    {}

    function requestRandomWords()
        external
        onlyOwner
        returns (uint256 requestId)
    {
        requestId = requestRandomness(
            callbackGasLimit,
            requestConfirmations,
            numWords
        );
        s_requests[requestId] = RequestStatus({
            paid: VRF_V2_WRAPPER.calculateRequestPrice(callbackGasLimit),
            randomWords: new uint256[](0),
            fulfilled: false
        });
        requestIds.push(requestId);
        lastRequestId = requestId;
        emit RequestSent(requestId, numWords);
        return requestId;
    }

    function fulfillRandomWords(
        uint256 _requestId,
        uint256[] memory _randomWords
    ) internal override {
        require(s_requests[_requestId].paid > 0, "request not found");
        s_requests[_requestId].fulfilled = true;
        s_requests[_requestId].randomWords = _randomWords;
        emit RequestFulfilled(
            _requestId,
            _randomWords,
            s_requests[_requestId].paid
        );
    }

    function getRequestStatus(
        uint256 _requestId
    )
        external
        view
        returns (uint256 paid, bool fulfilled, uint256[] memory randomWords)
    {
        require(s_requests[_requestId].paid > 0, "request not found");
        RequestStatus memory request = s_requests[_requestId];
        return (request.paid, request.fulfilled, request.randomWords);
    }

    /**
     * Allow withdraw of Link tokens from the contract
     */
    function withdrawLink() public onlyOwner {
        LinkTokenInterface link = LinkTokenInterface(linkAddress);
        require(
            link.transfer(msg.sender, link.balanceOf(address(this))),
            "Unable to transfer"
        );
    }
}

At the beginning, I set the callbackGasLimit to 100000, but it was not successful, so I went to stackoverflow to ask questions, and someone told me to change it to 300000. But I tried 300000, 500000, 1000000, and even 3000000, but it was not successful. The hash of the transaction failure: 0x126f1828085fc2fa95cd0e65a3a4e79d8e3e7ae3e17ef1e859c43d4c6c512a74
I am not sure what could be causing the issue as I followed the documentation and used the code provided by Chainlink. I have 10 test link in my contract and 10 sepolia eth in my wallet. Before I request the random number, I also sent 25 test link to the contract. Could someone please help me identify the problem and suggest a solution?

Thank you in advance for your help!

[Nlferu]

Hello @Laidoffworkerlearnstocode

It is caused because of incorrect link or wrapper addresses or you are just do not fund correct contract with enough amount of ETH/LINK. You should checkout my solution for VRFV2 Lottery here: https://github.com/Neftyr/Lottery-On-VRFConsumerBaseV2-Python

[cromewar]

@Laidoffworkerlearnstocode Does this make sense to you?

[codingJourneyFromUnemployment]

Thx, I'm trying to reproduce the whole project using his code.

[Nlferu]

@Laidoffworkerlearnstocode

Let me know if you have any questions regarding my code I will try to help/clarify ;)