Lesson 9 : expected 0 constructor arguments, got 6

[parishill25]

Hi,
I got an error when i want to deploy to my hardhat network :Error: ERROR processing /root/lottery-contract/deploy/01-deploy-lottery.js:

Error: expected 0 constructor arguments, got 6.

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.4;

error Raffle__notEngoughETH();
error Raflle__TransferFailed();
error Raffle__NOTOPEN();
error Raffle__UpkeepNotNeeded(uint256 currrentbalance, uint256 numplayers, uint256 RaffleState);

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


/** @title A sample Raffle Contract
 * @author Akki Salim
 * @notice This contract is for creating untemperable  decentralized smart contract
 * @dev This implements Chainlink VRF and Chainlink Keepers
 */

abstract contract Raffle is VRFConsumerBaseV2, KeeperCompatibleInterface {
    
    enum RaffleState {
        OPEN,
        CALCULATING
    }

    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;
    uint16 private immutable i_callBackGasLimit;
    uint32 private constant REQUEST_CONFIRMATIONS = 3;
    uint32 private constant WORD_NUMBER = 1;

    address private s_recentWinner;
    RaffleState private s_rafflestate;
    uint256 private s_lasttimestamp;
    uint256 private immutable i_interval;

    event RaffleEnter(address indexed player);
    event RaffleWinnerId(uint256 indexed requestId);
    event RaffleWinner(address indexed winner);

   constructor (
        address vrfCoordinatorV2,
        uint256 entranceFee,
        bytes32 gasLane,
        uint64 subscriptionId,
        uint16 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__notEngoughETH();
        }

        if (s_rafflestate != RaffleState.OPEN) {
            revert Raffle__NOTOPEN();
        }
        s_players.push(payable(msg.sender));
        emit RaffleEnter(msg.sender);
    }

    function getEntrancefee() public view returns (uint256) {
        return i_entrancefee;
    }

    function checkUpkeep(
        bytes memory /*checkdata*/
    ) public view 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(abi.encodePacked(""));
        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,
            i_callBackGasLimit,
            REQUEST_CONFIRMATIONS,
            WORD_NUMBER
        );

        emit RaffleWinnerId(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 Raflle__TransferFailed();
        }

        emit RaffleWinner(recentWinner);
    }

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

    function getNumberOfPlayers() 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;
    }


}

01-hardhat-deploy.js

const { network, ethers } = require("hardhat")
const { developementChains, networkConfig } = require("../helper-hardhat-config")
const { verify } = require("../helper-hardhat-config")

const FUND_SUB_AMOUNT = ethers.utils.parseEther("30")

module.exports = async ({ getNamedAccounts, deployments }) => {
    const { deploy, log } = deployments
    const { deployer } = await getNamedAccounts()
    const chainId = network.config.chainId
    let VRFCoordinatorV2address, subscriptionId

    if (developementChains.includes(network.name)) {
        const VRFCoordinatorV2Mock = await ethers.getContract("VRFCoordinatorV2Mock")
        VRFCoordinatorV2address = VRFCoordinatorV2Mock.address
        const transactionResponse = await VRFCoordinatorV2Mock.createSubscription()
        const transactionReceipt = await transactionResponse.wait(1)
        subscriptionId = transactionReceipt.events[0].args.subId
        await VRFCoordinatorV2Mock.fundSubscription(subscriptionId, FUND_SUB_AMOUNT)
    } else {
        VRFCoordinatorV2address = networkConfig[chainId]["vrfCoordinatorV2"]
        subscriptionId = networkConfig[chainId]["subscriptionId"]
    }


    const entranceFee = networkConfig[chainId]["entranceFee"]
    const gasLane = networkConfig[chainId]["gasLane"]
    const callBackGasLimit = networkConfig[chainId]["callBackGasLimit"]
    const interval = networkConfig[chainId]["interval"]

    const Raffle = await deploy("Raffle", {
        from: deployer,
        args: [
            VRFCoordinatorV2address,
            entranceFee,
            gasLane,
            subscriptionId,
            callBackGasLimit,
            interval,
        ],
        log: true,
        waitConfirmations: network.config.blockConfirmation || 1,
    })
   
    if (!developementChains.includes(network.name) && process.env.ETHERSCAN_KEY) {
        log("Verifying.............")
        await verify({ address: Raffle.address, contractName: "Raffle" })
    }

    log("-----------------------------------------------")

}

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

[parishill25]

@alymurtazamemon could you please check the issue?

[alymurtazamemon]

@parishill25 Why have you marked your contract abstract?

[parishill25]

I have an error processing if i don't put the abstract : Error: ERROR processing /root/lottery-contract/deploy/01-deploy-lottery.js:
TypeError: Cannot read properties of undefined (reading 'toHexString')

[alymurtazamemon]

@parishill25 It means that the values you are assigning to the args array in the deploy have one of the values undefined. Console log the args array and see which one is undefined.