Lesson 9 => Error: invalid arrayify value (argument="value", value="", code=INVALID_ARGUMENT, version=bytes/5.7.0)

[Mericbey167]

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

const VRF_SUB_FUND_AMOUNT = ethers.utils.parseEther("2")

module.exports = async ({ getNamedAccounts, deployments, getChainId }) => {
    /* Destuructured Variables */
    const { deployer } = await getNamedAccounts()
    const { deploy, log } = deployments
    /* Global Variables */
    const chainId = await getChainId()
    let vrfCoordinatorV2Address, subscriptionId
    const easyAccess = networkConfig[chainId]

    if (developmentChains.includes(network.name)) {
        /* Development Chains => Hardhat & Localhost */

        const vrfCoordinatorV2Mock = await ethers.getContract("VRFCoordinatorV2Mock")
        vrfCoordinatorV2Address = vrfCoordinatorV2Mock.address

        // We gonna create subscription and fund it programatically.
        const transactionResponse = await vrfCoordinatorV2Mock.createSubscription()
        const transactionReceipt = await transactionResponse.wait(1)
        subscriptionId = transactionReceipt.events[0].args.subId
        // Now we need to fund it
        await vrfCoordinatorV2Mock.fundSubscription(subscriptionId, VRF_SUB_FUND_AMOUNT)
    } else {
        /* Testnet Chains => Sepolia Network */

        vrfCoordinatorV2Address = easyAccess["vrfCoordinatorV2"]
        subscriptionId = easyAccess["subscriptionId"]
    }
    const entranceFee = easyAccess["entranceFee"]
    const gasLane = easyAccess["gasLane"]
    const callbackGasLimit = easyAccess["callbackGasLimit"]
    const interval = easyAccess["interval"]

    /* Raffle.sol constructor arguments */
    const args = [
        vrfCoordinatorV2Address,
        entranceFee,
        gasLane,
        subscriptionId,
        callbackGasLimit,
        interval,
    ]

    /* Raffle.sol Deployment */
    const raffle = await deploy("Raffle", {
        from: deployer,
        args: args,
        log: true,
        waitConfirmations: network.config.blockConfirmations || 1,
    })
    if (!developmentChains.includes(network.name) && process.env.ETHERSCAN_API_KEY) {
        await verify(raffle.address, args)
    }

    log("Process related with Raffle contract is done!")
    log("--------------------------------------------------------------------------------")
}

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

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

import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";
import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
import "@chainlink/contracts/src/v0.8/interfaces/AutomationCompatibleInterface.sol";

/* Errors */
error Raffle__notEnoughEthEntered();
error Raffle__TransferFailed();
error Raffle__NotOpen();
error Raffle__UpkeepNeededNotTrue(uint256 currentBalance, uint256 numPlayers, uint256 raffleState);

/**
 * @title A sample Raffle Contract
 * @author Meric_bey
 * @notice This contract is for creating untamperable decentralized smart contract
 * @dev This implements Chainlink VRF and Chainlink Automation
 */
contract Raffle is VRFConsumerBaseV2, AutomationCompatibleInterface {
    /* Type Declarations */
    enum RaffleState {
        OPEN,
        CALCULATING
    } // uint256 0 = OPEN, 1 = CALCULATING

    /* State Variables */
    // Chainlink VRF Variables

    VRFCoordinatorV2Interface private immutable i_vrfCoordinator;
    bytes32 private immutable i_gasLane;
    uint64 private immutable i_subscriptionId;
    uint32 private immutable i_callbackGasLimit;
    uint16 private constant REQUEST_CONFIRMATIONS = 3;
    uint32 private constant NUM_WORDS = 1;

    /* Lottery Variables */
    uint256 private immutable i_entranceFee;
    address payable[] private s_players;
    address payable s_recentWinner;
    RaffleState private s_raffleState;
    uint256 private immutable i_interval;
    uint256 private s_lastTimeStamp;

    /* Events */
    event RaffleEnter(address indexed player);
    event RequestedRaffleWinner(uint256 indexed requestId);
    event WinnerPicked(address indexed winner);

    /* Functions */
    constructor(
        address vrfCoordinatorV2,
        uint256 entranceFee,
        bytes32 gasLane,
        uint64 subscriptionId,
        uint32 callbackGasLimit,
        uint256 interval
    ) public VRFConsumerBaseV2(vrfCoordinatorV2) {
        i_entranceFee = entranceFee;
        i_vrfCoordinator = VRFCoordinatorV2Interface(vrfCoordinatorV2);
        i_gasLane = gasLane;
        i_subscriptionId = subscriptionId;
        i_callbackGasLimit = callbackGasLimit;
        s_raffleState = RaffleState.OPEN;
        i_interval = interval;
        s_lastTimeStamp = block.timestamp;
    }

    function enterRaffle() public payable {
        // require(msg.value > i_entranceFee, "Not enough ETH")
        if (msg.value < i_entranceFee) {
            revert Raffle__notEnoughEthEntered();
        }
        if (s_raffleState != RaffleState.OPEN) {
            revert Raffle__NotOpen();
        }
        s_players.push(payable(msg.sender));
        emit RaffleEnter(msg.sender);
    }

    /**
     * @dev This is the function that Chainlink Automation nodes call.
     * They look for the 'upKeepNeeded' to return true.
     * The following should be true in order to return true:
     * 1. Our time interval should have passed.
     * 2. The lottery should have at least 1 player and have some ETH.
     * 3. Our subscription should have funded with LINK.
     * 4. The lottery should be on "OPEN" state.
     */
    function checkUpkeep(
        bytes memory /* checkData */
    ) public view override returns (bool upKeepNeeded, bytes memory /* performData */) {
        bool isOpen = (RaffleState.OPEN == s_raffleState);
        bool timePassed = ((block.timestamp - s_lastTimeStamp) > i_interval);
        bool hasBalance = address(this).balance > 0;
        bool hasPlayers = (s_players.length > 0);
        upKeepNeeded = (isOpen && timePassed && hasBalance && hasPlayers);
    }

    function performUpkeep(bytes calldata /* performData */) external override {
        (bool upKeepNeeded, ) = checkUpkeep("");
        if (!upKeepNeeded) {
            revert Raffle__UpkeepNeededNotTrue(
                address(this).balance,
                s_players.length,
                uint256(s_raffleState)
            );
        }
        s_raffleState = RaffleState.CALCULATING; // Random word request edilirken calculating olsun ki insanlar katılamasın.
        uint256 requestId = i_vrfCoordinator.requestRandomWords(
            i_gasLane,
            i_subscriptionId,
            REQUEST_CONFIRMATIONS,
            i_callbackGasLimit,
            NUM_WORDS
        );
        emit RequestedRaffleWinner(requestId);
    }

    function fulfillRandomWords(
        uint256 /* requestId */,
        uint256[] memory randomWords
    ) internal override {
        uint256 indexOfWinner = randomWords[0] % s_players.length;
        address payable recentWinner = s_players[indexOfWinner];
        s_recentWinner = recentWinner;
        s_players = new address payable[](0);
        s_raffleState = RaffleState.OPEN;
        s_lastTimeStamp = block.timestamp; // We reset the timestamp so interval can start again.
        (bool success, ) = recentWinner.call{value: address(this).balance}("");
        if (!success) {
            revert Raffle__TransferFailed();
        }
        emit WinnerPicked(recentWinner);
    }

    /* View / Pure Functions */
    function getEntranceFee() public view returns (uint256) {
        return i_entranceFee;
    }

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

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

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

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

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

    function getLatestTimestamp() public view returns (uint256) {
        return s_lastTimeStamp;
    }

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

My deploy script and Raffle contract is located on above. I'm getting an error that says "invalid arrayify value...". I've made a research and people have already said that it's about bytes parameters. "We're passing empty string on checkUpkeep function but we need to pass empty byte data" they say but i don't understand how to do this convertion on my code. For those who know the solution i'll be really appreciated if you share with us :)

[Mericbey167]

Also here is my helper-hardhat-config.js . Since we have gasLane which is a type of bytes. So maybe i made a mistake here.

const { ethers } = require("hardhat")

const networkConfig = {
    11155111: {
        name: "sepolia",
        vrfCoordinatorV2: "0x8103B0A8A00be2DDC778e6e7eaa21791Cd364625",
        entranceFee: ethers.utils.parseEther("0.01"),
        gasLane: "0x474e34a077df58807dbe9c96d3c009b23b3c6d0cce433e59bbf5b34f823bc56c", // 66 characters. 64 + 0x
        subscriptionId: "3348",
        callbackGasLimit: "500000",
        interval: "30",
    },
    31337: {
        name: "hardhat",
        entranceFee: ethers.utils.parseEther("0.01"),
        gasLane: "", // We're mocking this already. So doesn't matter.
        callbackGasLimit: "500000",
        interval: "30",
    },
}

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

module.exports = {
    networkConfig,
    developmentChains,
}
 

[Mericbey167]

I've noticed while i was sharing my helper-hardhat-config.js file in here that i didn't specify the gasLane for hardhat network. In video, Patrick says "We'll mock this gasLane anyway so you can put anything here it doesn't matter". So i just put empty strings and moved on but this error occured. So i used same keyHash address that i used for Sepolia network.
Additionally, like Patrick said you can put anything here. It doesn't have to be same address with Sepolia Network. Or it doesn't have to be even a valid address. But you need one thing that is bytes format. You need to put0x and 64 more characters here. That's how bytes format works. Since it's a variable type of a bytes we'll make sure we put correct format.
Finally, same address with Sepolia Network works but also this one works for me as well:

gasLane: "0x0000000000000000000000000000000000000000000000000000000000000000", // 0x + 64 zeros.

It's been like me talking with myself but for those who might have same issue i wanted to explain the solution. :)

[jujuvideogirlai]

Hi Mericbey167,

Same error here, thanks for your explanation! 😃