Lesson 9 - Function has override specified but does not override anything

[SpeedBird789]

Hi there,

I've followed along with Patrick and his code till 14:52:17 and upon compilation, I'm getting a couple of errors:

1. Contract "Raffle" should be marked as abstract

contract Raffle is VRFConsumerBaseV2, KeeperCompatibleInterface {
    /* Type declarations */
    enum RaffleState {
        OPEN,
        CALCULATING
    }

2. Function has override specified but does not override anything

function checkUpKeep(
        bytes memory /*checkData*/
    )
        public
        override
        returns (
            bool upKeepNeeded,
            bytes memory /* performData */
        )
    {
        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 /* performData */
    ) 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);
    }

Am I missing anything here?

[SpeedBird789]

Here's my Raffle.sol contract:

// Raffle

// Enter the lottery (paying some amount)
// Pick a random winner (verifiably random)
// Winner to be selected every X minutes -> completely automated
// Chainlink Oracle -> Randomness, Automated Execution (Chainlink Keeper)

// SPDX-License-Identifier: MIT

// SPDX-License-Identifier: SEE LICENSE IN LICENSE
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__NotEnoughETHEntered();
error Raffle__TransferFailed();
error Raffle__NotOpen();
error Raffle__UpkeepNotNeeded(uint256 currentBalance, uint256 numPlayers, uint256 raffleState);

/**@title A sample Raffle Contract
 * @author SpeedBird789
 * @notice This contract is for creating a sample raffle contract
 * @dev This implements the Chainlink VRF Version 2
 */

contract Raffle is VRFConsumerBaseV2, KeeperCompatibleInterface {
    /* Type declarations */
    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;
    uint32 private immutable i_callbackGasLimit;
    uint16 private constant REQUEST_CONFIRMATIONS = 3;
    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);

    constructor(
        address vrfCoordinatorV2,
        uint256 entranceFee,
        bytes32 gasLane,
        uint64 subscriptionId,
        uint32 callbackGasLimit,
        uint256 interval
    ) VRFConsumerBaseV2(vrfCoordinatorV2) {
        i_entranceFee = entranceFee;
        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_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 of mapping. Named events with the functions name reversed */
        emit RaffleEnter(msg.sender);
    }

    /**
     * @dev This is the function that the Chainlink Keeper nodes call
     * they look for `upkeepNeeded` to return True.
     * the following should be true for this to return true:
     * 1. The time interval has passed between raffle runs.
     * 2. The lottery is open.
     * 3. The contract has ETH.
     * 4. Implicity, your subscription is funded with LINK.
     */

    function checkUpKeep(
        bytes memory /*checkData*/
    )
        public
        override
        returns (
            bool upKeepNeeded,
            bytes memory /* performData */
        )
    {
        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 /* performData */
    ) 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 indexOfWinner = randomWords[0] % s_players.length;
        address payable recentWinner = s_players[indexOfWinner];
        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_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;
    }
}

[othaime-en]

Hey @SpeedBird789 rename the "Keep" in checkUpKeep and performUpKeep to "keep" (with a small k).

[othaime-en]

The final code should look like this.

// Raffle

// Enter the lottery (paying some amount)
// Pick a random winner (verifiably random)
// Winner to be selected every X minutes -> completely automated
// Chainlink Oracle -> Randomness, Automated Execution (Chainlink Keeper)

// SPDX-License-Identifier: MIT

// SPDX-License-Identifier: SEE LICENSE IN LICENSE
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__NotEnoughETHEntered();
error Raffle__TransferFailed();
error Raffle__NotOpen();
error Raffle__UpkeepNotNeeded(uint256 currentBalance, uint256 numPlayers, uint256 raffleState);

/**@title A sample Raffle Contract
 * @author SpeedBird789
 * @notice This contract is for creating a sample raffle contract
 * @dev This implements the Chainlink VRF Version 2
 */

contract Raffle is VRFConsumerBaseV2, KeeperCompatibleInterface {
    /* Type declarations */
    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;
    uint32 private immutable i_callbackGasLimit;
    uint16 private constant REQUEST_CONFIRMATIONS = 3;
    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);

    constructor(
        address vrfCoordinatorV2,
        uint256 entranceFee,
        bytes32 gasLane,
        uint64 subscriptionId,
        uint32 callbackGasLimit,
        uint256 interval
    ) VRFConsumerBaseV2(vrfCoordinatorV2) {
        i_entranceFee = entranceFee;
        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_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 of mapping. Named events with the functions name reversed */
        emit RaffleEnter(msg.sender);
    }

    /**
     * @dev This is the function that the Chainlink Keeper nodes call
     * they look for `upkeepNeeded` to return True.
     * the following should be true for this to return true:
     * 1. The time interval has passed between raffle runs.
     * 2. The lottery is open.
     * 3. The contract has ETH.
     * 4. Implicity, your subscription is funded with LINK.
     */

    function checkUpkeep(
        bytes memory /*checkData*/
    )
        public
        override
        returns (
            bool upkeepNeeded,
            bytes memory /* performData */
        )
    {
        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 /* performData */
    ) 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 indexOfWinner = randomWords[0] % s_players.length;
        address payable recentWinner = s_players[indexOfWinner];
        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_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;
    }
}

[SpeedBird789]

Hey @SpeedBird789 rename the "Keep" in checkUpKeep and performUpKeep to "keep" (with a small k).

Ah what a silly mistake!
All good now, cheers mate!

[Ar11-kgp]

@SpeedBird789 you not alone vro. Committed the same mistake ;-;

[likhith-xorstack]

// Winner to be selected every 'X' minutes -> completely automated

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

// error codes here
error Lottery__NotEnoughETHEntered();
error Lottery__TransferFailed();
error Lottery__NotOpen();
error Lottery__UpkeepNotNeeded(uint256 currentBalance, uint256 numPlayers, uint256 LotteryState);

import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";
import "@chainlink/contracts/src/v0.8/interfaces/AutomationCompatibleInterface.sol";
//IGNORE THIS, (OFFICIAL EXTENSION ISSUE)

contract Lottery is VRFConsumerBaseV2 {
    /* State variables */
    uint256 private immutable i_entranceFee;
    address payable[] private  s_palyers;
    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;

    /* Type declaration */
    enum LotteryState {
        OPEN, CALCULATING
    }

    // lottery variables
    address private s_recentWinner;
    LotteryState private s_lotteryState;
    uint256 private s_lastTimeStamp;
    uint256 private immutable i_interval;

    /* Events */
    event LotterEnter(address indexed player); 
    event RequestedLotteryWinner(uint256 indexed requestId); 
    event WinnerPicked(address indexed winner); 

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

    // Enter the lotter by paying some ETH 
    function enterLottery() public payable {
        if (msg.value > i_entranceFee) {
            revert Lottery__NotEnoughETHEntered();
        }

        if(s_lotteryState != LotteryState.OPEN){
            revert Lottery__NotOpen();
        }

        // add the player once they pay entranceFee
        s_palyers.push(payable(msg.sender));

        // emir an event when we update a dynamic array or mapping
        // named events with its fun name reversed
        emit LotterEnter(msg.sender);
    }

    // automated execution (ChainLink Keepers), it has 2 function!
        // 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 should have some ETH
        // 3. Our subscription is funded with Link
        // 4. The lottery should be in "open" state
    
    // Pick a random winner (verify random)
        // we need ChainLink Oracle for :
        // randomn number generator (ChainLink Randomness)

        // ChainLink VRF is a 2 transaction process
            // 1st step:- request a random number
            // 2nd step:- once we get it, do something with it

    function checkUpkeep(bytes memory) public override returns(bool upkeepNeeded, bytes memory) {
        bool isOpen = (LotteryState.OPEN == s_lotteryState);
        bool timePassed = ((block.timestamp - s_lastTimeStamp) > i_interval);
        bool hasPlayers = (s_palyers.length > 0);
        bool hasBalance = (address(this).balance > 0);

        upkeepNeeded = (isOpen && timePassed && hasBalance && hasPlayers);
    }

    function performUpkeep(bytes calldata) external override {
        (bool upkeepNeeded,) = checkUpkeep("");

        if(!upkeepNeeded){
            revert Lottery__UpkeepNotNeeded(
                address(this).balance,
                s_palyers.length,
                uint256(s_lotteryState)
            );
        }
        
        // 2nd step of ChainLink randomness is here, 1st step will be performed in "fulfillRandomWords" function

        // updated the lottery state first
        s_lotteryState = LotteryState.CALCULATING;

        uint256 requestId = i_vrfCoordinator.requestRandomWords(
            i_gasLane,
            i_subscriptionId,
            REQUEST_CONFIRMATIONS, 
            i_callbackGasLimit,
            NUM_WORDS
        );
        emit RequestedLotteryWinner(requestId); 
    }

    function fulfillRandomWords(uint256, uint256[] memory randomWords) internal override {
        // 1st step of ChainLink randomness is here, 2nd step will be performed in "performUpkeep" function

        // convert that random number into small number that can be used as an index of the players
        uint256 indexOfWinner = randomWords[0] % s_palyers.length;
        address payable recentWinner = s_palyers[indexOfWinner];
        s_recentWinner = recentWinner;

        // Set lottery state back to open
        s_lotteryState = LotteryState.OPEN;

        // once winner is picked, reset the player array
        s_palyers = new address payable[](0);

        // reset timestamp
        s_lastTimeStamp = block.timestamp;

        (bool success,) = recentWinner.call{value:address(this).balance}("");

        if(!success){
            revert Lottery__TransferFailed();
        }
        emit WinnerPicked(recentWinner);
    }

                /* PURE & VIEW functions */

    // to read enteranceFee
    function getEntranceFee() public view returns (uint256) {
        return i_entranceFee;
    }

    // to read all the players
    function getPlayers(uint256 index) public view returns (address) {
        return s_palyers[index];
    }

    // to read recent winner
    function getRecentWinner() public view returns (address) {
        return s_recentWinner;
    }

    // to read lottery state
    function getLotteryState() public view returns (LotteryState) {
        return s_lotteryState;
    }

    // to read numWords
    function getNumWords() public pure returns (uint256) {
        return NUM_WORDS;
    }

    // to read number of players
    function getNumberOfPlayers() public view returns (uint256) {
        return s_palyers.length;
    }

    // to read latest timestamp
    function getNLatestTimeStamp() public view returns (uint256) {
        return s_lastTimeStamp;
    }

    // to read request confirmations
    function getRequestConfirmations() public pure returns (uint256) {
        return REQUEST_CONFIRMATIONS;
    }
}

i have changed the "keep" in checkUpkeep and performUpkeep function to small, but im still facing the same issue. Please point me in the right direction.

ERROR :-

TypeError: Function has override specified but does not override anything.
  --> Contracts/Lottery.sol:95:47:
   |
95 |     function checkUpkeep(bytes memory) public override returns(bool upkeepNeeded, bytes memory) {
   |                                               ^^^^^^^^


TypeError: Function has override specified but does not override anything.
   --> Contracts/Lottery.sol:104:53:
    |
104 |     function performUpkeep(bytes calldata) external override {
    |                                                     ^^^^^^^^


Error HH600: Compilation failed

[aaryanXcode]

// Winner to be selected every 'X' minutes -> completely automated

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

// error codes here
error Lottery__NotEnoughETHEntered();
error Lottery__TransferFailed();
error Lottery__NotOpen();
error Lottery__UpkeepNotNeeded(uint256 currentBalance, uint256 numPlayers, uint256 LotteryState);

import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";
import "@chainlink/contracts/src/v0.8/interfaces/AutomationCompatibleInterface.sol";
//IGNORE THIS, (OFFICIAL EXTENSION ISSUE)

contract Lottery is VRFConsumerBaseV2 {
    /* State variables */
    uint256 private immutable i_entranceFee;
    address payable[] private  s_palyers;
    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;

    /* Type declaration */
    enum LotteryState {
        OPEN, CALCULATING
    }

    // lottery variables
    address private s_recentWinner;
    LotteryState private s_lotteryState;
    uint256 private s_lastTimeStamp;
    uint256 private immutable i_interval;

    /* Events */
    event LotterEnter(address indexed player); 
    event RequestedLotteryWinner(uint256 indexed requestId); 
    event WinnerPicked(address indexed winner); 

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

    // Enter the lotter by paying some ETH 
    function enterLottery() public payable {
        if (msg.value > i_entranceFee) {
            revert Lottery__NotEnoughETHEntered();
        }

        if(s_lotteryState != LotteryState.OPEN){
            revert Lottery__NotOpen();
        }

        // add the player once they pay entranceFee
        s_palyers.push(payable(msg.sender));

        // emir an event when we update a dynamic array or mapping
        // named events with its fun name reversed
        emit LotterEnter(msg.sender);
    }

    // automated execution (ChainLink Keepers), it has 2 function!
        // 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 should have some ETH
        // 3. Our subscription is funded with Link
        // 4. The lottery should be in "open" state
    
    // Pick a random winner (verify random)
        // we need ChainLink Oracle for :
        // randomn number generator (ChainLink Randomness)

        // ChainLink VRF is a 2 transaction process
            // 1st step:- request a random number
            // 2nd step:- once we get it, do something with it

    function checkUpkeep(bytes memory) public override returns(bool upkeepNeeded, bytes memory) {
        bool isOpen = (LotteryState.OPEN == s_lotteryState);
        bool timePassed = ((block.timestamp - s_lastTimeStamp) > i_interval);
        bool hasPlayers = (s_palyers.length > 0);
        bool hasBalance = (address(this).balance > 0);

        upkeepNeeded = (isOpen && timePassed && hasBalance && hasPlayers);
    }

    function performUpkeep(bytes calldata) external override {
        (bool upkeepNeeded,) = checkUpkeep("");

        if(!upkeepNeeded){
            revert Lottery__UpkeepNotNeeded(
                address(this).balance,
                s_palyers.length,
                uint256(s_lotteryState)
            );
        }
        
        // 2nd step of ChainLink randomness is here, 1st step will be performed in "fulfillRandomWords" function

        // updated the lottery state first
        s_lotteryState = LotteryState.CALCULATING;

        uint256 requestId = i_vrfCoordinator.requestRandomWords(
            i_gasLane,
            i_subscriptionId,
            REQUEST_CONFIRMATIONS, 
            i_callbackGasLimit,
            NUM_WORDS
        );
        emit RequestedLotteryWinner(requestId); 
    }

    function fulfillRandomWords(uint256, uint256[] memory randomWords) internal override {
        // 1st step of ChainLink randomness is here, 2nd step will be performed in "performUpkeep" function

        // convert that random number into small number that can be used as an index of the players
        uint256 indexOfWinner = randomWords[0] % s_palyers.length;
        address payable recentWinner = s_palyers[indexOfWinner];
        s_recentWinner = recentWinner;

        // Set lottery state back to open
        s_lotteryState = LotteryState.OPEN;

        // once winner is picked, reset the player array
        s_palyers = new address payable[](0);

        // reset timestamp
        s_lastTimeStamp = block.timestamp;

        (bool success,) = recentWinner.call{value:address(this).balance}("");

        if(!success){
            revert Lottery__TransferFailed();
        }
        emit WinnerPicked(recentWinner);
    }

                /* PURE & VIEW functions */

    // to read enteranceFee
    function getEntranceFee() public view returns (uint256) {
        return i_entranceFee;
    }

    // to read all the players
    function getPlayers(uint256 index) public view returns (address) {
        return s_palyers[index];
    }

    // to read recent winner
    function getRecentWinner() public view returns (address) {
        return s_recentWinner;
    }

    // to read lottery state
    function getLotteryState() public view returns (LotteryState) {
        return s_lotteryState;
    }

    // to read numWords
    function getNumWords() public pure returns (uint256) {
        return NUM_WORDS;
    }

    // to read number of players
    function getNumberOfPlayers() public view returns (uint256) {
        return s_palyers.length;
    }

    // to read latest timestamp
    function getNLatestTimeStamp() public view returns (uint256) {
        return s_lastTimeStamp;
    }

    // to read request confirmations
    function getRequestConfirmations() public pure returns (uint256) {
        return REQUEST_CONFIRMATIONS;
    }
}

i have changed the "keep" in checkUpkeep and performUpkeep function to small, but im still facing the same issue. Please point me in the right direction.

ERROR :-

TypeError: Function has override specified but does not override anything.
  --> Contracts/Lottery.sol:95:47:
   |
95 |     function checkUpkeep(bytes memory) public override returns(bool upkeepNeeded, bytes memory) {
   |                                               ^^^^^^^^


TypeError: Function has override specified but does not override anything.
   --> Contracts/Lottery.sol:104:53:
    |
104 |     function performUpkeep(bytes calldata) external override {
    |                                                     ^^^^^^^^


Error HH600: Compilation failed

is it resolved? I am also facing this issue.

[aaryanXcode]

// Winner to be selected every 'X' minutes -> completely automated

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

// error codes here
error Lottery__NotEnoughETHEntered();
error Lottery__TransferFailed();
error Lottery__NotOpen();
error Lottery__UpkeepNotNeeded(uint256 currentBalance, uint256 numPlayers, uint256 LotteryState);

import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";
import "@chainlink/contracts/src/v0.8/interfaces/AutomationCompatibleInterface.sol";
//IGNORE THIS, (OFFICIAL EXTENSION ISSUE)

contract Lottery is VRFConsumerBaseV2 {
    /* State variables */
    uint256 private immutable i_entranceFee;
    address payable[] private  s_palyers;
    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;

    /* Type declaration */
    enum LotteryState {
        OPEN, CALCULATING
    }

    // lottery variables
    address private s_recentWinner;
    LotteryState private s_lotteryState;
    uint256 private s_lastTimeStamp;
    uint256 private immutable i_interval;

    /* Events */
    event LotterEnter(address indexed player); 
    event RequestedLotteryWinner(uint256 indexed requestId); 
    event WinnerPicked(address indexed winner); 

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

    // Enter the lotter by paying some ETH 
    function enterLottery() public payable {
        if (msg.value > i_entranceFee) {
            revert Lottery__NotEnoughETHEntered();
        }

        if(s_lotteryState != LotteryState.OPEN){
            revert Lottery__NotOpen();
        }

        // add the player once they pay entranceFee
        s_palyers.push(payable(msg.sender));

        // emir an event when we update a dynamic array or mapping
        // named events with its fun name reversed
        emit LotterEnter(msg.sender);
    }

    // automated execution (ChainLink Keepers), it has 2 function!
        // 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 should have some ETH
        // 3. Our subscription is funded with Link
        // 4. The lottery should be in "open" state
    
    // Pick a random winner (verify random)
        // we need ChainLink Oracle for :
        // randomn number generator (ChainLink Randomness)

        // ChainLink VRF is a 2 transaction process
            // 1st step:- request a random number
            // 2nd step:- once we get it, do something with it

    function checkUpkeep(bytes memory) public override returns(bool upkeepNeeded, bytes memory) {
        bool isOpen = (LotteryState.OPEN == s_lotteryState);
        bool timePassed = ((block.timestamp - s_lastTimeStamp) > i_interval);
        bool hasPlayers = (s_palyers.length > 0);
        bool hasBalance = (address(this).balance > 0);

        upkeepNeeded = (isOpen && timePassed && hasBalance && hasPlayers);
    }

    function performUpkeep(bytes calldata) external override {
        (bool upkeepNeeded,) = checkUpkeep("");

        if(!upkeepNeeded){
            revert Lottery__UpkeepNotNeeded(
                address(this).balance,
                s_palyers.length,
                uint256(s_lotteryState)
            );
        }
        
        // 2nd step of ChainLink randomness is here, 1st step will be performed in "fulfillRandomWords" function

        // updated the lottery state first
        s_lotteryState = LotteryState.CALCULATING;

        uint256 requestId = i_vrfCoordinator.requestRandomWords(
            i_gasLane,
            i_subscriptionId,
            REQUEST_CONFIRMATIONS, 
            i_callbackGasLimit,
            NUM_WORDS
        );
        emit RequestedLotteryWinner(requestId); 
    }

    function fulfillRandomWords(uint256, uint256[] memory randomWords) internal override {
        // 1st step of ChainLink randomness is here, 2nd step will be performed in "performUpkeep" function

        // convert that random number into small number that can be used as an index of the players
        uint256 indexOfWinner = randomWords[0] % s_palyers.length;
        address payable recentWinner = s_palyers[indexOfWinner];
        s_recentWinner = recentWinner;

        // Set lottery state back to open
        s_lotteryState = LotteryState.OPEN;

        // once winner is picked, reset the player array
        s_palyers = new address payable[](0);

        // reset timestamp
        s_lastTimeStamp = block.timestamp;

        (bool success,) = recentWinner.call{value:address(this).balance}("");

        if(!success){
            revert Lottery__TransferFailed();
        }
        emit WinnerPicked(recentWinner);
    }

                /* PURE & VIEW functions */

    // to read enteranceFee
    function getEntranceFee() public view returns (uint256) {
        return i_entranceFee;
    }

    // to read all the players
    function getPlayers(uint256 index) public view returns (address) {
        return s_palyers[index];
    }

    // to read recent winner
    function getRecentWinner() public view returns (address) {
        return s_recentWinner;
    }

    // to read lottery state
    function getLotteryState() public view returns (LotteryState) {
        return s_lotteryState;
    }

    // to read numWords
    function getNumWords() public pure returns (uint256) {
        return NUM_WORDS;
    }

    // to read number of players
    function getNumberOfPlayers() public view returns (uint256) {
        return s_palyers.length;
    }

    // to read latest timestamp
    function getNLatestTimeStamp() public view returns (uint256) {
        return s_lastTimeStamp;
    }

    // to read request confirmations
    function getRequestConfirmations() public pure returns (uint256) {
        return REQUEST_CONFIRMATIONS;
    }
}

i have changed the "keep" in checkUpkeep and performUpkeep function to small, but im still facing the same issue. Please point me in the right direction.
ERROR :-

TypeError: Function has override specified but does not override anything.
  --> Contracts/Lottery.sol:95:47:
   |
95 |     function checkUpkeep(bytes memory) public override returns(bool upkeepNeeded, bytes memory) {
   |                                               ^^^^^^^^


TypeError: Function has override specified but does not override anything.
   --> Contracts/Lottery.sol:104:53:
    |
104 |     function performUpkeep(bytes calldata) external override {
    |                                                     ^^^^^^^^


Error HH600: Compilation failed

is it resolved? I am also facing this issue.

oh sorry,I got it :)