Lesson 4: Remix Fund Me - Not withdrawing all the contracts

[EzeCerino]

Hey everyone, I just realize something that I want to share and I want to know if am I correct.
During the Remix Fund Me video, around 5h05m, @PatrickAlphaC call the withdraw function but he only fund that with just one account. As the the call function was not inside the loop it's only withdrawing to the owner of the contract.
It's that correct or did I miss something. I quickly heck the code on the repo and seems to be the same as the one during the 5h05m o f the video.

Let me share screenshots:
Note that I change my code to 5 usd minimum because I have not enough eth from the Rinkeby Faucet.

This is the balance for the account 1 (the owner) after deploying the contract: 0.2541 eth

After doing the first fund of 5 usd (0.06 eth at the time) : 0.2478 eth

Balance of the account 2 after doing the fund with that address (not the owner): 0.0335 eth
I'm sorry, i have missed the screenshot before funding.

Both account after the withdrawal: Account 1 balance=0.2597 / Account 2 balance = 0.0035

If you look at the ether scan of the contract, the withdraw creates only one transaction. This is the address of the contract for you to check: 0x8d72C0061c27EA74B9F42b299c9D40d1a0569E27

Leave you my code for you to check if I did something wrong, please let me know:

//SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./PriceConverter.sol";

contract FundeMe {

    using PriceConverter for uint256;

    uint256 public minimumUSD = 5 * 1e18;
    address[] public founders;
    mapping(address => uint256) public foundersToAmount;

    address public owner;

    constructor(){
        owner = msg.sender;
    }

    function fund() public payable {
        require(msg.value.getConversionRate() >= minimumUSD, "Did not sent enougth");
        founders.push(msg.sender);
        foundersToAmount[msg.sender]=msg.value;
    }

    function withdraw() public onlyOwner{
        for(uint256 index = 0; index < founders.length; index++){
            address founder = founders[index];
            foundersToAmount[founder] = 0;
        }

        founders = new address[](0);
        (bool callSuccess, )= payable(msg.sender).call{value: address(this).balance}("");
        require(callSuccess,"Call Failed");

    }

    modifier onlyOwner {
        require(msg.sender == owner, "Only Owner can call this fuction");
        _;
    }

}

So, I tried to fix this this way:

    function withdraw() public onlyOwner{
        for(uint256 index = 0; index < founders.length; index++){
            address founder = founders[index];
            (bool callSuccess, )= payable(founder).call{value: foundersToAmount[founder]}("");
            require(callSuccess,"Call Failed");
            foundersToAmount[founder] = 0;
        }

        founders = new address[](0);
        //(bool callSuccess, )= payable(msg.sender).call{value: address(this).balance}("");
        //require(callSuccess,"Call Failed");

    }

It creates 2 transaction on the withdraw function but the thing is that I'm not seeing reflected the withdrawal into my account 2 balance.

This is the contract with the modifications.: 0x7A9d8875AA21D624F856d5D7Fc3bC1A80f711DA7
An this is the withdrawal TX:

Please let me know if I'm doing something wrong here.
It's an amazing course by the way, congratulation to @PatrickAlphaC !!

[alymurtazamemon]

@EzeCerino See the actual code was correct, what it was doing that resetting the array and mapping and after that at the end withdrawing the amount into the owner of the contract.

But what you are doing, is that you are withdrawing to each individual account and at the end, the contract has not left anything to be withdrawn to the owner account.

Ask me any questions if you still have queries.

[EzeCerino]

@ali-thegilfoyle thanks for the quick reply. To be honest I did not fully understand you. The fist code is the one that I made following the course video. The second one is the one that I try to fix. Neither of both codes are working properly, according to my point of view. Let me elaborate a bit more.

I'm assuming that the goal of the withdraw function is give back the funds to every founder. So, I test the contract on the testnet and this is what happen:

First code in my question (following the video), this is what is happening:
I create the contract with account 1. I fund the contract with account 1 and 2. Then I call withdraw function with account 1 (the owner).
What is happening is that all the funds go from the contract to the account 1. Only 1 transaction from the contract to account 1 is created and reflected on etherscan.

Second code, moving the sending eth line inside the loop:
Same, I create the contract with account 1. I fund the contract with account 1 and 2. Then I call withdraw function with account 1 (the owner).
What is happening is that the contract actually creates 2 transactions from the contract to the 2 accounts BUT, I can only see the balance changing on account 1. It like the funds get lost somewhere.

Thanks again!

[alymurtazamemon]

@EzeCerino The goal of this contract is to withdraw funds to only a single account. (Owner).

[EzeCerino]

Okay, if that's the goal of the contract the code along the course is correct.
But if the goal were to withdraw funds to every founder, is my second code correct? Why I am not seeing the balance changing on my account 2.
I really appreciate your time here!

[mattjaf]

dude dont update your balance at the end of the transaction, that is a major security risk
you want the message call at the very end of the function.

[EzeCerino]

Hey @mattjaf could you elaborate a bit more?