Lesson 7, testing fund function - result always didnt send enough ETH

[czilauto0r1]

Hi, I stopped on tests for now it's the hardest part for me I don't know why and now I have some problem with testing fund function my code is
FundMe.test.js

const { assert, expect } = require("chai")
const { network, deployments, ethers, getNamedAccounts } = require("hardhat")
describe("FundMe", async function () {
    let fundMe
    let deployer
    let mockV3Aggregator
    const sendValue = ethers.utils.parseEther("1.0") // or 1000000000000000000
    beforeEach(async function () {
        // deploy our fundMe contract
        // using Hardhat-deploy
        // const accounts = await ethers.getSigners()
        // const accountZero = accounts[0]
        deployer = (await getNamedAccounts()).deployer
        await deployments.fixture(["all"])
        fundMe = await ethers.getContract("FundMe", deployer) // get most recent deployment fundme contract
        mockV3Aggregator = await ethers.getContract(
            "MockV3Aggregator",
            deployer
        )
    })
    describe("constructor", async function () {
        it("sets the aggregator addresses correctly", async function () {
            const response = await fundMe.priceFeed()
            assert.equal(response, mockV3Aggregator.address)
        })
    })

    describe("fund", async function () {
        it("Fails if you dont send enough ETH", async function () {
            await expect(fundMe.fund()).to.be.revertedWith("Didnt send enough")
        })
        // it("updated the amount funded data structure", async function () {
        //     await fundMe.fund({ value: sendValue })
        //     const response = await fundMe.addressToAmountFunded(deployer)
        //     assert.equal(response.toString(), sendValue.toString())
        // })
        it("Updates the amount funded data structure", async () => {
            await fundMe.fund({ value: sendValue })
            const response = await fundMe.getAddressToAmountFunded(deployer)
            assert.equal(response.toString(), sendValue.toString())
        })
    })
})

I even copied exactly same code from github and still have same error

FundMe.sol

//SPDX-License-Identifier: MIT
// Pragma
pragma solidity ^0.8.4;
//Get funds from users
// Withdraw funds
// set a minimum funding value in usd

// contract cost 819,290 gas
// Imports
import "./PriceConverter.sol";
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
// Error Codes
error FundMe__NotOwner();

// Interfaces, Libraries, Contracts

/** @title A contract for crowd funding
 *   @author Tomek Bodek
 *   @notice This contract is to demo a sample funding contract
 *   @dev This implements price fees as our library
 */
contract FundMe {
    // Type declarations
    using PriceConverter for uint256;
    // State variables!
    mapping(address => uint256) public addressToAmountFunded;
    address[] public funders;
    // Could we make this constant?
    address public immutable i_owner;
    uint256 public constant MINIMUM_USD = 50 * 1e18;
    AggregatorV3Interface public priceFeed;

    // Modifiers
    modifier onlyOwner() {
        if (msg.sender != i_owner) {
            revert FundMe__NotOwner();
        }
        _; // <- rest of code
        // require(msg.sender == i_owner, "Sender is not owner"); // <- do this first
        // <- rest of code
    }

    // Functions order:
    //// constructor
    //// receive
    //// fallback
    //// external
    //// public
    //// internal
    //// private
    //// view / pure

    constructor(address priceFeedAddress) {
        // () taking data from priceFeed
        i_owner = msg.sender; // przypisuje OWNER to address who deploy that contract
        priceFeed = AggregatorV3Interface(priceFeedAddress);
    }

    receive() external payable {
        fund();
    }

    fallback() external payable {
        fund();
    }

    /**
     *   @notice This function funds this contract
     *   @dev This implements price feeds as our library
     */

    function fund() public payable {
        //We want to be able to set minimum funding value
        // 1. How do we send eth to this contract
        require(
            msg.value.getConversionRate(priceFeed) >= MINIMUM_USD,
            "Didnt send enough"
        ); // 1e18 == 1 * 10 ** 18 == 1000000000000000000 = 1 eth
        // if you need to require something with revert use require
        funders.push(msg.sender);
        addressToAmountFunded[msg.sender] = msg.value;
    }

    function withdraw() public onlyOwner {
        // require(msg.sender == owner, "Sender is not owner");
        // for loop
        // [1, 2, 3, 4]
        //  0, 1, 2, 3  <- indexes
        // for(/* starting index, ending index, step amount */ )
        // 0, 10, 2 <- from 0 to 10 by 2 so: 0,2,4,6,8,10
        for (
            uint256 funderIndex = 0;
            funderIndex < funders.length;
            funderIndex++
        ) {
            address funder = funders[funderIndex];
            addressToAmountFunded[funder] = 0;
        }
        // reset array
        funders = new address[](0);
        //actually withdraw the funds
        (bool callSuccess, ) = payable(msg.sender).call{
            value: address(this).balance
        }("");
        require(callSuccess, "Call failed");
        // transfer method
        // msg.sender == address
        // payable(msg.sender) = payable
        // payable msg.sender.transfer(address(this).balance);
        // send method
        // bool sendSuccess = payable(msg.sender).send(address(this).balance);
        // require(sendSuccess, "Send failed");
        // call method <- RECOMMENDED METHOD
        // (bool callSuccess, ) = payable(msg.sender).call{value: address(this).balance}("");
        // require(callSuccess, "Call failed");
    }

    // Explainer from: https://solidity-by-example.org/fallback/
    // Ether is sent to contract
    //      is msg.data empty?
    //          /   \
    //         yes  no
    //         /     \
    //    receive()?  fallback()
    //     /   \
    //   yes   no
    //  /        \
    //receive()  fallback()
}

[alymurtazamemon]

@czilauto0r1 Are you testing on the Testnet network? if so then make sure you have 1 ETH in it because you specify 1 Eth as a value. Or you can lower your value, at this time 0.05 value of eth will work.

[alymurtazamemon]

@czilauto0r1 do other tests working? just run npx hardhat test.

[czilauto0r1]

first two are working, constructor and failing if you dont send enough eth. Then everywhere where I put fundMe.fund its failing with revert "didnt send enough eth" // and I have another question if I have for example that test:

        it("updated the amount funded data structure", async function () {
            await fundMe.fund({ value: sendValue })
            const response = await fundMe.addressToAmountFunded(deployer)
            assert.equal(response.toString(), sendValue.toString())
        })

when I add console.log("Send value is: ", sendValue.toString()) - I can see the value and its correct
when I add console.log("Response is: ", response.toString()) - I can't see value
my question is i'm doing something wrong? if you can explain that to me would be great.

        it("updated the amount funded data structure", async function () {
            console.log("Send value is: ", sendValue.toString())
            await fundMe.fund({ value: sendValue })
            const response = await fundMe.addressToAmountFunded(deployer)
            console.log("Response is: ", response.toString())
            assert.equal(response.toString(), sendValue.toString())
        })

[czilauto0r1]

ok third day with that error finally it passed. I went through whole code and in helper-hardhat-config.js there was
const INITIAL_ANSWER = 2000000000 so I changed to
const INITIAL_ANSWER = 200000000000 and its working. @ali-thegilfoyle thank you for your time really helpfull that was now I know more how to fix errors :)

[alymurtazamemon]

@czilauto0r1 Great! I spent a lot of time on your issue but could not see that. Ya, debugging is also a skill that we should learn to find bugs in our code. I remember I spent days for minor typo mistakes and that was really emotional testing of my patience level.

I am happy to see your issue resolved.

[Sairam002]

Hi @czilauto0r1 @alymurtazamemon , I tried changing the value of INITIAL_ANSWER but stilll getting the same error can you please help me!!!

My code

FundMe.sol

// SPDX-License-Identifier: MIT
// 1. Pragma
pragma solidity ^0.8.0;
// 2. Imports
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
import "./PriceConverter.sol";

// 3. Interfaces, Libraries, Contracts
// error FundMe__NotOwner();

/**@title A sample Funding Contract
 * @author Patrick Collins
 * @notice This contract is for creating a sample funding contract
 * @dev This implements price feeds as our library
 */
contract PatrickFundMe {
    // Type Declarations
    using PriceConverter for uint;

    // State variables
    uint public constant MINIMUM_USD = 50 * 10**18; // ethers.utils.parseEther("")
    address private immutable i_owner;
    address[] private s_funders;
    mapping(address => uint) public s_addressToAmountFunded;
    AggregatorV3Interface private s_priceFeed;

    // Events (we have none!)

    // Modifiers
    modifier onlyOwner() {
        require(msg.sender == i_owner);
        // if (msg.sender != i_owner){
        //     revert //FundMe__NotOwner;//();
        // }
        _;
    }

    // Functions Order:
    //// constructor
    //// receive
    //// fallback
    //// external
    //// public
    //// internal
    //// private
    //// view / pure

    constructor(address priceFeed) {
        s_priceFeed = AggregatorV3Interface(priceFeed);
        i_owner = msg.sender;
    }

    /// @notice Funds our contract based on the ETH/USD price
    function fund() public payable {
        require(
            msg.value.getConversionRate(s_priceFeed) >= MINIMUM_USD,
            "You need to spend more ETH!"
        );
        // require(PriceConverter.getConversionRate(msg.value) >= MINIMUM_USD, "You need to spend more ETH!");
        s_addressToAmountFunded[msg.sender] += msg.value;
        s_funders.push(msg.sender);
    }

    function withdraw() public payable onlyOwner {
        for (
            uint funderIndex = 0;
            funderIndex < s_funders.length;
            funderIndex++
        ) {
            address funder = s_funders[funderIndex];
            s_addressToAmountFunded[funder] = 0;
        }
        s_funders = new address[](0);
        // Transfer vs call vs Send
        // payable(msg.sender).transfer(address(this).balance);
        (bool success, ) = i_owner.call{value: address(this).balance}("");
        require(success);
    }

    function cheaperWithdraw() public payable onlyOwner {
        address[] memory funders = s_funders;
        // mappings can't be in memory, sorry!
        for (
            uint funderIndex = 0;
            funderIndex < funders.length;
            funderIndex++
        ) {
            address funder = funders[funderIndex];
            s_addressToAmountFunded[funder] = 0;
        }
        s_funders = new address[](0);
        // payable(msg.sender).transfer(address(this).balance);
        (bool success, ) = i_owner.call{value: address(this).balance}("");
        require(success);
    }

    // /** @notice Gets the amount that an address has funded
    //  *  @param fundingAddress the address of the funder
    //  *  @return the amount funded
    //  */
    // function getAddressToAmountFunded(address fundingAddress)
    //     public
    //     view
    //     returns (uint)
    // {
    //     return s_addressToAmountFunded[fundingAddress];
    //}

    function getVersion() public view returns (uint) {
        return s_priceFeed.version();
    }

    function getFunder(uint index) public view returns (address) {
        return s_funders[index];
    }

    function getOwner() public view returns (address) {
        return i_owner;
    }

    function getPriceFeed() public view returns (AggregatorV3Interface) {
        return s_priceFeed;
    }
}

helper hardhat config

const networkConfig = {
    4:{
        name: "rinkeby",
        ethPrice:"0x8A753747A1Fa494EC906cE90E9f37563A8AF630e",
    },
    42:{
        name:"koven",
        ethPrice:"0x9326BFA02ADD2366b30bacB125260Af641031331",
    }
}

const DECIMALS = 8;
const INITIAL_VALUE = 200000000000;


module.exports = {
    networkConfig,
    DECIMALS,
    INITIAL_VALUE
}

Price Converter

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

import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";

library PriceConverter {
    function getPrice(AggregatorV3Interface _priceFeed)
        public
        view
        returns (uint)
    {
        (, int price, , , ) = _priceFeed.latestRoundData();
        return uint(price);
    }

    function getConversionRate(uint ethAmount, AggregatorV3Interface _priceFeed)
        internal
        view
        returns (uint)
    {
        uint perEthPrice = getPrice(_priceFeed);
        uint PriceAfterConverting = (perEthPrice * ethAmount) /
            1000000000000000000;
        return PriceAfterConverting;
    }
}

hardhat config

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

/** @type import('hardhat/config').HardhatUserConfig */
module.exports = {
  solidity: {
    compilers:[{version:"0.8.0"},{version:"0.6.6"}],
  },
  namedAccounts:{
    deployer: {
      default:0,
    },
    user:{
      default: 0,
    }
  },
  networks:{
    rinkeby:{
      url: process.env.RinkebyRPC_URL,
      accounts:[process.env.PrivateKey,],
      chainId: 4
    }
  }
};

I need your help
please help me

[pyromaus]

Its a known issue, a lot of Discussions here have similar errors when calling Fund(). the transaction actually does go through in the background, while still throwing the error of "not enough ETH"
hopefully this will get fixed

[czilauto0r1]

so there is no way to test fund() function? // we can just test if transaction will fail if you send less then required amount of eth? others will fail too? // and the same thing happening with withdraw() so I think I made some mistake somewhere

[alymurtazamemon]

@czilauto0r1 @pyromaus It is not true, many people have tested that successfully, I am one of them. There could be many reasons behind showing this error so we cannot say that issue is with code.

[krakxn]

Firstly, check if there is a problem with your getConversionRate().

Also, the Fund function works fine for me, so it definitely can be fixed.

Copy paste this in FundMe.sol (you can change variable names as per your convention)

function fund() public payable {
        require(
            msg.value.getConversionRate(s_priceFeed) >= MINIMUM_USD,
            "You need to spend more ETH!"
        );
        s_addressToAmountFunded[msg.sender] += msg.value;
        s_funders.push(msg.sender);
    }

If the problem still persists, I would recommend cloning the repo (message/quote me if doubtful) and changing basic files such as hardhat config as per your choice. Let me know if this solves your problem, goodluck!