Lesson 9: Error: incorrect data length (argument="gasLane".............)

[TradMod]

I'm getting this error during deployment.
Mocks are getting deployed successfully.

ERROR:

$ hh deploy
Nothing to compile
Local network detected! Deploying mocks.....
deploying "VRFCoordinatorV2Mock" (tx: 0x11b9dfa83e5a81e783d8d818bd6499fa1504a937113eca5f07b8cfafe70751ea)...: deployed at 0x5FbDB2315678afecb367f032d93F642f64180aa3 with 1797707 gas
Mocks deployed...
------------------------------------------------------------------------------
An unexpected error occurred:

Error: ERROR processing /mnt/e/AB Dee/DEV/Bingo/bingo-hardhat/deploy/01-bingo-deploy.js:
Error: incorrect data length (argument="gasLane", value="0x5FbDB2315678afecb367f032d93F642f64180aa3", code=INVALID_ARGUMENT, version=abi/5.6.4)

My 01-deploy.js:

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

const FUND_AMOUNT = ethers.utils.parseEther("2");

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
        await vrfCoordinatorV2Mock.fundSubscription(subscriptionId, FUND_AMOUNT)
    } else {
        vrfCoordinatorV2address = networkConfig[chainId]["vrfCoordinatorV2"];
        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 bingo = await deploy("Bingo", {
        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(bingo.address, args)
    }
}

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

Contract:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.5;

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 Bingo__NotEnoughtETH();
error Bingo__WinnerTransactionFailed();
error Bingo__BingoStateIsNotOpen();
error Bingo__UpKeepNotNeeded(
    uint accountBalance,
    uint noOfPlayers,
    uint bingoState
);

/**@title A sample Bingo (Lottery) Contract
 * @author ABDul Rehman aka AB Dee aka Dev AB Dee :)
 * @dev This implements the Chainlink VRF Version 2 & Chainlink keepers
 */

contract Bingo is VRFConsumerBaseV2, KeeperCompatibleInterface {
    enum BingoState {
        OPEN,
        CALCULATING
    }

    uint private immutable i_entranceFee;
    address payable[] private players;
    VRFCoordinatorV2Interface private immutable i_vrfCoordinator;
    bytes32 private immutable i_gasLane;
    uint64 private immutable i_subscriptionId;
    uint32 private immutable i_callbackGasLimit;
    uint32 private constant NUM_WORDS = 1;
    uint16 private constant REQUEST_CONFIRMATIONS = 2;

    address private bingoWinner;
    BingoState private bingoState;
    uint256 private lastBlockTimeStamp;
    uint256 private immutable i_interval;

    event BingoEnter(address indexed player);
    event RequestBingoWinner(uint indexed requestId);
    event WinnerBingo(address indexed winner);

    constructor(
        bytes32 gasLane,
        address vrfCoordinatorV2,
        uint entranceFee,
        uint64 subscriptionId,
        uint32 callbackGasLimit,
        uint256 interval
    ) VRFConsumerBaseV2(vrfCoordinatorV2) {
        i_vrfCoordinator = VRFCoordinatorV2Interface(vrfCoordinatorV2);
        i_entranceFee = entranceFee;
        i_gasLane = gasLane;
        i_subscriptionId = subscriptionId;
        i_callbackGasLimit = callbackGasLimit;
        bingoState = BingoState.OPEN;
        lastBlockTimeStamp = block.timestamp;
        i_interval = interval;
    }

    function enterBingo() public payable {
        if (msg.value <= i_entranceFee) {
            revert Bingo__NotEnoughtETH();
        }
        if (bingoState != BingoState.OPEN) {
            revert Bingo__BingoStateIsNotOpen();
        }
        players.push(payable(msg.sender));
        emit BingoEnter(msg.sender);
    }

    function checkUpkeep(
        bytes memory /* checkData */
    )
        public
        view
        override
        returns (
            bool upkeepNeeded,
            bytes memory /* performData */
        )
    {
        bool isOpen = (BingoState.OPEN == bingoState);
        bool timePassed = ((block.timestamp - lastBlockTimeStamp) > i_interval);
        bool noOfPlayers = players.length > 0;
        bool bingoBalance = address(this).balance > 0;
        upkeepNeeded = (isOpen && timePassed && noOfPlayers && bingoBalance);
    }

    function performUpkeep(
        bytes calldata /* performData */
    ) external override {
        (bool upkeepNeeded, ) = checkUpkeep("");
        if (!upkeepNeeded) {
            revert Bingo__UpKeepNotNeeded(
                address(this).balance,
                players.length,
                uint(bingoState)
            );
        }

        bingoState = BingoState.CALCULATING;
        uint256 requestId = i_vrfCoordinator.requestRandomWords(
            i_gasLane, //0xd89b2bf150e3b9e13446986e571fb9cab24b13cea0a43ea20a6049a85cc807cc
            i_subscriptionId,
            REQUEST_CONFIRMATIONS,
            i_callbackGasLimit,
            NUM_WORDS
        );
        emit RequestBingoWinner(requestId);
    }

    function fulfillRandomWords(
        uint256, /*requestId*/
        uint256[] memory randomWords
    ) internal override {
        uint index = randomWords[0] % players.length;
        address payable winner = players[index];
        players = new address payable[](0);
        lastBlockTimeStamp = block.timestamp;
        bingoWinner = winner;
        bingoState = BingoState.OPEN;
        (bool success, ) = winner.call{value: address(this).balance}("");
        // require(success, "bingoWinner Failed");
        if (!success) {
            revert Bingo__WinnerTransactionFailed();
        }
        emit WinnerBingo(winner);
    }

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

    function getPlayers(uint index) public view returns (address) {
        return players[index];
    }

    function getBingoWinner() public view returns (address) {
        return bingoWinner;
    }

    function getBingoState() public view returns (BingoState) {
        return bingoState;
    }

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

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

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

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

    function getRequestConfirmations() public pure returns (uint256) {
        return REQUEST_CONFIRMATIONS;
    }
}

My helper-hardhat-config.js:

const { ethers } = require("ethers")

const networkConfig = {
    4: {
        name: "rinkeby",
        vrfCoordinatorV2: "0x6168499c0cFfCaCD319c818142124B7A15E857ab",
        entranceFee: ethers.utils.parseEther("0.005"),
        gasLane: "0xd89b2bf150e3b9e13446986e571fb9cab24b13cea0a43ea20a6049a85cc807cc",
        subscriptionId: "0",
        callbackGasLimit: "500000",
        interval: "55",
    },
    31337: {
        name: "hardhat",
        entranceFee: ethers.utils.parseEther("0.005"),
        gasLane: "0xd89b2bf150e3b9e13446986e571fb9cab24b13cea0a43ea20a6049a85cc807cc",
        callbackGasLimit: "500000",
        interval: "55",
    }
}

const developmentChains = ["hardhat", "localhost"]

module.exports = {
    networkConfig,
    developmentChains,
}

Pls help. Thanks

[krakxn]

Can you make a repo and link it here -- I will look into it. Thank you

[NagoriMustakim]

in your deploy script

 const args = [gasLane, vrfCoordinatorV2address, entranceFee, subscriptionId, callbackGasLimit, interval];

[TradMod]

Thanks, bro, It's deployed successfully now Alhumdulilah. I had args in m deploy.js but it was not in right order

[edgarhovhannisyan]

I also had this problem. The thing is you should look at the constructor of the VRF coordinator V2 and provide the input arguments in the exact order they appear in it.

[vamsikrishnapeketi]

hey guys now i am facing the same issue but when I checked the order of the constructor and the args array is the same so is there any other to solve this error .

[alymurtazamemon]

@vamsikrishnapeketi Please create a new discussion, mentioned your issue, also leave your repository link and tag me there.

[deaguss]

try sorting between the args and the constructor, checked console args without anyone undefined args value