Lesson 7: testWithdrawWithSingleFunder

[codeplay22]

when i run this test (testWithdrawWithSingleFunder)
How startingOwnerBalance is 79228162514264337593543950335? in testWithdrawWithSingleFunder

FundMeTest.t.sol

pragma solidity ^0.8.18;
import {Test,console} from "../../lib/forge-std/src/Test.sol";
import {FundMe} from "../../src/FundMe.sol";
import {DeployFundMe} from "../../script/DeployFundMe.s.sol";

contract FundMeTest is Test {
    uint256 number = 1;
    uint256 GAS_Price = 1;
    FundMe fundMe;
    address USER = makeAddr("user"); // making a fake address here 
    uint256 constant SEND_VALUE = 0.1 ether;
    uint256 constant STARTING_BALANCE = 10 ether;

    function setUp() external {
        // us -> FundMeTest -> FundMe
        DeployFundMe deployfundMe = new DeployFundMe();
        // fundMe = new FundMe(0x694AA1769357215DE4FAC081bf1f309aDC325306);
        fundMe = deployfundMe.run();
        vm.deal(USER,STARTING_BALANCE);
    }

    function testMinimumdollarisfive() public {

        assertEq(fundMe.MINIMUM_USD(), 5e18);

    }

    function testOwner() public {

        // console.log(fundMe.i_owner());
       // console.log(msg.sender);  // who ever is calling the FundMeTest
        // console.log(address(this)); // Gives me address of FundMeTest 
        assertEq(fundMe.getOwner(), msg.sender);
    }


    function testVersionIsAccurate() public {

        uint256 version =  fundMe.getVersion();
        console.log("version is",version);
        assertEq(version, 4);

    }

    function testFundFailsWithoutEnoughEth() public {
        vm.expectRevert();
        // console.log("this is the message after expectRevert call");
        fundMe.fund();
    }

    function  testFundUpdatesFundedDataStructure() public{
        vm.prank(USER); // The next TX will be sent by USER.
        fundMe.fund{value: SEND_VALUE }();

        uint256 amountFunded = fundMe.getAddressToAmountFunded(USER);
        console.log("amount funded is",amountFunded);
        assertEq(amountFunded, SEND_VALUE);
    }

    function testAddsFunderToArraysOfFunders() public {
        vm.prank(USER);
        fundMe.fund{value:SEND_VALUE}();

        address funder = fundMe.getFunder(0);
        assertEq(funder,USER);
    }

    modifier funded(){
        vm.prank(USER);
        fundMe.fund{value:SEND_VALUE}();
        _;
    }

    function testOnlyOwnerCanWithdraw () public funded {

        vm.expectRevert();
        vm.prank(USER);
        fundMe.withdraw();

    }

    function testWithdrawWithSingleFunder() public funded(){

        // Arrange
        uint256 startingOwnerBalance = fundMe.getOwner().balance; // i_owner startingOwnerBalance
        console.log("getowner 1st time",fundMe.getOwner());
        console.log("startingOwnerBalance is",startingOwnerBalance);
        uint256 startingFundMeBalance = address(fundMe).balance;
       
        console.log("startingFund me balance is",startingFundMeBalance);
        // Act
        // uint256 gasStart = gasleft();
        // vm.txGasPrice(GAS_Price);
        vm.prank(fundMe.getOwner());  // getowner == i_owner
        // console.log("getowner 2nd time",fundMe.getOwner());
        fundMe.withdraw();

        // uint256 gasEnd = gasleft(); 
        // uint256 gasUsed = (gasStart - gasEnd) * tx.gasprice;
        // console.log(gasUsed);

        // Assert

        uint256 endingOwnerBalance = fundMe.getOwner().balance;
        console.log("ending owner balance is",endingOwnerBalance);
        uint256 endingFundMeBalance = address(fundMe).balance;
        console.log("ending fund me balance is",endingFundMeBalance);
        assertEq(endingFundMeBalance,0);
        assertEq(startingFundMeBalance + startingOwnerBalance,endingOwnerBalance);

    }

    function testWithdrawfromMultipleFunders() public {
        //Arrange

        uint160 numberOfFunders = 10;
        uint160 startingFunderIndex = 1;
        for(uint160 i=startingFunderIndex;i<numberOfFunders;i++){
            hoax(address(i), SEND_VALUE);
            fundMe.fund{value:SEND_VALUE}();
        }

        uint256 startingOwnerBalance = fundMe.getOwner().balance;
        uint256 startingFundMeBalance = address(fundMe).balance;

        //Act
        vm.prank(fundMe.getOwner());
        fundMe.withdraw();

        //Assert
        assert(address(fundMe).balance == 0 );
        assert(startingFundMeBalance + startingOwnerBalance == fundMe.getOwner().balance);

    }

    function testWithdrawfromMultipleFundersCheaper() public {
        //Arrange

        uint160 numberOfFunders = 10;
        uint160 startingFunderIndex = 1;
        for(uint160 i=startingFunderIndex;i<numberOfFunders;i++){
            hoax(address(i), SEND_VALUE);
            fundMe.fund{value:SEND_VALUE}();
        }

        uint256 startingOwnerBalance = fundMe.getOwner().balance;
        uint256 startingFundMeBalance = address(fundMe).balance;

        //Act
        vm.prank(fundMe.getOwner());
        fundMe.cheaperWithdraw();

        //Assert
        assert(address(fundMe).balance == 0 );
        assert(startingFundMeBalance + startingOwnerBalance == fundMe.getOwner().balance);

    }


} 

DeployFundMe.s.sol

pragma solidity ^0.8.18;
import {Script} from "../../lib/forge-std/src/Script.sol";
import {FundMe} from "../src/FundMe.sol";
import {HelperConfig} from "./HelperConfig.s.sol";

contract DeployFundMe is Script{

    function run() external returns (FundMe){

        HelperConfig helperconfig = new HelperConfig();
        (address ethUsdPriceFeed) = helperconfig.activeNetworkConfig();
        vm.startBroadcast();
        FundMe fundMe  = new FundMe(ethUsdPriceFeed);
        vm.stopBroadcast();
        return fundMe;
        
    }
    
}  

FundMe.sol

pragma solidity ^0.8.18;

import {AggregatorV3Interface} from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
import {PriceConverter} from "./PriceConverter.sol";
// import {console} from "forge-std/Script.sol";
// import {console} from "../lib/forge-std/src/Script.sol";


error FundMe__NotOwner();

contract FundMe {
    
    using PriceConverter for uint256;

    mapping(address => uint256) private s_addressToAmountFunded;
    address[] private s_funders;
    
    // Could we make this constant?  /* hint: no! We should make it immutable! */
    address private /* immutable */ i_owner;
    uint256 public constant MINIMUM_USD = 5 * 10 ** 18;
    AggregatorV3Interface private s_priceFeed;
    
    constructor(address priceFeed) {

        i_owner = msg.sender;
        s_priceFeed = AggregatorV3Interface(priceFeed);

    }

    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 getVersion() public view returns (uint256){
        // console.log(s_priceFeed.version());
        return s_priceFeed.version();
    }
    
    modifier onlyOwner {
        // require(msg.sender == owner);
        if (msg.sender != i_owner) revert FundMe__NotOwner();
        _;
    }
    
    function cheaperWithdraw() public  onlyOwner {

        uint256 fundersLength = s_funders.length;
        for(uint256 funderIndex = 0; funderIndex < fundersLength; funderIndex++){

            address funder = s_funders[funderIndex];
            s_addressToAmountFunded[funder] = 0;
        }
        s_funders = new address[](0);
        (bool callSuccess, ) = payable(msg.sender).call{value: address(this).balance}("");
        require(callSuccess, "Call failed");
    } 

    function withdraw() public onlyOwner {
        for (uint256 funderIndex=0; funderIndex < s_funders.length; funderIndex++){
            address funder = s_funders[funderIndex];
            s_addressToAmountFunded[funder] = 0;
        }
        s_funders = new address[](0);
        // // transfer
        // payable(msg.sender).transfer(address(this).balance);
        
        // // send
        // bool sendSuccess = payable(msg.sender).send(address(this).balance);
        // require(sendSuccess, "Send failed");

        // call
        (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()

    fallback() external payable {
        fund();
    }

    receive() external payable {
        fund();
    }


function getAddressToAmountFunded(
    address fundingAddress
) external view returns (uint256){

    return s_addressToAmountFunded[fundingAddress];
}

function getFunder(uint256 index) external view returns(address) {
    return s_funders[index];
}

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


}


// Concepts we didn't cover yet (will cover in later sections)
// 1. Enum
// 2. Events
// 3. Try / Catch
// 4. Function Selector
// 5. abi.encode / decode
// 6. Hash with keccak256
// 7. Yul / Assembly


/**
 * View /Pure functions (Getters)
 */

This output comes

[PASS] testWithdrawWithSingleFunder() (gas: 92064)
Logs:
getowner 1st time 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38
startingOwnerBalance is 79228162514264337593543950335
startingFund me balance is 100000000000000000
ending owner balance is 79228162514364337593543950335
ending fund me balance is 0

How startingOwnerBalance is 79228162514264337593543950335?

[EngrPips]

Hey @codeplay22 please show your DeployFundeMe.s.sol script.

[codeplay22]

This is DeployFundMe.s.sol

pragma solidity ^0.8.18;
import {Script} from "../../lib/forge-std/src/Script.sol";
import {FundMe} from "../src/FundMe.sol";
import {HelperConfig} from "./HelperConfig.s.sol";

contract DeployFundMe is Script{

    function run() external returns (FundMe){

        HelperConfig helperconfig = new HelperConfig();
        (address ethUsdPriceFeed) = helperconfig.activeNetworkConfig();
        vm.startBroadcast();
        FundMe fundMe  = new FundMe(ethUsdPriceFeed);
        vm.stopBroadcast();
        return fundMe;
        
    }
    
}

[EngrPips]

Hey @codeplay22 , so i asked that you show me your DeployFundMe.s.sol so i can figure out who is the owner of the contract, what i have observed is whenever you put a transaction call between a vm.startBroadcast() and vm.stopBroadcast() foundry has a default address which it always use to send those transactions and that default address always have a default balance of 79228162514264337593543950335

So in your DeployFundMe.s.sol you placed the transaction that deploy your FundMe contract between vm.startBroadcast() and vm.stopBroadcast() so foundry would use the default address it uses to send transaction 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38 which then make it so the address is the owner of your FundMe contract , so when you check the balance of the owner of FundMe contract, you get back that huge value.

Tested it on my end it the same value

[codeplay22]

okay
Thanks!

[EngrPips]

Anytime friend

[lomrormaheshIITB]

@EngrPips Thanks, I have an issue in figuring out the i_owner of the fundMe contract. Your explanation helped me understand that.

[EngrPips]

Awesome, I am glad that helped you. Keep crushing it.