How to fix this error ?

[taiwanweiii]

I have typed the command npx hardhat deploy, than i got the error below.

Error code

本地端網路Mocks...
hardhat
An unexpected error occurred:

Error: ERROR processing /Users/choushi/Desktop/區塊鏈學習/Lesson 9/deploy/00-deployer-mocks.js:
TypeError: Cannot read properties of undefined (reading 'length')
    at getFrom (/Users/choushi/Desktop/區塊鏈學習/Lesson 9/node_modules/hardhat-deploy/src/helpers.ts:1625:14)
    at fetchIfDifferent (/Users/choushi/Desktop/區塊鏈學習/Lesson 9/node_modules/hardhat-deploy/src/helpers.ts:827:34)
    at processTicksAndRejections (node:internal/process/task_queues:95:5)
    at _deployOne (/Users/choushi/Desktop/區塊鏈學習/Lesson 9/node_modules/hardhat-deploy/src/helpers.ts:905:24)
    at DeploymentsManager.executeDeployScripts (/Users/choushi/Desktop/區塊鏈學習/Lesson 9/node_modules/hardhat-deploy/src/DeploymentsManager.ts:1214:19)
    at processTicksAndRejections (node:internal/process/task_queues:95:5)
    at DeploymentsManager.runDeploy (/Users/choushi/Desktop/區塊鏈學習/Lesson 9/node_modules/hardhat-deploy/src/DeploymentsManager.ts:1060:5)
    at SimpleTaskDefinition.action (/Users/choushi/Desktop/區塊鏈學習/Lesson 9/node_modules/hardhat-deploy/src/index.ts:442:5)
    at Environment._runTaskDefinition (/Users/choushi/Desktop/區塊鏈學習/Lesson 9/node_modules/hardhat/src/internal/core/runtime-environment.ts:333:14)
    at Environment.run (/Users/choushi/Desktop/區塊鏈學習/Lesson 9/node_modules/hardhat/src/internal/core/runtime-environment.ts:166:14)
    at SimpleTaskDefinition.action (/Users/choushi/Desktop/區塊鏈學習/Lesson 9/node_modules/hardhat-deploy/src/index.ts:593:32)
    at Environment._runTaskDefinition (/Users/choushi/Desktop/區塊鏈學習/Lesson 9/node_modules/hardhat/src/internal/core/runtime-environment.ts:333:14)

Lock.sol

// SPDX-License-Identifier: UNLICENSED
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 currenBalance,
    uint256 numPlayers,
    uint256 raffeState
);

/** @title Asample Raffle Contract
 *  @author STUST WILLY
 *  @notice This contract is for creating an untamperable decentralized smart contract
 *  @dev This implements Chainlink VRF v2 and Chainlink Keepers
 */
contract Raffle is VRFConsumerBaseV2, KeeperCompatibleInterface {
    /* Type declarations */
    enum RaffleState {
        OPEN,
        CALCULATING
    } //uint256 0 = OPEN , 1 = CALCULATING
    /* State Variables */
    uint256 private immutable i_entranceFee;
    address payable[] private s_players;
    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;
    VRFCoordinatorV2Interface private immutable i_vrfCoordinator;

    /* 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 requestRaffleWinner(uint256 indexed requestID);
    event WinnerPicked(address indexed winner);

    /* Function */
    constructor(
        uint256 entranceFee,
        address vrfCoordinatorV2,
        uint64 subscriptionID,
        bytes32 gasLane,
        // uint256 inteval,
        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 RaffleEnter(msg.sender);
    }

    /**
     * @dev this is the function that the Chainlink Keeper nodes call
     * they look for the 'upkeepNeeded' to return true
     * 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 have some ETH
     * 3.Our suscription is funded with LINK
     * 4.The lottery should be in an "open" state
     */
    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 requestRaffleWinner(requestId);
    }

    function fulfillRandomWords(
        uint256 /*requestId*/,
        uint256[] memory randowWords
    ) internal override {
        uint256 index0fWinner = randowWords[0] % s_players.length;
        address payable recentWinner = s_players[index0fWinner];
        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);
    }

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

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

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

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

00-deployer-mocks.js

const { developmentChains } = require("../help-hardhat-config")

const BASE_FEE = '250000000000000000'
const GAS_PRICE_LINK = 1e9
module.exports = async function ({ getNamedAccounts, deployments }) {
    const { deploy, log } = deployments
    const { deployer } = await getNamedAccounts()
    const arg = [BASE_FEE, GAS_PRICE_LINK]

    if (developmentChains.includes(network.name)) {
        log("本地端網路Mocks...")
        log(network.name)
        await deploy("VRFCoordinatorV2Mock", {
            from: deployer,
            log: true,
            args: arg,
        })
        log('Mock 部署完畢')
        log("-------------------------")
    }
}


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

hardhat.config.js

require("@nomicfoundation/hardhat-toolbox");
require("hardhat-deploy")


const SEPOLIA_PRC_URL = process.env.SEPOLIA_PRC_URL
const PRIVATE_KEY = process.env.PRIVATE_KEY
const COINMARKETCAP_API_KEY = process.env.COINMARKETCAP_API_KEY
const ETHERSCAN_API_KEY = process.env.ETHERSCAN_API_KEY


/** @type import('hardhat/config').HardhatUserConfig */
module.exports = {
  solidity: {
    compilers: [
      {
        version: "0.8.7",
      },
      // {
      //   version: "0.4.24",
      // },
    ],
  },
  nameAccounts: {
    deployer: {
      default: 0
    },
    player: {
      default: 1
    }
  },
  defaultNetwork: "hardhat",
  network: {
    hardhat: {
      chainId: 31337,
      blockConfirmations: 1
    },
    SEPOLIA: {
      chainId: 11155111,
      blockConfirmations: 6,
      url: SEPOLIA_PRC_URL,
      accounts: [PRIVATE_KEY],

    }
  }
};

help-hardhat-config.js

const { ethers } = require("hardhat")

const networkConfig = {
    11155111:
    {
        name: "SEPOLIA",
        vrfCoordinatorV2: "0x8103B0A8A00be2DDC778e6e7eaa21791Cd364625",
        entranceFee: ethers.parseEther('0.1'),
        gasLane: "0x474e34a077df58807dbe9c96d3c009b23b3c6d0cce433e59bbf5b34f823bc56c",
        subscriptionId: '0',
        callbackGasLimit: '500000',
        interval: '30',
    },
    31337: {
        name: "hardhat",
        entranceFee: ethers.parseEther('0.1'),
        gasLane: "0x474e34a077df58807dbe9c96d3c009b23b3c6d0cce433e59bbf5b34f823bc56c",
        callbackGasLimit: '500000',
        interval: '30',
    }
}
const developmentChains = ["hardhat", "localhost"]
module.exports = {
    networkConfig,
    developmentChains
}```

[Nlferu]

Hello @taiwanweiii

Try editing your imports in hardhat.config.js into below:

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