checkUpkeep Overriding function return types differ.

[Ahmed14z]

i keep getting these errors , Overriding function return types differ. Contract "Raffle" should be marked as abstract.
here's my code , but i'm pretty sure i imported and also added it to the contract
Note : now the KeeperCompatibleInterface is named Automation , but i tried using KeeperCompatibleInterface and also adding it still same error.

//Raffle
//Enter the lottery
//pick a random winner
//winner to be selected every x minutes -> completely automated
//chainlink orable -> Randomness , Automated excution (Chain link keepers)

//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";

error Raffle__NotEnoughETHEntered();
error Raffle__TransferFailed();
error Raffle__NotOpen();

contract Raffle is VRFConsumerBaseV2, AutomationCompatibleInterface {
    /** Type decleration */
    enum RaffleState {
        OPEN,
        CALCULATING
    }

    /** State Variables */
    uint256 private immutable i_entranceFee;
    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;

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

    constructor(
        address vrfCoordinatorV2,
        uint256 entranceFee,
        bytes32 gasLane,
        uint64 subscriptionId,
        uint32 callBackGasLimit
    ) VRFConsumerBaseV2(vrfCoordinatorV2) {
        i_entranceFee = entranceFee;
        i_vrfCoordinator = VRFCoordinatorV2Interface(vrfCoordinatorV2);
        i_gasLane = gasLane;
        i_subscriptionId = subscriptionId;
        i_callBackGasLimit = callBackGasLimit;
        s_raffleState = RaffleState.OPEN;
    }

    function enterRaffle() public payable {
        //require msg.value > i_entranceFee
        if (msg.value < i_entranceFee) {
            revert Raffle__NotEnoughETHEntered();
        }
        if (s_raffleState != RaffleState.OPEN) {
            revert Raffle__NotOpen();
        }
        s_players.push(payable(msg.sender));
        // Emit an event when we update a dynamic array or mapping
        // Name events with the function name reversed
        emit raffleEnter(msg.sender);
    }

    /**
     *  @dev this is the function that the chainlink keeper nodes call they look for the `upkeepNeeded`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 is funded with link
     * 4. lottery should be in an open state
     * 5.
     */
    function checkUpkeep(
        bytes calldata /*checkData*/
    ) external override {}

    function requestRandomWinner() external {
        // external functions are a little bit cheaper than public
        //request the random number
        //once we get it  , do something with it
        //2 transactions

        s_raffleState = RaffleState.CALCULATING;
        uint256 requestId = i_vrfCoordinator.requestRandomWords(
            i_gasLane, //gas lane,
            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_raffleState = RaffleState.OPEN;
        (bool success, ) = recentWinner.call{value: address(this).balance}("");
        // require(success)
        if (!success) {
            revert Raffle__TransferFailed();
        }
        emit WinnerPicked(recentWinner);
    }

    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;
    }
}

[alymurtazamemon]

@Ahmed14z You need to override all of the required methods otherwise it will give the error to make your contract abstract. I am seeing here that you do not have the performUpkeep function here, Patrick's letter in the lesson change the name of requestRamdonWinner to performUpkeep. You should follow the tutorial and it will be resolved.

[Ahmed14z]

yes , i did so and it was fixed , i was worried because he didn't have any errors , but it works fine now thank you.

[solyakin]

I have the performUpKeep function in mine but I'm still having the same issue.

[alymurtazamemon]

@solyakin Make sure the spelling and function definition, as you wrote here performUpKeep its look like you wrote the same spelling for the function that is incorrect, the correct spelling is performUpkeep

[solyakin]

Yes thanks. It worked