lesson 9: cant deploy to sepolia testnet

[thedreader]

Deploy-raffle.js

const {
  developmentChains,
  networkConfig,
  VERIFICATION_BLOCK_CONFIRMATIONS
} = require("../helper-hardhat-config");
const { verify } = require("../utils/verify");

const VRF_SUB_AMT = ethers.utils.parseEther("5");

module.exports = async function ({ getNamedAccounts, deployments }) {
  const { deploy, log } = deployments;
  const { deployer } = await getNamedAccounts();
  const chainId = network.config.chainId;
  console.log(chainId);
  let vrfCoordinatorV2Address, subscriptionId;

  if (developmentChains.includes(network.name)) {
    const vrfCoordinatorV2Mock = await ethers.getContract("VRFCoordinatorV2Mock");
    vrfCoordinatorV2Address = vrfCoordinatorV2Mock.address;

    const transactionResponse = await vrfCoordinatorV2Mock.createSubscription();
    const transactionReceipt = await transactionResponse.wait();

    subscriptionId = transactionReceipt.events[0].args.subId;

    await vrfCoordinatorV2Mock.fundSubscription(subscriptionId, VRF_SUB_AMT);
  } 
  else {
    vrfCoordinatorV2Address = networkConfig[chainId]["vrfCoordinatorV2"];
    subscriptionId = networkConfig[chainId]["subscriptionId"];
    console.log(vrfCoordinatorV2Address + " " + subscriptionId);
  }
  const waitBlockConfirmations = developmentChains.includes(network.name)
        ? 1
        : VERIFICATION_BLOCK_CONFIRMATIONS

  const entranceFee = networkConfig[chainId]["entranceFee"];
  const gasLane = networkConfig[chainId]["gasLane"];
  const callbackGasLimit = networkConfig[chainId]["callbackGasLimit"];
  const interval = networkConfig[chainId]["interval"];
  
  const args = [
    vrfCoordinatorV2Address,
    entranceFee,
    gasLane,
    subscriptionId,
    callbackGasLimit,
    interval,
  ];

  const raffle = await deploy("Raffle", {
    from: deployer,
    args: args,
    log: true,
    waitConfirmations: waitBlockConfirmations,
  });

  if (developmentChains.includes(network.name)) {
    const vrfCoordinatorV2Mock = await ethers.getContract("VRFCoordinatorV2Mock");
    await vrfCoordinatorV2Mock.addConsumer(subscriptionId, raffle.address);

    console.log('Consumer is added');
  }

  if(!developmentChains.includes(network.name) && process.env.API_KEY_ETHERSCAN) {
    console.log("verifying...")
   await verify(raffle.address, args)
  }


  console.log("DONE!")
};

module.exports.tags= ["all", "raffle"]

hardhat-helper.js

const networkConfig= {
   5: {
      name: "goerli",
      vrfCoordinatorV2: "0x2Ca8E0C643bDe4C2E08ab1fA0da3401AdAD7734D",
      entranceFee: ethers.utils.parseEther("0.01"),
      gasLane: "0x79d3d8832d904592c0bf9818b621522c988bb8b0c05cdc3b15aea1b6e8db0c15",
      subscriptionId: "0",
      callbackGasLimit: "500000",
      interval: "30"
   },
   31337: {
      name: "hardhat",
      entranceFee: ethers.utils.parseEther("20"),
      gasLane: "0x79d3d8832d904592c0bf9818b621522c988bb8b0c05cdc3b15aea1b6e8db0c15",
      callbackGasLimit: "500000",
      interval: "30"
   },
   11155111: {
      name: "sepolia",
      subscriptionId: "690",
      gasLane: "0x474e34a077df58807dbe9c96d3c009b23b3c6d0cce433e59bbf5b34f823bc56c", // 30 gwei
      keepersUpdateInterval: "30",
      entranceFee: ethers.utils.parseEther("0.01"), // 0.01 ETH
      callbackGasLimit: "500000", // 500,000 gas
      vrfCoordinatorV2: "0x8103B0A8A00be2DDC778e6e7eaa21791Cd364625",
   },


}

const developmentChains= ["hardhat", "localhost"]
const VERIFICATION_BLOCK_CONFIRMATIONS = 6

module.exports= {
   networkConfig,
   developmentChains,
   VERIFICATION_BLOCK_CONFIRMATIONS
}

hardhat.config.js

require("@nomiclabs/hardhat-etherscan")
require("hardhat-deploy")
require("solidity-coverage")
require("hardhat-gas-reporter")
require("hardhat-contract-sizer")
require("dotenv").config()

const sepoliaUrl = process.env.SEPOLIA_RPC_URL;
const sepolia_private_key = process.env.PRIVATE_KEY;
const API_KEY_ETHERSCAN = process.env.API_KEY_ETHERSCAN;

/** @type import('hardhat/config').HardhatUserConfig */
module.exports = {
  solidity: "0.8.8",
  defaultNetwork: "hardhat",
  networks: {
    hardhat: {
      chainId: 31337,
      blockConfirmations: 1,
    },
    sepolia: {
      url: sepoliaUrl,
      accounts: [sepolia_private_key],
      chainId: 11155111,
      blockConfirmations: 6,
      saveDeployments: true,
    },
  },
  namedAccounts: {
    deployer: {
      default: 0,
    },
    player: {
      default: 1,
    },
  },

  etherscan: {
    apiKey: API_KEY_ETHERSCAN,
    // customChains: [], // uncomment this line if you are getting a TypeError: customChains is not iterable
  },

  //   etherscan: {

  //     // yarn hardhat verify --network <NETWORK> <CONTRACT_ADDRESS> <CONSTRUCTOR_PARAMETERS>
  //     apiKey: {
  //         goerli: API_KEY_ETHERSCAN,
  //     },
  //     customChains: [
  //         {
  //             network: "goerli",
  //             chainId: 5,
  //             urls: {
  //                 apiURL: "https://api-goerli.etherscan.io/api",
  //                 browserURL: "https://goerli.etherscan.io",
  //             },
  //         },
  //     ],
  // },

  gasReporter: {
    enabled: false,
    currency: "USD",
    outputFile: "gas-report.txt",
    noColors: true,
    // coinmarketcap: process.env.COINMARKETCAP_API_KEY,
  },
  mocha: {
    timeout: 500000, //500secs
  },
};

Raffle.sol

//enter the lottery game
//pick a random winner
//winner to be selected after every x min -> completely automated
//chainlink oracle-> for randomness and automated execution-> chainlink keepers

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

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

//errors
error Raffle__NotEnoughETHEntered();
error Raffle__TransferFailed();
error Raffle__NotOpen();
error Raffle__UpkeepNotNeeded(uint256 currentBal, uint256 numPlayers, uint256 raffleState);

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

    /* State vars */
    VRFCoordinatorV2Interface private immutable i_vrfCoordinator;
    bytes32 private immutable i_gasLane;
    uint64 private immutable i_subscriptionId;
    uint16 private constant requestConfirmations = 3;
    uint32 private immutable i_callbackGasLimit;
    uint32 private constant numWords = 1;

    //lottery variables
    address private s_recentWinner;
    address payable[] private s_players;
    RaffleState private s_raffleState;
    uint256 private immutable i_interval;
    uint256 private immutable i_entranceFee;
    uint256 private s_lastTimeStamp;

    /* Events */
    //indexed vars are easy to find
    event RaffleEnter(address indexed player);
    event RequestedRaffleWinner(uint256 indexed requestId);
    event WinnerPicked(address indexed recentWinner);

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

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

        //Events get emitted to a data storage outside of the smart contract
        //Emit an event when we update a dynamic array or mapping
        //Named events with the function named reversed

        emit RaffleEnter(msg.sender);
    }

    function fulfillRandomWords(
        uint256 /*requestId*/,
        uint256[] memory randomWords
    ) internal override {
        uint256 indexOfWinner = randomWords[0] % s_players.length;
        address payable winner = s_players[indexOfWinner];
        s_recentWinner = winner;
        s_raffleState= RaffleState.OPEN;
        s_players= new address payable[](0);
        s_lastTimeStamp= block.timestamp;

        (bool success, ) = winner.call{value: address(this).balance}("");
        if (!success) {
            revert Raffle__TransferFailed();
        }

        emit WinnerPicked(s_recentWinner);
    }

    /**
     * @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 view override returns (bool upkeepNeeded, bytes memory /* performData */) 
    {
        bool timePassed = (block.timestamp - s_lastTimeStamp) > i_interval;
        bool isOpen= RaffleState.OPEN == s_raffleState;
        bool hasPlayers= s_players.length > 0;
        bool hasBalance= address(this).balance > 0;
        upkeepNeeded= (isOpen && timePassed && hasBalance && hasPlayers);

    }

    function performUpkeep(bytes calldata /* performData */) external override {
        (bool upkeepNeeded, ) = checkUpkeep("");
        if(!upkeepNeeded) {
            revert Raffle__UpkeepNotNeeded(address(this).balance, s_players.length, uint256(s_raffleState));
        }

        uint256 requestId = i_vrfCoordinator.requestRandomWords(
            i_gasLane,
            i_subscriptionId,
            requestConfirmations,
            i_callbackGasLimit,
            numWords
        );

        s_raffleState= RaffleState.CALCULATING;

        emit RequestedRaffleWinner(requestId);
    }

    //get 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 numWords;
    }

    function getNumPlayers() public view returns(uint256) {
        return s_players.length;
    }

    function getLastestTimeStamp() public view returns(uint256) {
        return s_lastTimeStamp;
    }

    function getRequestConfirmations() public pure returns(uint256) {
        return requestConfirmations;
    }

    function getInterval() public view returns(uint256) {
        return i_interval;
    }

    
}

The error-

But it's working on hardhat's local network

Someone please tell me what I'm doing wrong, because I'm not able to figure out the error here.

[alymurtazamemon]

@thedreader Inside the 01-deploy-raffle.js file, one of the arguments you pass the deploy is undefined. You have to make sure which one is undefined. You can console.log the args before deploying.

[thedreader]

Thanks. It worked.