What is the purpose of checkUpKeep() and performUpKeep()

[EddiePumpin]

`//SPDX License-Identifier: MIT;
pragma solidity ^0.8.20;

import {VRFConsumerBaseV2Plus} from "@chainlink/contracts/src/v0.8/vrf/dev/VRFConsumerBaseV2Plus.sol";
import "@chainlink/contracts/src/v0.8/vrf/interfaces/VRFCoordinatorV2Interface.sol";
import {AutomationCompatibleInterface} from "@chainlink/contracts/src/v0.8/automation/AutomationCompatible.sol";

// 1. Enter Raffle
// 2. Pick a random winner - Chainlink VRF
// 3. In every X minutes - Chainlink automation

error Raffle__NotEnoughETH();
error Raffle__RaffleNotOpened();
error Raffle__TransferFailed();
error Raffle__upKeepNotNeeded();

contract Raffle is VRFConsumerBaseV2Plus, AutomationCompatibleInterface, {
// State Varables
enum RaffleState {
OPEN,
CALCULATING
}

uint256 public immutable i_entranceFee;
address[] public s_rafflePlayers;
uint256 private immutable i_subscriptionId;
VRFCoordinatorV2Interface private immutable i_vrfCoordinator;
RaffleState private s_raffleState;

address public s_raffleWinner;
uint256 public s_lastTimeStamp;
uint256 public immutable i_timeInterval;

constructor(
    uint256 entranceFee,
    uint256 subscriptionId,
    address vrfCoordinator,
    uint256 timeInterval
) VRFConsumerBaseV2Plus(vrfCoordinator) {
    i_entranceFee = entranceFee;
    i_subscriptionId = subscriptionId;
    i_vrfCoordinator = VRFCoordinatorV2Interface(vrfCoordinator);
    s_lastTimeStamp = block.timestamp;
    i_timeInterval = timeInterval;
    s_raffleState = RaffleState.OPEN;
}

function enterRaffle() public payable {
    if (msg.value < i_entranceFee) {
        revert Raffle__NotEnoughETH();
    }
    if (s_raffleState != RaffleState.OPEN) {
        revert Raffle__RaffleNotOpened();
    }
    s_rafflePlayers.push(payable(msg.sender));
}

function fulfillRandomWords(
    uint256 /*requestId,*/,
    uint256[] calldata randomWords
) internal override {
    uint256 winnerIndex = randomWords[0] % s_rafflePlayers.length;
    address raffleWinner = s_rafflePlayers[winnerIndex];
    s_raffleWinner = raffleWinner;
    (bool success, ) = s_raffleWinner.call{value: address(this).balance}(
        ""
    );
    if (!success) {
        revert Raffle__TransferFailed();
    }
    s_rafflePlayers = new address[](0);
    s_raffleState = RaffleState.OPEN;
    s_lastTimeStamp = block.timestamp;
}

function checkUpKeep(bytes calldata /* checkData */) public override returns (bool upKeepNeeded, bytes memory /* performData */ ) {
    bool isOpen = (RaffleState.OPEN == s_raffleState);
    bool timePaased = ((s_lastTimeStamp - block.timestamp) > i_timeInterval);
    bool hasPlayers = (s_rafflePlayers.length > 0);
    bool hasBalance = (address(this).balance > 0);
    
    upKeepNeeded = (timePaased && hasPlayers && hasBalance && isOpen );
}

function performUpKeep(bytes calldata /* performData */) external override {
    (bool upKeepNeeded, ) = checkUpKeep("");
    if(!upKeepNeeded) {
        revert Raffle__upKeepNotNeeded();
    }
}

}

`

[HarigovindM-G]

So here the point is that we are using ChainLink keepers to upkeep our Smart contract right . So for these keepers to work our contract have to compatible with theirs , so when you check the documentation , we can see that , Chainlink keepers work on the basis of these two functions checkUpKeep and performUpKeep. So what chainlink keepers do is that they will look for this function checkUpKeep to be true for performing the upkeep , here we have specified some condition on which we need to perform the upkeep . Also you have to note that we cannot just give params like we wish to checkUpKeep because our Contract inherits from AutomationCompatibleInterface.sol , so you can just go to AutomationCompatibleInterface.sol to check the params and how to implement it , you can see that in AutomationCompatibleInterface.sol they only provide the interface and we have to implement these functions in our contract . So when checkUpkeep is True , the chainlink keepers understand that it is time to perform some action , but what action should they do?, here is where performUpKeep comes to play , in this function we write what we want the keepers to do to our contract to upkeep it , in our case its like choosing a winner , resestting lottery and stuff . contract Raffle is VRFConsumerBaseV2Plus, AutomationCompatibleInterface This is the line where the inheritance happens if you dont know it already .
Hope it helps
Hari

[EddiePumpin]

Thanks for the answer, it helps

[EddiePumpin]

I will like to ask a question on ERC20. Is the second contract(OurToken.sol) not complete.

Also in the test script, the name(), symbol(), totalSupply was called but they are not in the ManualToken.sol contract

[HarigovindM-G]

In the ManualToken.sol, you could see that name , symbol and totalSupply are public variables

you can just access them by using .name() , .symbol() , .totalSupply() . But on the other hand if these variables were private , you cannot access them using . , This is a concept called access specifiers in Object Oriented Programming . If you want to learn more about the access specifiers you can just the lookup the internet and find ton of explanations .
Hope this clears your question
Happy coding
Hari

[EddiePumpin]

Thanks mate. I think you should be a tutor like Patrick

[HarigovindM-G]

Thank You Eddie , your wishes really mean a lot to me

[steveharo]

In the context of blockchain-based smart contracts, particularly when using Chainlink Keepers (now Chainlink Automation), the functions checkUpkeep() and performUpkeep() play crucial roles in automating certain contract functions.

checkUpkeep(): This function is called by the Chainlink Keeper nodes to determine whether the contract requires any upkeep or maintenance. It returns a boolean value indicating if the conditions for upkeep are met. If checkUpkeep() returns true, it means that the conditions have been satisfied and performUpkeep() should be executed.

performUpkeep(): If checkUpkeep() indicates that upkeep is needed, performUpkeep() is called by the Keeper nodes. This function contains the logic for the actual tasks that need to be performed, such as executing specific contract functions, updating states, or triggering actions.

Together, these functions allow for the decentralized and automated execution of smart contract tasks without requiring manual intervention.

[EddiePumpin]

THANKS MATE,