Lesson 9:Invalid type for argument in function call. Invalid implicit conversion from literal_string "" to bytes calldata requested

[QingRun-Tan]

// SPDX-License-Identifier: MIT

/**
 * 希望参与人进入彩票系统，付钱
 * 随机选出一个优胜者（可以验证的随机的，不可篡改的）
 * 每隔y/m/d选出一个-->完全自动化的
 * 使用chainlink oracle来获得随机性，使用chainlink keeper自动执行
 */
pragma solidity ^0.8.0;

import "@chainlink/contracts/src/v0.8/vrf/VRFConsumerBaseV2.sol"; //引入chainlink vrf产生随机数
import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
import "@chainlink/contracts/src/v0.8/automation/AutomationCompatible.sol";
//自定义一个异常
error Lottey_NotEnoughETHEntered();
error Lottry_TransferFailed();
error Lottey_NotOpen();
error Lottey_UpkeepNotNeeded(
    uint256 currentBalance,
    uint256 numberPlayers,
    uint256 lotteyState
);

/**
 * @title 一个抽奖系统
 * @author tqr
 * @notice 本合约旨在创建一个不可篡改的去中心化智能合约
 * @dev  实现了chaink vrf + chainlink autimation
 */
contract Lottey is VRFConsumerBaseV2, AutomationCompatibleInterface {
    /**
     * @dev 状态类型声明
     */
    enum LotteyState {
        OPEN,
        CALCULATING
    } //uint256 0 = OPEN,1=CALCULATING

    /**
     * @dev 状态变量声明
     */
    uint256 private immutable i_entranceFee; //这是一个immutable变量 节省gasfee  入场fee
    address payable[] private s_players;
    VRFCoordinatorV2Interface private immutable i_vrfCoordinator;
    bytes32 private immutable i_keyHash;
    uint32 private immutable i_subscriptionId;
    uint16 private constant REQUEST_CONFIRMATIONS = 3;
    uint32 private immutable i_callbackGasLimit;
    uint32 private constant NUMS_WORDS = 1;

    /**
     * 事件声明
     */
    event RallfEnter(address indexed player); //定义一个事件 indexed类型便于搜索
    event RequestedRaffleWinner(uint256 indexed requestId);
    event WinnerPicked(address indexed winner);
    /**
     * 抽奖变量声明
     */
    address private s_recentWinner;
    LotteyState private s_lotteyState;
    uint256 private s_lastTimeStamp;
    uint256 private immutable i_interval;

    constructor(
        address vrfCoordinatorV2,
        uint256 entranceFee,
        bytes32 keyHash,
        uint32 subscriptionId,
        uint32 callbackGasLimit,
        uint256 interval //2次抽奖的时间间隔
    ) VRFConsumerBaseV2(vrfCoordinatorV2) {
        i_entranceFee = entranceFee;
        i_vrfCoordinator = VRFCoordinatorV2Interface(vrfCoordinatorV2);
        i_keyHash = keyHash;
        i_subscriptionId = subscriptionId;
        i_callbackGasLimit = callbackGasLimit;
        s_lotteyState = LotteyState.OPEN;
        s_lastTimeStamp = block.timestamp;
        i_interval = interval;
    }

    //入场
    function enterRallf() public payable {
        //如果进入的人钱不够 就抛异常
        if (msg.value < i_entranceFee) {
            revert Lottey_NotEnoughETHEntered();
        }
        if (s_lotteyState != LotteyState.OPEN) {
            revert Lottey_NotOpen();
        }
        //将进入的人保存到s_players数组中
        s_players.push(payable(msg.sender));

        emit RallfEnter(msg.sender); //触发时间
    }

    function checkUpkeep(
        bytes calldata /**checkData*/
    )
        public
        override
        returns (bool upkeepNeeded, bytes memory /**performData*/)
    {
        bool isOpen = (LotteyState.OPEN == s_lotteyState);
        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);
    }

    //选出随机优胜者
    /**
     * external :
     */
    function performUpkeep(bytes calldata /* performData */) external override {
        /**
         * 请求随机数
         */
        (bool upkeepNeeded, ) = checkUpkeep("");
        if (!upkeepNeeded) {
            revert Lottey_UpkeepNotNeeded(
                address(this).balance,
                s_players.length,
                uint256(s_lotteyState)
            );
        }

        s_lotteyState = LotteyState.CALCULATING;
        uint256 requestId = i_vrfCoordinator.requestRandomWords(
            i_keyHash,
            i_subscriptionId,
            REQUEST_CONFIRMATIONS,
            i_callbackGasLimit,
            NUMS_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_lotteyState = LotteyState.OPEN;
        //重置数组
        s_players = new address payable[](0);
        //重置时间
        s_lastTimeStamp = block.timestamp;
        (bool success, ) = recentWinner.call{value: address(this).balance}("");
        if (!success) {
            revert Lottry_TransferFailed();
        }
        emit WinnerPicked(recentWinner);
    }

    //使其他用户可以看见这个entranceFee 其他用户可以调用这个函数 无需gasfee
    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;
    }
}

Please tell me how I can modify it。thanks very much

[Ebenezary]

change from this :

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

to this :

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

[WeDev00]

By doing so we are changing the signature of the method, does this not cause problems for the override? and why?