Lesson 9: No Contract deployed with name lottery

[margelatufml]

Hi! based on the Patrick's course I tried to create the same smart contract, but using as name lottery ( yes, with a lowercase letter), the contract is deployed succesfully, but when I tried to test it, if the code is good, I have this error:

1) lottery Unit tests
       "before each" hook for "Initializes the constructor correctly.":
     Error: No Contract deployed with name lottery
      at Object.getContract (node_modules\@nomiclabs\hardhat-ethers\src\internal\helpers.ts:447:11)
      at processTicksAndRejections (node:internal/process/task_queues:95:5)
      at runNextTicks (node:internal/process/task_queues:64:3)
      at listOnTimeout (node:internal/timers:533:9)
      at processTimers (node:internal/timers:507:7)
      at Context.<anonymous> (test\unit\lottery.test.js:17:25) 

lottery.test.js

const { assert } = require("chai")
const { network, getNamedAccounts, deployments, ethers } = require("hardhat")
const { developmentChains, networkConfig } = require("../../helper-hardhat-config")

!developmentChains.includes(network.name)
    ? describe.skip
    : describe("lottery Unit tests", async function () {
          let lottery
          let vrfCoordinatorV2Mock
          const chainId = network.config.chainId

          beforeEach(async function () {
              const { deployer } = await getNamedAccounts()
              await deployments.fixture(["all"]) //using fixture we can deploy our contracts with as many tags as we want
              //running all the deploy scripts using this line

              lottery = await ethers.getContract("lottery", deployer)
              vrfCoordinatorV2Mock = await ethers.getContract("VRFCoordinatorV2Mock", deployer)
          })

          describe("Constructor", async function () {
              it("Initializes the constructor correctly.", async function () {
                  const lotteryState = await lottery.getLotteryState()
                  const interval = await lottery.getInterval()

                  assert.equal(lotteryState.toString(), "0")
                  assert.equal(interval.toString(), networkConfig[chainId]["interval"])
              })
          })
      })

contract- lottery.sol:

//Lottery

//Enter the lottery(paying some amount)
//Pick a random winner
//Winner to be selected every x minutes->completely automate
//Chainlink Oracle

//SPDX-License-Identifier:MIT

pragma solidity >=0.8.4;

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 lottery__NotEnoughtETHEntered();
error lottery_TransferFailed();
error lottery_NotOpen();
error lottery_UpkeepNotNeeded(uint256 currentBalance, uint256 numPlayers, uint256 lotteryState);

/**
 * @title A simple lotytery contract
 * @author Air_trader
 * @notice This is a contract for a lottery website
 * @dev This implements ChainlinkVRF adn Keepers
 */

contract lottery is VRFConsumerBaseV2, KeeperCompatibleInterface {
    /**Type declarations*/
    enum LotteryState {
        OPEN,
        CALCULATING
    } //uint256 0=OPEN ,1=CALCULATING
    /*State variables*/
    uint256 private immutable i_entranceFee;
    address payable[] private s_players;
    VRFCoordinatorV2Interface private immutable i_vrfCoordinator;
    bytes32 private immutable i_gasLane;
    uint64 private immutable i_subscribtionId;
    uint16 private constant REQUEST_CONFIRMATIONS = 3;
    uint32 private immutable i_callbackgasLimit;
    uint32 private constant NUM_WORDS = 1;

    //Lottery Variables
    address private s_recentWinner;
    LotteryState private s_lotterystate;
    uint256 private s_lastTimeStamp;
    uint256 private s_interval;
    /*Events*/
    event LotteryEnter(address indexed player);
    event RequestedLotteryWinner(uint256 indexed requestId);
    event WinnerPicked(address indexed winner);

    constructor(
        address vfrCoordinatorV2, //contract
        uint256 entranceFee,
        bytes32 gasLane,
        uint64 subscribtionId,
        uint32 callbackGasLimit,
        uint256 interval
    ) VRFConsumerBaseV2(vfrCoordinatorV2) {
        i_entranceFee = entranceFee;
        i_vrfCoordinator = VRFCoordinatorV2Interface(vfrCoordinatorV2);
        i_gasLane = gasLane;
        i_subscribtionId = subscribtionId;
        i_callbackgasLimit = callbackGasLimit;
        s_lotterystate = LotteryState.OPEN;
        s_lastTimeStamp = block.timestamp;
        s_interval = interval;
    }

    function enterlottery() public payable {
        //require msg.value>i_entranceFee
        if (msg.value < i_entranceFee) {
            revert lottery__NotEnoughtETHEntered();
        }
        s_players.push(payable(msg.sender));
        //Events
        emit LotteryEnter(msg.sender);
        if (s_lotterystate != LotteryState.OPEN) {
            revert lottery_NotOpen();
        }
    }

    /**
     * @dev This is a function that take thar "UpkeepNeede" to return true
     * The folowing should be true in order to return true:
     * 1.Out time interval should have passed
     * 2.The lottery shold have at least 1 player, and have some ETH
     * 3.Our subsribtion should be founded with LINK
     * 4.Lottery should be in open state
     */
    function checkUpkeep(
        bytes memory /*checkData*/
    ) public override returns (bool upkeepNeeded, bytes memory /*performData*/) {
        bool isOpen = (LotteryState.OPEN == s_lotterystate);
        //block.timestamp- last block timestamp > interval
        bool timePassed = ((block.timestamp - s_lastTimeStamp) > s_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 lottery_UpkeepNotNeeded(
                address(this).balance,
                s_players.length,
                uint256(s_lotterystate)
            );
        }
        s_lotterystate = LotteryState.CALCULATING;
        uint256 requestId = i_vrfCoordinator.requestRandomWords(
            i_gasLane, //gasLane
            i_subscribtionId,
            REQUEST_CONFIRMATIONS,
            i_callbackgasLimit,
            NUM_WORDS
        );
        emit RequestedLotteryWinner(requestId);
    }

    //This will send the money to the winner
    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_lotterystate = LotteryState.OPEN;
        s_players = new address payable[](0);
        s_lastTimeStamp = block.timestamp;
        (bool succes, ) = recentWinner.call{value: address(this).balance}("");
        //require(succes)
        if (!succes) {
            revert lottery_TransferFailed();
        }
        emit WinnerPicked(recentWinner);
    }

    function getEtraceFee() 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 getLotteryState() public view returns (LotteryState) {
        return s_lotterystate;
    }

    function getNumWords() public pure returns (uint256) {
        return NUM_WORDS;
    }

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

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

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

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

01-deploy_lottery.js

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

const VRF_SUB_MOUNT = ethers.utils.parseEther("3")

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

    if (developmentChains.includes(network.name)) {
        const VRFCoordinatorV2Mock = await ethers.getContract("VRFCoordinatorV2Mock")
        vrfCoordinatorV2Address = VRFCoordinatorV2Mock.address
        const transactionResponse = await VRFCoordinatorV2Mock.createSubscription()
        const transactionReceipt = await transactionResponse.wait(1)
        subscribtionId = transactionReceipt.events[0].args.subId
        //Fund the subscribtion
        await VRFCoordinatorV2Mock.fundSubscription(subscribtionId, VRF_SUB_MOUNT)
    } else {
        vrfCoordinatorV2Address = networkConfig[chainId]["vrfCoordinatorV2"]
        subscribtionId = networkConfig[chainId]["subscriptionId"]
    }
    const entranceFEE = networkConfig[chainId]["entranceFee"]
    const gasLane = networkConfig[chainId]["gasLane"]
    const callbackGasLimit = networkConfig[chainId]["callbackGasLimit"]
    const interval = networkConfig[chainId]["interval"]
    const arguments = [
        vrfCoordinatorV2Address,
        entranceFEE,
        gasLane,
        subscribtionId,
        callbackGasLimit,
        interval,
    ]
    const lottery = await deploy("lottery", {
        from: deployer,
        args: arguments,
        log: true,
        waitConfirmations: network.config.blockConfirmations || 1,
    })
    if (!developmentChains.includes(network.name) && process.env.ETHERSCAN_API_KEY) {
        log("Verifying....")
        await verify(lottery.address, arguments)
    }

    log("_______________________")
}
module.exports.tag = ["all", "lottery"]

And this is my repository: https://github.com/margelatufml/lottery-contract

[paulcoffee85]

Looks like you need to declare: subscribtionId = transactionReceipt.events[0].args.subId
Also, entranceFEE = entranceFee in hardhat, might want to keep those all the same in every file including contract.
Test after changes and see if that works.

In 'lottery.test.js' You could use this line:
deployer = (await getNamedAccounts()).deployer
or the line you have:
const { deployer } = await getNamedAccounts() but add a declaration for 'deployer' after describe().

At end of 'deploy-lottery', need an 's' in tags
module.exports.tag = ["all", "lottery"]

Just glanced in your helper-hardhat as well. Looks like 'subscription misspelled.

    5: {
        name: "goereli",
        vrfCoordinatorV2: "0x2Ca8E0C643bDe4C2E08ab1fA0da3401AdAD7734D",
        entranceFee: ethers.utils.parseEther("0.01"),
        gasLane: "0x79d3d8832d904592c0bf9818b621522c988bb8b0c05cdc3b15aea1b6e8db0c15",
        subscribtionId: "0",
        callbackGasLimit: "500000",
        interval: "30",
    },

[margelatufml]

Thanks so much!

[paulcoffee85]

It worked ? 👍 anytime.