Lesson 09: TypeError: raffle.getEntranceFee is not a function

[umairahmed88]

this is my code

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

!developmentChains.includes(network.name)
? describe.skip
: describe("Raffle", function () {
let raffle, vrfCoordinatorV2Mock, raffleEntranceFee, deployer;
const chainId = network.config.chainId;

		beforeEach(async function () {
			deployer = (await getNamedAccounts()).deployer;
			await deployments.fixture(["all"]);
			raffle = await ethers.getContract("Raffle", deployer);
			vrfCoordinatorV2Mock = await ethers.getContract(
				"VRFCoordinatorV2Mock",
				deployer
			);
			raffleEntranceFee = await raffle.getEntranceFee();
		});

		describe("constructor", function () {
			it("initializes the raffle correctly", async function () {
				const raffleState = await raffle.getRaffleState();
				const interval = await raffle.getInterval();
				assert.equal(raffleState.toString(), "0");
				assert.equal(interval.toString(), networkConfig[chainId]["interval"]);
			});
		});

		describe("enterRaffle", function () {
			it("reverts when you don't pay enough", async function () {
				await expect(raffle.enterRaffle()).to.be.revertedWith(
					"Raffle__NotEnoughETHEntered"
				);
			});
			it("record player when they enter", async function () {
				await raffle.enterRaffle({ value: raffleEntranceFee });
				const playerFromContract = await raffle.getPlayer(0);
				assert.equal(playerFromContract, deployer);
			});
		});
  });

I got this error

 TypeError: raffle.getEntranceFee is not a function

[0xpolarzero]

Hi @umairahmed88. Could you please provide the code for your Raffle contract?

Meanwhile, this could mean that this function cannot be accessed from outside the contract. This could be due to:

• a typo: maybe you mistyped getEntranceFee in your contract ;
• the visibility: perhaps this function is marked as internal or private in your contract, which means that it cannot be accessed outside of it. In this case, you can mark it as external (access it only from outside) or public (access it from outside as well as from inside the contract).

Let me know if it solves your issue. If not, please provide the code from Raffle.sol for better assistance.

[umairahmed88]

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.17;

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 currentBalance,
uint256 numPlayers,
uint256 raffleState
);

contract Raffle is VRFConsumerBaseV2, KeeperCompatibleInterface {
enum RaffleState {
OPEN,
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_subscriptionId;
uint32 private immutable i_callbackGasLimit;
uint16 private constant REQUEST_CONFIRMATIONS = 3;
uint32 private constant NUM_WORDS = 1;

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

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

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 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 Raffle__TransferFailed();
    }
    emit WinnerPicked(recentWinner);
}

function getEntranceFee() private view returns (uint256) {
    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 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;
}

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

}

[0xpolarzero]

@umairahmed88 see this:

function getEntranceFee() private view returns (uint256) {
  i_entranceFee;
}

This function is marked as private, which makes your tests unable to access it. It should be marked as public or external, so you can access it from outside the contract.

[umairahmed88]

Thank you! Got It

[umairahmed88]

Hi @0xpolarzero !
kindly help me inresolving this issue #4901

[umairahmed88]

@0xpolarzero kindly help me in resolving this issue #4940