InsufficientBalance() Foundry Lottery Smart Contract

[nandes007]

i got InsufficientBalance() error when run my test below

function testFulfillrandomWordsPicksAWinnerResetsAndSendsMoney() public raffleEntered {
      uint256 additionalEntrants = 3;
      uint256 startingIndex = 1;
      address expectedWinner = address(1);

      for (uint256 i = startingIndex; i < startingIndex + additionalEntrants; i++) {
         address newPlayer = address(uint160(i));
         hoax(newPlayer, 1 ether);
         raffle.enterRaffle{value: entranceFee}();
      }
      uint256 startingTimeStamp = raffle.getLastTimeStamp();
      uint256 winnerStartingBalance = expectedWinner.balance;

      vm.recordLogs();
      raffle.performUpkeep("");
      Vm.Log[] memory entries = vm.getRecordedLogs();
      bytes32 requestId = entries[1].topics[1];
      VRFCoordinatorV2_5Mock(vrfCoordinator).fulfillRandomWords(uint256(requestId), address(raffle));

      address recentWinner = raffle.getRecentWinner();
      Raffle.RaffleState raffleState = raffle.getRaffleState();
      uint256 winnerBalance = recentWinner.balance;
      uint256 endingTimeStamp = raffle.getLastTimeStamp();
      uint256 prize = entranceFee * (additionalEntrants + 1);

      assert(recentWinner == expectedWinner);
      assert(uint256(raffleState) == 0);
      assert(winnerBalance == winnerStartingBalance + prize);
      assert(endingTimeStamp > startingTimeStamp);
   }

Below my DeployRaffle.s.sol

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

import {Script} from "forge-std/Script.sol";
import {Raffle} from "src/Raffle.sol";
import {HelperConfig} from "script/HelperConfig.s.sol";
import {CreateSubscription, FundSubscription, AddConsumer} from "script/Interactions.s.sol";

contract DeployRaffle is Script{
 function run() public {
    deployContract();
 }

 function deployContract() public returns (Raffle, HelperConfig) {
    HelperConfig helperConfig = new HelperConfig();
    // local -> deploy mocks, get local config
    // sepolia -> get sepolia config
    HelperConfig.NetworkConfig memory config = helperConfig.getConfig();

    if (config.subscriptionId == 0) {
       // create subscription
       CreateSubscription createSubscription = new CreateSubscription();
       (config.subscriptionId, config.vrfCoordinator) = createSubscription.createSubscription(config.vrfCoordinator);

       // fund it
       FundSubscription fundSubscription = new FundSubscription();
       fundSubscription.fundSubscription(config.vrfCoordinator, config.subscriptionId, config.link);
    }

    vm.startBroadcast();
    Raffle raffle = new Raffle(
       config.entranceFee,
       config.interval,
       config.vrfCoordinator,
       config.gasLane,
       config.subscriptionId,
       config.callbackGasLimit
    );
    vm.stopBroadcast();

    AddConsumer addConsumer = new AddConsumer();
    addConsumer.addConsumer(address(raffle), config.vrfCoordinator, config.subscriptionId);

    return(raffle, helperConfig);
 }
}

Below my HelperConfig.s.sol

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

import {Script} from "forge-std/Script.sol";
import {VRFCoordinatorV2_5Mock} from "@chainlink/contracts/src/v0.8/vrf/mocks/VRFCoordinatorV2_5Mock.sol";
import {LinkToken} from "test/mocks/LinkToken.sol";

abstract contract CodeConstants {
   /* VRF Mock Values */
   uint96 public constant MOCK_BASE_FEE = 0.25 ether;
   uint96 public constant MOCK_GAS_PRICE_LINK = 1e9;
   // LINK / ETH price
   int256 public constant MOCK_WEI_PER_UNIT_LINK = 4e15;

   uint256 public constant ETH_SEPOLIA_CHAIN_ID = 11155111;
   uint256 public constant LOCAL_CHAIN_ID = 31337;
}

contract HelperConfig is CodeConstants, Script {
   error HelperConfig__InvalidChainId();

   struct NetworkConfig {
      uint256 entranceFee;
      uint256 interval;
      address vrfCoordinator;
      bytes32 gasLane;
      uint32 callbackGasLimit;
      uint256 subscriptionId;
      address link;
   }

   NetworkConfig public localNetworkConfig;
   mapping(uint256 chainId => NetworkConfig) public networkConfigs;

   constructor() {
      networkConfigs[ETH_SEPOLIA_CHAIN_ID] = getSepoliaEthConfig();
   }

   function getConfigByChainId(uint256 chainId) public returns (NetworkConfig memory) {
      if (networkConfigs[chainId].vrfCoordinator != address(0)) {
         return networkConfigs[chainId];
      } else if (chainId == LOCAL_CHAIN_ID) {
         return getOrCreateAnvilEthConfig();
      } else {
         revert HelperConfig__InvalidChainId();
      }
   }

   function getSepoliaEthConfig() public pure returns (NetworkConfig memory) {
      return NetworkConfig({
         entranceFee: 0.01 ether, // 1e16
         interval: 30, // 30 seconds
         vrfCoordinator: 0x9DdfaCa8183c41ad55329BdeeD9F6A8d53168B1B,
         gasLane: 0x787d74caea10b2b357790d5b5247c2f63d1d91572a9846f780606e4d953677ae,
         callbackGasLimit: 500000,
         subscriptionId: 69914354514457442842714437614694663546291266087561478362118270048052038076816,
         link: 0x779877A7B0D9E8603169DdbD7836e478b4624789
      });
   }

   function getConfig() public returns (NetworkConfig memory) {
      return getConfigByChainId(block.chainid);
   }

   function getOrCreateAnvilEthConfig() public returns (NetworkConfig memory) {
      // check to see if we set an active network config
      if (localNetworkConfig.vrfCoordinator != address(0)) {
         return localNetworkConfig;
      }

      // Deploy mocks and such
      vm.startBroadcast();
      VRFCoordinatorV2_5Mock vrfCoordinator = new VRFCoordinatorV2_5Mock(MOCK_BASE_FEE, MOCK_GAS_PRICE_LINK, MOCK_WEI_PER_UNIT_LINK);
      LinkToken linkToken = new LinkToken();
      vm.stopBroadcast();

      localNetworkConfig = NetworkConfig({
         entranceFee: 0.01 ether,
         interval: 30,
         vrfCoordinator: address(vrfCoordinator),
         // doesn't matter
         gasLane: 0x787d74caea10b2b357790d5b5247c2f63d1d91572a9846f780606e4d953677ae,
         callbackGasLimit: 500000, // 500,000 gas
         subscriptionId: 0, // might have to fix this
         link: address(linkToken)
      });
      return localNetworkConfig;
   }
}

Below my Intractions.s.sol

// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;

import {Script, console} from "forge-std/Script.sol";
import {HelperConfig, CodeConstants} from "script/HelperConfig.s.sol";
import {VRFCoordinatorV2_5Mock} from "@chainlink/contracts/src/v0.8/vrf/mocks/VRFCoordinatorV2_5Mock.sol";
import {LinkToken} from "test/mocks/LinkToken.sol";
import {DevOpsTools} from "lib/foundry-devops/src/DevOpsTools.sol";

contract CreateSubscription is Script {
   function createSubscriptionUsingConfig() public returns (uint256, address) {
      HelperConfig helperConfig = new HelperConfig();
      address vrfCoordinator = helperConfig.getConfig().vrfCoordinator;
      (uint256 subId, ) = createSubscription(vrfCoordinator);
      return (subId, vrfCoordinator);
   }

   function createSubscription(address vrfCoordinator) public returns (uint256, address) {
      console.log("Creating subscription on chain Id: ", block.chainid);
      vm.startBroadcast();
      uint256 subId = VRFCoordinatorV2_5Mock(vrfCoordinator).createSubscription();
      vm.stopBroadcast();
      console.log("Your subscription Id is: ", subId);
      console.log("Please update the subscription Id in your HelperConfig.s.sol");
      return (subId, vrfCoordinator);
   }

   function run() public {
      createSubscriptionUsingConfig();
   }
}

contract FundSubscription is Script, CodeConstants {
   uint256 public constant FUND_AMOUNT = 3 ether;

   function fundSubscriptionUsingConfig() public {
      HelperConfig helperConfig = new HelperConfig();
      address vrfCoordinator = helperConfig.getConfig().vrfCoordinator;
      uint256 subscriptionId = helperConfig.getConfig().subscriptionId;
      address linkToken = helperConfig.getConfig().link;
      fundSubscription(vrfCoordinator, subscriptionId, linkToken);
   }

   function fundSubscription(address vrfCoordinator, uint256 subscriptionId, address linkToken) public {
      console.log("Funding subscription: ", subscriptionId);
      console.log("Using vrfCoordinator: ", vrfCoordinator);
      console.log("On Chain: ", block.chainid);

      if (block.chainid == LOCAL_CHAIN_ID) {
         vm.startBroadcast();
         VRFCoordinatorV2_5Mock(vrfCoordinator).fundSubscription(subscriptionId, FUND_AMOUNT * 100);
         vm.stopBroadcast();
      } else {
         vm.startBroadcast();
         LinkToken(linkToken).transferAndCall(vrfCoordinator, FUND_AMOUNT, abi.encode(subscriptionId));
         vm.stopBroadcast();
      }
   }

   function run() public {
      fundSubscriptionUsingConfig();
   }
}

contract AddConsumer is Script {
   function addConsumerUsingConfig(address mostRecentlyDeployed) public {
      HelperConfig helperConfig = new HelperConfig();
      uint256 subId = helperConfig.getConfig().subscriptionId;
      address vrfCoordinator = helperConfig.getConfig().vrfCoordinator;
      addConsumer(mostRecentlyDeployed, vrfCoordinator, subId);
   }

   function addConsumer(address contractToAddVrf, address vrfCoordinator, uint256 subId) public {
      console.log("Adding consumer contract: ", contractToAddVrf);
      console.log("To vrfCoordinator: ", vrfCoordinator);
      console.log("On ChainId: ", block.chainid);
      vm.startBroadcast();
      VRFCoordinatorV2_5Mock(vrfCoordinator).addConsumer(subId, contractToAddVrf);
      vm.stopBroadcast();
   }
   
   function run() public {
      address mostRecentlyDeployed = DevOpsTools.get_most_recent_deployment("Raffle", block.chainid);
      addConsumerUsingConfig(mostRecentlyDeployed);
   }
}

i've do console log in VRFCoordinatorV2_5Mock.sol in _chargePayment() function for debugging like below

function _chargePayment(uint96 payment, bool nativePayment, uint256 subId) internal {
    Subscription storage subcription = s_subscriptions[subId];
    console.log("DEBUGGING");
    if (nativePayment) {
      console.log("NATIVE PAYMENT CALLED");
      uint96 prevBal = subcription.nativeBalance;
      console.log(prevBal, "prev balance");
      console.log(payment, "payment");
      if (prevBal < payment) {
        revert InsufficientBalance();
      }
      subcription.nativeBalance = prevBal - payment;
      s_withdrawableNative += payment;
    } else {
      console.log("NOT NATIVE PAYMENT CALLED");
      uint96 prevBal = subcription.balance;
      if (prevBal < payment) {
        revert InsufficientBalance();
      }
      subcription.balance = prevBal - payment;
      s_withdrawableTokens += payment;
    }
  }

and when i run test, InsufficientBalance() error come from NATIVE PAYMENT. Below the log

Logs:
Creating subscription on chain Id:  31337
Your subscription Id is:  97767009708314305665643641779529925837712974602641641141825456487478243071475
Please update the subscription Id in your HelperConfig.s.sol
Funding subscription:  97767009708314305665643641779529925837712974602641641141825456487478243071475
Using vrfCoordinator:  0x90193C961A926261B756D1E5bb255e67ff9498A1
On Chain:  31337
Adding consumer contract:  0x50EEf481cae4250d252Ae577A09bF514f224C6C4
To vrfCoordinator:  0x90193C961A926261B756D1E5bb255e67ff9498A1
On ChainId:  31337
DEBUGGING
NATIVE PAYMENT CALLED
0 prev balance
250040590000000000 payment

is there something i missed in my code ?

[EngrPips]

Hello @nandes007, Since you chose the native payment method for your vrf charges, you should fund your subscription with ETH, not LINK, and everything should be fine.

[nandes007]

Sorry @EngrPips, how to change that payment method?

[nandes007]

sorry @EngrPips, why that prev balance is 0?

[EngrPips]

Sorry @EngrPips, how to change that payment method?

You need to make the nativePayment argument in this function function _chargePayment(uint96 payment, bool nativePayment, uint256 subId) internal be false.

[nandes007]

got it, thank you a lot @EngrPips

[EngrPips]

You are welcome mah man. Keep crushing it.