[FAIL: panic: assertion failed (0x01)] testWithdrawFromMultipleFundersCheaper #3298

AnaAse · 2025-01-20T13:18:44Z

AnaAse
Jan 20, 2025

Good day!
Nothing less than PANIC, would you please bring some light?
(I would like to send my code in a different way I´ve seen other students doing it, not copy-paste)

Failing tests:
Encountered 1 failing test in test/FundMetest.t.sol:FundMeTest
[FAIL: panic: assertion failed (0x01)] testWithdrawFromMultipleFundersCheaper() (gas: 599132)

Encountered a total of 1 failing tests, 9 tests succeeded

FundMeTest:

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.18;

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

contract FundMeTest is Test {
FundMe fundMe;
address USER = makeAddr("user"); //we can use this user when we want to work with somebody
uint256 constant SEND_VALUE = 0.1 ether; // that makes it 100000000000000000
uint256 constant STARTING_BALANCE = 10 ether;
uint256 constant GAS_PRICE = 1;

function setUp() external {
// fundMe = new FundMe(0x106379F11C3cF4027C38655b79327081eA9C9Cf5); OJO este numero copiado del curso!!!
DeployFundMe deployFundMe = new DeployFundMe();
fundMe = deployFundMe.run();
vm.deal(USER, 100e18);
}
function testMinimumDollarFive() public view {
assertEq(fundMe.MINIMUM_USD(), 5e18);
}
function testOwnerIsMsgSender() public view {
assertEq(fundMe.getOwner(), msg.sender);

    //What can we do to work with addresses outside our system?
    // 1. Unit
    //   -Testing a specific part of our code
    // 2. Integration
    //   -Testing how our code works with other parts of our code
    // 3. Forked
    //   -Testing our code on a simulated real environment
    // 4. Staging
    //   - Testing our code in a real environment that is not production
}
function testPriceFeedVersionIsAccurate() public view{
    uint256 version = fundMe.getVersion();
    assertTrue(version == 4 || version == 6, "Version must be 4 or 6");
    // assertEq(version, 4);
}

function testFundFailsWithoutEnoughETH() public{
    vm.expectRevert(); //hey the next line should revert!!
    // assert (This tx fails/reverts)
    fundMe.fund(); //send with no value, 0 value
}

function testFundUpdatesFundedDataStructure() public {
    vm.prank(USER); // The next TX will be sent by USER... the following fundME.fund will be sent by USER
    fundMe.fund{value: SEND_VALUE}(); //vamos a enviar lo que hemos determinado arriba en una variable, mas que 5$
    uint256 amountFunded = fundMe.getAddressToAmountFunded(USER);
    assertEq(amountFunded, SEND_VALUE);

}

// reset everything every simgle time as it will run SetUp and then the function, again SetUp and the other function
function testAddsFunderToArrayOfFunders() 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}();
_;
}
// any test we write after the above modifier, if we add the funded
function testOnlyOwnerCanWithdraw() public funded{ //this funded comes from the modifier to avoid repeating code
vm.prank(USER);
vm.expectRevert();
fundMe.withdraw();
}

function testWithDrawWithASingleFunder() public funded{
    //Arrange . The test we are testing the withdraw at FundMe.sol. 
    // Before we have to see whats our balance before so that we can compare our balances after
    uint256 startingOwnerBalance = fundMe.getOwner().balance;
    uint256 startingFundMeBalance = address(fundMe).balance;

    // Act
    uint256 gasStart = gasleft();  //Lets say 1000, we had
    vm.txGasPrice(GAS_PRICE); // min 12:19
    vm.prank(fundMe.getOwner());  //c: 200, we spend
    fundMe.withdraw();

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

    // Assert
    uint256 endingOwnerBalance = fundMe.getOwner().balance;
    uint256 endingFundMeBalance = address(fundMe).balance;
    assertEq(endingFundMeBalance, 0);
    assertEq(startingFundMeBalance + startingOwnerBalance, endingOwnerBalance);
}
function testWithdrawFromMultipleFunders() public funded {
    // Arrange
    uint160 numberOfFunders = 10; //if you want to use number to generate addresses you must use uint160 instead of uint256
    uint160 startingFunderIndex = 1;
    //we create a loop
    for(uint160 i = startingFunderIndex; i < numberOfFunders; i++){
        // vm.prank new address
        // vm.deal new address
        // address (1) just dont use 0 address as often reverts
        hoax(address(i), SEND_VALUE);
        fundMe.fund{value: SEND_VALUE}();
    }

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

// Act
    vm.startPrank(fundMe.getOwner());
    fundMe.withdraw();
    vm.stopPrank();

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

function testWithdrawFromMultipleFundersCheaper() public funded {
    // Arrange
    uint160 numberOfFunders = 10; //if you want to use number to generate addresses you must use uint160 instead of uint256
    uint160 startingFunderIndex = 1;
    //we create a loop
    for(uint160 i = startingFunderIndex; i < numberOfFunders; i++){
        // vm.prank new address
        // vm.deal new address
        // address (1) just dont use 0 address as often reverts
        hoax(address(i), SEND_VALUE);
        fundMe.fund{value: SEND_VALUE}();
    }

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

// Act
    vm.startPrank(fundMe.getOwner());
    fundMe.cheaperWithdraw();
    vm.stopPrank();

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

}

FundMe.sol

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

// Note: The AggregatorV3Interface might be at a different location than what was in the video!
import {AggregatorV3Interface} from "@chainlink/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol";
import {PriceConverter} from "./PriceConverter.sol";

error FundMe__NotOwner();

contract FundMe {
using PriceConverter for uint256;

mapping(address => uint256) private s_addressToAmountFunded; //antes sin s_, ahora hemos añadido
address[] private s_funders;  //antes sin s_, ahora hemos añadido

// Could we make this constant?  /* hint: no! We should make it immutable! */
address private immutable i_owner;
uint256 public constant MINIMUM_USD = 5e18;
AggregatorV3Interface private s_priceFeed;

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

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

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

}

function getVersion() public view returns (uint256) {
    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; //meaning we´ll read it from storage once and then
    for (uint256 funderIndex = 0; funderIndex > fundersLength; funderIndex++){
        address funder = s_funders[funderIndex];
        s_addressToAmountFunded[funder] = 0;  //so we are going to loop from this array from for, reading from memory
    }
}

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

    (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();
}
/**
 * View / Pure functions are going to be our Getters
 */

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

EngrPips · 2025-01-20T13:32:48Z

EngrPips
Jan 20, 2025

Hello @AnaAse, Your assertion is wrong, so the best thing to do is use console.log in your test to print out the values you are using in your test and like that, you can see which value is weird and then find out why it is weird.

1 reply

EngrPips Jan 20, 2025

You can also run your test with the -vvvv flag and share the stack trace of your test process with us, and maybe like that, we can catch what is wrong.

AnaAse · 2025-01-20T17:15:32Z

AnaAse
Jan 20, 2025
Author

Anas-Laptop:foundry-fund-me-f23 ana$ forge snapshot -vvvv
[⠊] Compiling...
No files changed, compilation skipped

Ran 10 tests for test/FundMetest.t.sol:FundMeTest
[PASS] testAddsFunderToArrayOfFunders() (gas: 100130)
Traces:
[100130] FundMeTest::testAddsFunderToArrayOfFunders()
├─ [0] VM::prank(user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D])
│ └─ ← [Return]
├─ [81335] FundMe::fund{value: 100000000000000000}()
│ ├─ [8993] MockV3Aggregator::latestRoundData() [staticcall]
│ │ └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
│ └─ ← [Stop]
├─ [685] FundMe::getFunder(0) [staticcall]
│ └─ ← [Return] user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D]
├─ [0] VM::assertEq(user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D]) [staticcall]
│ └─ ← [Return]
└─ ← [Stop]

[PASS] testFundFailsWithoutEnoughETH() (gas: 23029)
Traces:
[23029] FundMeTest::testFundFailsWithoutEnoughETH()
├─ [0] VM::expectRevert(custom error 0xf4844814)
│ └─ ← [Return]
├─ [14884] FundMe::fund()
│ ├─ [8993] MockV3Aggregator::latestRoundData() [staticcall]
│ │ └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
│ └─ ← [Revert] revert: You need to spend more ETH!
└─ ← [Stop]

[PASS] testFundUpdatesFundedDataStructure() (gas: 99815)
Traces:
[99815] FundMeTest::testFundUpdatesFundedDataStructure()
├─ [0] VM::prank(user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D])
│ └─ ← [Return]
├─ [81335] FundMe::fund{value: 100000000000000000}()
│ ├─ [8993] MockV3Aggregator::latestRoundData() [staticcall]
│ │ └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
│ └─ ← [Stop]
├─ [495] FundMe::getAddressToAmountFunded(user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D]) [staticcall]
│ └─ ← [Return] 100000000000000000 [1e17]
├─ [0] VM::assertEq(100000000000000000 [1e17], 100000000000000000 [1e17]) [staticcall]
│ └─ ← [Return]
└─ ← [Stop]

[PASS] testMinimumDollarFive() (gas: 8499)
Traces:
[8499] FundMeTest::testMinimumDollarFive()
├─ [251] FundMe::MINIMUM_USD() [staticcall]
│ └─ ← [Return] 5000000000000000000 [5e18]
├─ [0] VM::assertEq(5000000000000000000 [5e18], 5000000000000000000 [5e18]) [staticcall]
│ └─ ← [Return]
└─ ← [Stop]

[PASS] testOnlyOwnerCanWithdraw() (gas: 100066)
Traces:
[100066] FundMeTest::testOnlyOwnerCanWithdraw()
├─ [0] VM::prank(user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D])
│ └─ ← [Return]
├─ [81335] FundMe::fund{value: 100000000000000000}()
│ ├─ [8993] MockV3Aggregator::latestRoundData() [staticcall]
│ │ └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
│ └─ ← [Stop]
├─ [0] VM::prank(user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D])
│ └─ ← [Return]
├─ [0] VM::expectRevert(custom error 0xf4844814)
│ └─ ← [Return]
├─ [270] FundMe::withdraw()
│ └─ ← [Revert] FundMe__NotOwner()
└─ ← [Stop]

[PASS] testOwnerIsMsgSender() (gas: 8509)
Traces:
[8509] FundMeTest::testOwnerIsMsgSender()
├─ [202] FundMe::getOwner() [staticcall]
│ └─ ← [Return] DefaultSender: [0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38]
├─ [0] VM::assertEq(DefaultSender: [0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38], DefaultSender: [0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38]) [staticcall]
│ └─ ← [Return]
└─ ← [Stop]

[PASS] testPriceFeedVersionIsAccurate() (gas: 14046)
Traces:
[14046] FundMeTest::testPriceFeedVersionIsAccurate()
├─ [5460] FundMe::getVersion() [staticcall]
│ ├─ [262] MockV3Aggregator::version() [staticcall]
│ │ └─ ← [Return] 6
│ └─ ← [Return] 6
├─ [0] VM::assertTrue(true, "Version must be 4 or 6") [staticcall]
│ └─ ← [Return]
└─ ← [Stop]

[PASS] testWithDrawWithASingleFunder() (gas: 88172)
Logs:
10764

Traces:
[115481] FundMeTest::testWithDrawWithASingleFunder()
├─ [0] VM::prank(user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D])
│ └─ ← [Return]
├─ [81335] FundMe::fund{value: 100000000000000000}()
│ ├─ [8993] MockV3Aggregator::latestRoundData() [staticcall]
│ │ └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
│ └─ ← [Stop]
├─ [202] FundMe::getOwner() [staticcall]
│ └─ ← [Return] DefaultSender: [0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38]
├─ [0] VM::txGasPrice(1)
│ └─ ← [Return]
├─ [202] FundMe::getOwner() [staticcall]
│ └─ ← [Return] DefaultSender: [0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38]
├─ [0] VM::prank(DefaultSender: [0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38])
│ └─ ← [Return]
├─ [8570] FundMe::withdraw()
│ ├─ [0] DefaultSender::fallback{value: 100000000000000000}()
│ │ └─ ← [Stop]
│ └─ ← [Stop]
├─ [0] console::log(10764 [1.076e4]) [staticcall]
│ └─ ← [Stop]
├─ [202] FundMe::getOwner() [staticcall]
│ └─ ← [Return] DefaultSender: [0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38]
├─ [0] VM::assertEq(0, 0) [staticcall]
│ └─ ← [Return]
├─ [0] VM::assertEq(79228162514364337593543950335 [7.922e28], 79228162514364337593543950335 [7.922e28]) [staticcall]
│ └─ ← [Return]
└─ ← [Stop]

[PASS] testWithdrawFromMultipleFunders() (gas: 488496)
Traces:
[615885] FundMeTest::testWithdrawFromMultipleFunders()
├─ [0] VM::prank(user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D])
│ └─ ← [Return]
├─ [81335] FundMe::fund{value: 100000000000000000}()
│ ├─ [8993] MockV3Aggregator::latestRoundData() [staticcall]
│ │ └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
│ └─ ← [Stop]
├─ [0] VM::deal(ECRecover: [0x0000000000000000000000000000000000000001], 100000000000000000 [1e17])
│ └─ ← [Return]
├─ [0] VM::prank(ECRecover: [0x0000000000000000000000000000000000000001])
│ └─ ← [Return]
├─ [46935] FundMe::fund{value: 100000000000000000}()
│ ├─ [993] MockV3Aggregator::latestRoundData() [staticcall]
│ │ └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
│ └─ ← [Stop]
├─ [0] VM::deal(SHA-256: [0x0000000000000000000000000000000000000002], 100000000000000000 [1e17])
│ └─ ← [Return]
├─ [0] VM::prank(SHA-256: [0x0000000000000000000000000000000000000002])
│ └─ ← [Return]
├─ [46935] FundMe::fund{value: 100000000000000000}()
│ ├─ [993] MockV3Aggregator::latestRoundData() [staticcall]
│ │ └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
│ └─ ← [Stop]
├─ [0] VM::deal(RIPEMD-160: [0x0000000000000000000000000000000000000003], 100000000000000000 [1e17])
│ └─ ← [Return]
├─ [0] VM::prank(RIPEMD-160: [0x0000000000000000000000000000000000000003])
│ └─ ← [Return]
├─ [46935] FundMe::fund{value: 100000000000000000}()
│ ├─ [993] MockV3Aggregator::latestRoundData() [staticcall]
│ │ └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
│ └─ ← [Stop]
├─ [0] VM::deal(Identity: [0x0000000000000000000000000000000000000004], 100000000000000000 [1e17])
│ └─ ← [Return]
├─ [0] VM::prank(Identity: [0x0000000000000000000000000000000000000004])
│ └─ ← [Return]
├─ [46935] FundMe::fund{value: 100000000000000000}()
│ ├─ [993] MockV3Aggregator::latestRoundData() [staticcall]
│ │ └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
│ └─ ← [Stop]
├─ [0] VM::deal(ModExp: [0x0000000000000000000000000000000000000005], 100000000000000000 [1e17])
│ └─ ← [Return]
├─ [0] VM::prank(ModExp: [0x0000000000000000000000000000000000000005])
│ └─ ← [Return]
├─ [46935] FundMe::fund{value: 100000000000000000}()
│ ├─ [993] MockV3Aggregator::latestRoundData() [staticcall]
│ │ └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
│ └─ ← [Stop]
├─ [0] VM::deal(ECAdd: [0x0000000000000000000000000000000000000006], 100000000000000000 [1e17])
│ └─ ← [Return]
├─ [0] VM::prank(ECAdd: [0x0000000000000000000000000000000000000006])
│ └─ ← [Return]
├─ [46935] FundMe::fund{value: 100000000000000000}()
│ ├─ [993] MockV3Aggregator::latestRoundData() [staticcall]
│ │ └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
│ └─ ← [Stop]
├─ [0] VM::deal(ECMul: [0x0000000000000000000000000000000000000007], 100000000000000000 [1e17])
│ └─ ← [Return]
├─ [0] VM::prank(ECMul: [0x0000000000000000000000000000000000000007])
│ └─ ← [Return]
├─ [46935] FundMe::fund{value: 100000000000000000}()
│ ├─ [993] MockV3Aggregator::latestRoundData() [staticcall]
│ │ └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
│ └─ ← [Stop]
├─ [0] VM::deal(ECPairing: [0x0000000000000000000000000000000000000008], 100000000000000000 [1e17])
│ └─ ← [Return]
├─ [0] VM::prank(ECPairing: [0x0000000000000000000000000000000000000008])
│ └─ ← [Return]
├─ [46935] FundMe::fund{value: 100000000000000000}()
│ ├─ [993] MockV3Aggregator::latestRoundData() [staticcall]
│ │ └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
│ └─ ← [Stop]
├─ [0] VM::deal(Blake2F: [0x0000000000000000000000000000000000000009], 100000000000000000 [1e17])
│ └─ ← [Return]
├─ [0] VM::prank(Blake2F: [0x0000000000000000000000000000000000000009])
│ └─ ← [Return]
├─ [46935] FundMe::fund{value: 100000000000000000}()
│ ├─ [993] MockV3Aggregator::latestRoundData() [staticcall]
│ │ └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
│ └─ ← [Stop]
├─ [202] FundMe::getOwner() [staticcall]
│ └─ ← [Return] DefaultSender: [0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38]
├─ [202] FundMe::getOwner() [staticcall]
│ └─ ← [Return] DefaultSender: [0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38]
├─ [0] VM::startPrank(DefaultSender: [0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38])
│ └─ ← [Return]
├─ [16139] FundMe::withdraw()
│ ├─ [0] DefaultSender::fallback{value: 1000000000000000000}()
│ │ └─ ← [Stop]
│ └─ ← [Stop]
├─ [0] VM::stopPrank()
│ └─ ← [Return]
├─ [202] FundMe::getOwner() [staticcall]
│ └─ ← [Return] DefaultSender: [0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38]
└─ ← [Stop]

[FAIL: panic: assertion failed (0x01)] testWithdrawFromMultipleFundersCheaper() (gas: 599132)
Traces:
[2904808] FundMeTest::setUp()
├─ [1456817] → new DeployFundMe@0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f
│ └─ ← [Return] 7166 bytes of code
├─ [1405813] DeployFundMe::run()
│ ├─ [905989] → new HelperConfig@0x104fBc016F4bb334D775a19E8A6510109AC63E00
│ │ ├─ [0] VM::startBroadcast()
│ │ │ └─ ← [Return]
│ │ ├─ [377261] → new MockV3Aggregator@0x34A1D3fff3958843C43aD80F30b94c510645C316
│ │ │ └─ ← [Return] 1107 bytes of code
│ │ ├─ [0] VM::stopBroadcast()
│ │ │ └─ ← [Return]
│ │ └─ ← [Return] 2240 bytes of code
│ ├─ [359] HelperConfig::activeNetworkConfig() [staticcall]
│ │ └─ ← [Return] MockV3Aggregator: [0x34A1D3fff3958843C43aD80F30b94c510645C316]
│ ├─ [0] VM::startBroadcast()
│ │ └─ ← [Return]
│ ├─ [432448] → new FundMe@0x90193C961A926261B756D1E5bb255e67ff9498A1
│ │ └─ ← [Return] 2048 bytes of code
│ ├─ [0] VM::stopBroadcast()
│ │ └─ ← [Return]
│ └─ ← [Return] FundMe: [0x90193C961A926261B756D1E5bb255e67ff9498A1]
├─ [0] VM::deal(user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], 100000000000000000000 [1e20])
│ └─ ← [Return]
└─ ← [Stop]

[599132] FundMeTest::testWithdrawFromMultipleFundersCheaper()
├─ [0] VM::prank(user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D])
│ └─ ← [Return]
├─ [81335] FundMe::fund{value: 100000000000000000}()
│ ├─ [8993] MockV3Aggregator::latestRoundData() [staticcall]
│ │ └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
│ └─ ← [Stop]
├─ [0] VM::deal(ECRecover: [0x0000000000000000000000000000000000000001], 100000000000000000 [1e17])
│ └─ ← [Return]
├─ [0] VM::prank(ECRecover: [0x0000000000000000000000000000000000000001])
│ └─ ← [Return]
├─ [46935] FundMe::fund{value: 100000000000000000}()
│ ├─ [993] MockV3Aggregator::latestRoundData() [staticcall]
│ │ └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
│ └─ ← [Stop]
├─ [0] VM::deal(SHA-256: [0x0000000000000000000000000000000000000002], 100000000000000000 [1e17])
│ └─ ← [Return]
├─ [0] VM::prank(SHA-256: [0x0000000000000000000000000000000000000002])
│ └─ ← [Return]
├─ [46935] FundMe::fund{value: 100000000000000000}()
│ ├─ [993] MockV3Aggregator::latestRoundData() [staticcall]
│ │ └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
│ └─ ← [Stop]
├─ [0] VM::deal(RIPEMD-160: [0x0000000000000000000000000000000000000003], 100000000000000000 [1e17])
│ └─ ← [Return]
├─ [0] VM::prank(RIPEMD-160: [0x0000000000000000000000000000000000000003])
│ └─ ← [Return]
├─ [46935] FundMe::fund{value: 100000000000000000}()
│ ├─ [993] MockV3Aggregator::latestRoundData() [staticcall]
│ │ └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
│ └─ ← [Stop]
├─ [0] VM::deal(Identity: [0x0000000000000000000000000000000000000004], 100000000000000000 [1e17])
│ └─ ← [Return]
├─ [0] VM::prank(Identity: [0x0000000000000000000000000000000000000004])
│ └─ ← [Return]
├─ [46935] FundMe::fund{value: 100000000000000000}()
│ ├─ [993] MockV3Aggregator::latestRoundData() [staticcall]
│ │ └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
│ └─ ← [Stop]
├─ [0] VM::deal(ModExp: [0x0000000000000000000000000000000000000005], 100000000000000000 [1e17])
│ └─ ← [Return]
├─ [0] VM::prank(ModExp: [0x0000000000000000000000000000000000000005])
│ └─ ← [Return]
├─ [46935] FundMe::fund{value: 100000000000000000}()
│ ├─ [993] MockV3Aggregator::latestRoundData() [staticcall]
│ │ └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
│ └─ ← [Stop]
├─ [0] VM::deal(ECAdd: [0x0000000000000000000000000000000000000006], 100000000000000000 [1e17])
│ └─ ← [Return]
├─ [0] VM::prank(ECAdd: [0x0000000000000000000000000000000000000006])
│ └─ ← [Return]
├─ [46935] FundMe::fund{value: 100000000000000000}()
│ ├─ [993] MockV3Aggregator::latestRoundData() [staticcall]
│ │ └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
│ └─ ← [Stop]
├─ [0] VM::deal(ECMul: [0x0000000000000000000000000000000000000007], 100000000000000000 [1e17])
│ └─ ← [Return]
├─ [0] VM::prank(ECMul: [0x0000000000000000000000000000000000000007])
│ └─ ← [Return]
├─ [46935] FundMe::fund{value: 100000000000000000}()
│ ├─ [993] MockV3Aggregator::latestRoundData() [staticcall]
│ │ └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
│ └─ ← [Stop]
├─ [0] VM::deal(ECPairing: [0x0000000000000000000000000000000000000008], 100000000000000000 [1e17])
│ └─ ← [Return]
├─ [0] VM::prank(ECPairing: [0x0000000000000000000000000000000000000008])
│ └─ ← [Return]
├─ [46935] FundMe::fund{value: 100000000000000000}()
│ ├─ [993] MockV3Aggregator::latestRoundData() [staticcall]
│ │ └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
│ └─ ← [Stop]
├─ [0] VM::deal(Blake2F: [0x0000000000000000000000000000000000000009], 100000000000000000 [1e17])
│ └─ ← [Return]
├─ [0] VM::prank(Blake2F: [0x0000000000000000000000000000000000000009])
│ └─ ← [Return]
├─ [46935] FundMe::fund{value: 100000000000000000}()
│ ├─ [993] MockV3Aggregator::latestRoundData() [staticcall]
│ │ └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
│ └─ ← [Stop]
├─ [202] FundMe::getOwner() [staticcall]
│ └─ ← [Return] DefaultSender: [0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38]
├─ [202] FundMe::getOwner() [staticcall]
│ └─ ← [Return] DefaultSender: [0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38]
├─ [0] VM::startPrank(DefaultSender: [0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38])
│ └─ ← [Return]
├─ [365] FundMe::cheaperWithdraw()
│ └─ ← [Stop]
├─ [0] VM::stopPrank()
│ └─ ← [Return]
└─ ← [Revert] panic: assertion failed (0x01)

Suite result: FAILED. 9 passed; 1 failed; 0 skipped; finished in 10.75ms (7.53ms CPU time)

Ran 1 test suite in 702.61ms (10.75ms CPU time): 9 tests passed, 1 failed, 0 skipped (10 total tests)

Failing tests:
Encountered 1 failing test in test/FundMetest.t.sol:FundMeTest
[FAIL: panic: assertion failed (0x01)] testWithdrawFromMultipleFundersCheaper() (gas: 599132)

Encountered a total of 1 failing tests, 9 tests succeeded
Anas-Laptop:foundry-fund-me-f23 ana$

0 replies

AnaAse · 2025-01-20T22:10:38Z

AnaAse
Jan 20, 2025
Author

I used the console.log. but Im getting the same:
Failing tests:
Encountered 1 failing test in test/FundMetest.t.sol:FundMeTest
[FAIL: panic: assertion failed (0x01)] testWithdrawFromMultipleFundersCheaper() (gas: 605855)

Encountered a total of 1 failing tests, 9 tests succeeded

function testWithdrawFromMultipleFundersCheaper() public funded {
// Arrange
uint160 numberOfFunders = 10; //if you want to use number to generate addresses you must use uint160 instead of uint256
uint160 startingFunderIndex = 1;
//we create a loop
for(uint160 i = startingFunderIndex; i < numberOfFunders; i++){
// vm.prank new address
// vm.deal new address
// address (1) just dont use 0 address as often reverts
hoax(address(i), SEND_VALUE);
fundMe.fund{value: SEND_VALUE}();
}

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

// Debugging: Log balances before withdrawal
    console.log("Starting Owner Balance: ", startingOwnerBalance);
    console.log("Starting FundMe Balance: ", startingFundMeBalance);

// Act
    vm.startPrank(fundMe.getOwner());
    fundMe.cheaperWithdraw();
    vm.stopPrank();
// Debugging: Log balances after withdrawal
console.log("Final Owner Balance: ", fundMe.getOwner().balance);
console.log("Final FundMe Balance: ", address(fundMe).balance);



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

}

9 replies

AnaAse Jan 21, 2025
Author

Ok, yes... I had a > instead of <...

Now, this passed:

function cheaperWithdraw() public onlyOwner {
uint256 fundersLength = s_funders.length; // Cache the length of the array
for (uint256 funderIndex = 0; funderIndex < fundersLength; funderIndex++) {
address funder = s_funders[funderIndex];
s_addressToAmountFunded[funder] = 0; // Reset the funding amount for each funder
}
// Clear the funders array after processing
delete s_funders;

// Transfer all funds to the owner
(bool success, ) = payable(i_owner).call{value: address(this).balance}("");
require(success, "Transfer failed");

}

AnaAse Jan 21, 2025
Author

Still, I just verify now that the testWithDrawFromMultipleFundersCheaper gas is actually higher than testWithDrawFromMultipleFunders.

Ran 10 tests for test/FundMetest.t.sol:FundMeTest
[PASS] testAddsFunderToArrayOfFunders() (gas: 100130)
[PASS] testFundFailsWithoutEnoughETH() (gas: 23029)
[PASS] testFundUpdatesFundedDataStructure() (gas: 99815)
[PASS] testMinimumDollarFive() (gas: 8499)
[PASS] testOnlyOwnerCanWithdraw() (gas: 100066)
[PASS] testOwnerIsMsgSender() (gas: 8509)
[PASS] testPriceFeedVersionIsAccurate() (gas: 14046)
[PASS] testWithDrawWithASingleFunder() (gas: 88172)
[PASS] testWithdrawFromMultipleFunders() (gas: 488496)
[PASS] testWithdrawFromMultipleFundersCheaper() (gas: 493037)
Suite result: ok. 10 passed; 0 failed; 0 skipped; finished in 8.45ms (3.96ms CPU time)

EngrPips Jan 21, 2025

Everything works fine now, correct?

AnaAse Jan 21, 2025
Author

The code works and passes fine, but the Cheaper function actually demands more gas 493037. vs. 488496. Why did we create an extra function when in the end it costs us more?

EngrPips Jan 21, 2025

I am unsure why it demanded more gas but check that you didn't add some extra computation that Patrick cheaperWithdraw function didn't have

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

[FAIL: panic: assertion failed (0x01)] testWithdrawFromMultipleFundersCheaper #3298

{{title}}

Replies: 3 comments 10 replies

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

Select a reply

[FAIL: panic: assertion failed (0x01)] testWithdrawFromMultipleFundersCheaper #3298

AnaAse Jan 20, 2025

Replies: 3 comments · 10 replies

EngrPips Jan 20, 2025

EngrPips Jan 20, 2025

AnaAse Jan 20, 2025 Author

AnaAse Jan 20, 2025 Author

AnaAse Jan 21, 2025 Author

AnaAse Jan 21, 2025 Author

EngrPips Jan 21, 2025

AnaAse Jan 21, 2025 Author

EngrPips Jan 21, 2025

AnaAse
Jan 20, 2025

Replies: 3 comments 10 replies

EngrPips
Jan 20, 2025

AnaAse
Jan 20, 2025
Author

AnaAse
Jan 20, 2025
Author

AnaAse Jan 21, 2025
Author

AnaAse Jan 21, 2025
Author

AnaAse Jan 21, 2025
Author