LEC 9 : Invalid type for argument in function call. Invalid implicit conversion

[ippy1997]

I'M GETTING THIS ERROR
Invalid type for argument in function call. Invalid implicit conversion from literal_string "" to bytes calldata requested

At this line
(bool upkeepNeeded, ) = checkUpkeep("");

RAFFLE.SOL

// 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/KeeperCompatibleInterface.sol";
error Raffle__NotEnoughETHEnterd();
error Raffle__TransferFailed();
error Raffle__NotOPen();
error Raffle__upkeepNotNeeded(uint256 currentBalance, uint256 numPlayers, uint256 raffestate);

/** @title A sample Raffle Contract
 * @author Anonymous
 * @notice this contract is for creaint an untamperable dectralized smart contract
 * @dev this implements ChainLink VRF v2 and ChainLink Keepers
 *
 */

contract Raffle is VRFConsumerBaseV2, KeeperCompatibleInterface {
    /* Type declaraions */

    enum RaffleState {
        OPEN,
        CALCULATING
    }

    /* State Variables */
    uint256 private immutable i_enternaceFee;
    address payable[] private s_players;
    VRFCoordinatorV2Interface private immutable i_vrfCoordinator;
    bytes32 private immutable i_gasLane;
    uint64 private immutable i_subscriptionId;
    uint16 private constant REQUEST_CONFIRMATIONS = 3;
    uint32 private immutable i_callbackGaslimit;
    uint32 private constant NUM_WORDS = 1;

    // Lottery variables
    address private s_recentWinner;
    RaffleState private s_raffleState;
    uint256 private s_lastTimeStamp;
    uint256 private immutable i_interval;
    /* Events */
    event RaffleEnter(address indexed player);
    event RequestedRaffleWinner(uint256 indexed requestId);
    event WinnerPicked(address indexed winner); // to keep track of the recentWinenr

    /* functions */
    constructor(
        address vrfCoordinatorV2,
        uint256 enternaceFee,
        bytes32 gasLane,
        uint64 subscriptionId,
        uint32 callbackGasLimit,
        uint256 interval
    ) VRFConsumerBaseV2(vrfCoordinatorV2) {
        i_enternaceFee = enternaceFee;
        i_vrfCoordinator = VRFCoordinatorV2Interface(vrfCoordinatorV2);
        i_gasLane = gasLane;
        i_subscriptionId = subscriptionId;
        i_callbackGaslimit = callbackGasLimit;
        s_raffleState = RaffleState.OPEN;
        s_lastTimeStamp = block.timestamp;
        i_interval = interval;
    }

    function enterRaffle() public payable {
        if (msg.value < i_enternaceFee) {
            revert Raffle__NotEnoughETHEnterd();
        }
        if (s_raffleState != RaffleState.OPEN) {
            revert Raffle__NotOPen();
        }
        s_players.push(payable(msg.sender));
        //emit an event
        emit RaffleEnter(msg.sender);
    }

    /**
     * @dev this is the function that the chainLink keeper node calls
     * 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. lottery should have atleast 1 player , and have some ETH
     * 3. Our subscription is funded with link
     * 4. lottery should be an "open" state
     */
    function checkUpkeep(
        bytes calldata /*checkData*/
    )
        public
        override
        returns (
            bool upkeepNeeded,
            bytes memory /* perfomrData*/
        )
    {
        bool isOpen = (RaffleState.OPEN == s_raffleState);
        bool timePassed = ((block.timestamp - s_lastTimeStamp) > i_interval);
        bool hasPlayers = (s_players.length > 0);
        bool hasBalance = address(this).balance > 0;
        upkeepNeeded = (isOpen && timePassed && hasPlayers && hasBalance);
    }

    function performUpkeep(
        bytes calldata /*perfomeData*/
    ) external override {
        (bool upkeepNeeded, ) = checkUpkeep("");
        if (!upkeepNeeded) {
            revert Raffle__upkeepNotNeeded(
                address(this).balance,
                s_players.length,
                uint256(s_raffleState)
            );
        }

        s_raffleState = RaffleState.CALCULATING;
        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 indexeOfWinner = randomWords[0] % s_players.length;
        address payable recentWinner = s_players[indexeOfWinner];
        s_recentWinner = recentWinner;
        s_raffleState = RaffleState.OPEN;
        s_players = new address payable[](0);
        s_lastTimeStamp = block.timestamp;
        (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_enternaceFee;
    }

    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 view returns (uint256) {
        return NUM_WORDS;
    }
}

[RoboCrypter]

@ippy1997 : Change parameter state in your checkUpkeep function from calldata to memory

function checkUpkeep(
        bytes memory /*checkData*/
    )
        public
        view
        override
        returns (
            bool upkeepNeeded,
            bytes memory /* performData*/
        )

Hopefully, It will fix the issue!

[ippy1997]

Thanks a lot this solved the issue