Lesson 7: Understanding interactions

[NotNotRama]

I'm currently doing the last part of this lesson where I'm making the interaction test files but I don't quite get what's going on here

InteractionTest.t.sol

contract InteractionsTest is Test {
    FundMe fundMe;

    address USER = makeAddr("user");
    uint256 constant SEND_VALUE = 0.1 ether;
    uint256 constant STARTING_BALANCE = 10 ether;
    uint256 constant GAS_PRICE = 1;

    function setUp() external {
        DeployFundMe deploy = new DeployFundMe();
        fundMe = deploy.run();
        vm.deal(USER, STARTING_BALANCE);
    }

    function testUserCanFundInteractions() public {
        FundFundMe fundFundMe = new FundFundMe();
        fundFundMe.fundFundMe(address(fundMe));

        WithdrawFundMe withdrawFundMe = new WithdrawFundMe();
        withdrawFundMe.withdrawFundMe(address(fundMe));

        assert(address(fundMe).balance == 0);
    }
}

Interactions.s.sol

contract FundFundMe is Script {
    uint256 constant SEND_VALUE = 0.1 ether;

    function fundFundMe(address mostRecentlyDeployed) public {
        vm.startBroadcast();
        FundMe(payable(mostRecentlyDeployed)).fund{value: SEND_VALUE}();
        vm.stopBroadcast();
    }

    function run() external {
        address mostRecentlyDeployed = DevOpsTools.get_most_recent_deployment(
            "FundMe",
            block.chainid
        );
        fundFundMe(mostRecentlyDeployed);
    }
}

contract WithdrawFundMe is Script {
    function withdrawFundMe(address mostRecentlyDeployed) public {
        vm.startBroadcast();
        FundMe(payable(mostRecentlyDeployed)).withdraw();
        vm.stopBroadcast();
    }

    function run() external {
        address mostRecentlyDeployed = DevOpsTools.get_most_recent_deployment(
            "FundMe",
            block.chainid
        );
        withdrawFundMe(mostRecentlyDeployed);
    }
}

In testUserCanFundInteractions, at the start I'm creating a new instance of FundFundMe correct? If that's the case, is it calling the run function when it's created?

And if that's the case, why am I calling the fundFundMe function again? fundFundMe.fundFundMe(address(fundMe));

Also, I'm having some trouble understanding what's exactly going on on this line: FundMe(payable(mostRecentlyDeployed)).fund{value: SEND_VALUE}();

Am I calling the FundMe contract and passing the address where I previously deployed it? And also, where does the ether come from? Is it from a dumme account from foundry?

[pacelliv]

Hello @NotNotRama

In testUserCanFundInteractions, at the start I'm creating a new instance of FundFundMe correct? If that's the case, is it calling the run function when it's created?

And if that's the case, why am I calling the fundFundMe function again? fundFundMe.fundFundMe(address(fundMe));

Yes, you're creating a new instance of FundFundMe, but it doesn't automatically call the run function, instead after the instance is created is calling the fundFundMe function and passing the address of the recently deployed FundMe contract.

The line FundMe(payable(mostRecentlyDeployed)).fund{value: SEND_VALUE}() means the following:

• You cast mostRecentlyDeployed as payable.
• then this address payable is casted to FundMe to create a pointer to the contract.
• and from that pointer you invoke the fund method to send ether to the contract.

If you check at the top of Interactions.s.sol you will find SEND_VALUE, the amount used to fund the contract.

[PatrickAlphaC]

Hello! Great question. And fantastic formatting on your question :)

We don't call run when we create fundFundMe. On this line, all we do is deploy a contract

FundFundMe fundFundMe = new FundFundMe();

This is where solidity scripting can be a bit confusing. In order for us to run the run function, we first have to deploy a contract. However, we don't even call the run function, we instead call fundFundMe in the next line.

fundFundMe.fundFundMe(address(fundMe));

We call fundFundMe because we didn't call run. Our run function does 2 things:

1. Gets the most recently deployed FundMe contract
2. Calls fundFundMe(address mostRecentlyDeployedFundMe)

However, in our tests, we just pass the FundMe contract address directly to fundFundMe. So, in this line:

FundMe(payable(mostRecentlyDeployed)).fund{value: SEND_VALUE}();

This is the line that actually calls the fund function on our FundMe contract. Let's break it down:

FundMe(payable(mostRecentlyDeployed))

We are saying:
Get me the FundMe contract at the mostRecentlyDeployed address, and make that address payable.

Then:

.fund{value: SEND_VALUE}();

This is saying "call the fund function with a msg.value of SEND_VALUE.

Does that make sense?

[NotNotRama]

First of all, thank you both @PatrickAlphaC and @pacelliv for taking the time to answer my questions on a saturday noon/night. Really appreaciate it :)

So if I get this right, this line is the one that deploys the FundFundMe contract FundFundMe fundFundMe = new FundFundMe();

Now the fundFundMe function will be either called within run with the mostRecentlyDeployed address or when we manually call it inside testUserCanFundInteractions (more specifically, on this line fundFundMe.fundFundMe(address(fundMe));). What I'm finding confusing is the purpose of the run function since I don't see it so far being called anywhere?

As for the last part, I noticed that the value sent to the fund function was SEND_VALUE, but what I was wondering is who exactly is passing that value to the contract. For example, I think it was on Remix where you would get a bunch of accounts, and then when you execute some function you would lose some ether because you spent it to execute said function. In this case, what's the account paying for fund?

Sorry if my questions are not clear enough!

[PatrickAlphaC]

So run is only called when we call the script from the command line, in our tests here, we actually never call it!

forge script path/to/your/file.sol

^ This is the command that will call run. In our tests we don't bother.

On your other question, this is where the "magic" of forge scripting happens. Whatever the private key is being used to run the test sends the value. In forge test, it magically creates some fake accounts for you that have value in them to start.

[NotNotRama]

Much clearer now, thanks!

[NotNotRama]

Sorry for reopening this issue, but I've come across another question. This time it's for the withdraw function.

    function testUserCanFundInteractions() public {
        console.log("fundMe owner: %s", fundMe.getOwner());
        console.log("address(fundMe): %s", address(fundMe));
        FundFundMe fundFundMe = new FundFundMe();
        fundFundMe.fundFundMe(address(fundMe));

        WithdrawFundMe withdrawFundMe = new WithdrawFundMe();
        withdrawFundMe.withdrawFundMe(address(fundMe));

        assert(address(fundMe).balance == 0);
    }

Iirc, withdraw can only be called by the owner of the contract and here we're calling it with the fundMe address, not the owner account. In fact, if I console log the fundMe owner and the fundMe contract address these two are different. But if I try to call withdraw with the owner I get an error. What'd be the reason of that behaviour?

[Elldees]

Hi,

You are right that the FundMe owner and the fundMe contract address are different and that withdraw() can only be called by the owner of the contract.

I'm also assuming that what you mean is that this produces an error?:

        WithdrawFundMe withdrawFundMe = new WithdrawFundMe();
        withdrawFundMe.withdrawFundMe(fundMe.getOwner()); 
//trying to use owner address to since it is specified in "FundMe.sol" that only the owner can withdraw funds

I think that we have to consider the path that we are going down when we call this function in our test and how it interacts with our scripts and contract.

When we call withdrawFundMe(address(fundMe)); in "InteractionsTest.t.sol" we are pointing to the "Interactions.s.sol" script:

contract FundFundMe is Script {
    uint256 constant SEND_VALUE = 0.1 ether;

    function fundFundMe(address mostRecentlyDeployed) public {
        vm.startBroadcast();
        FundMe(payable(mostRecentlyDeployed)).fund{value: SEND_VALUE}();
        vm.stopBroadcast();
    }

    function run() external {
        address mostRecentlyDeployed = DevOpsTools.get_most_recent_deployment(
            "FundMe",
            block.chainid
        );
        fundFundMe(mostRecentlyDeployed);
    }
}

contract WithdrawFundMe is Script {
    function withdrawFundMe(address mostRecentlyDeployed) public {
        vm.startBroadcast();
        FundMe(payable(mostRecentlyDeployed)).withdraw();
        vm.stopBroadcast();
    }

    function run() external {
        address mostRecentlyDeployed = DevOpsTools.get_most_recent_deployment(
            "FundMe",
            block.chainid
        );
        withdrawFundMe(mostRecentlyDeployed);
    }
}

This is what we're looking at:

 function withdrawFundMe(address mostRecentlyDeployed) public {
        vm.startBroadcast();
        FundMe(payable(mostRecentlyDeployed)).withdraw();
        vm.stopBroadcast();
    }

So the function withdrawFundMe(address mostRecentlyDeployed) takes the address variable mostRecentlyDeployed in other words it takes the address of the most recently deployed contract to call the withdraw() function on.

We are not pointing to the "FundMe.sol" withdraw() function directly in our test "InteractionsTest.t.sol" we are first going through the script "Interactions.s.sol" to get the most recent FundMe{} contract and then in our script using import {FundMe} we are also calling the withdraw() on the most recent FundMe{} contract all in that one function withdrawFundMe(address mostRecentlyDeployed) so it both finds the most recent FundMe contract and withdraws the Eth from it.

Correct: InteractionsTest.t.sol --> Interactions.s.sol( --> FundMe.sol withdraw()):

• Interactions.s.sol: the function there requires a contract address and it will also call the withdraw function once it has found the FundMe contract address.

• FundMe.sol withdraw(): We know that there is no need to put in a specific address as if the user trying to withdraw the funds is not the owner the function will revert so when we call with the owner address it will run.

Incorrect: InteractionsTest.t.sol --> FundMe.sol withdraw()

As an example:

When we try to pass this:

        WithdrawFundMe withdrawFundMe = new WithdrawFundMe();
        withdrawFundMe.withdrawFundMe(fundMe.getOwner()); 
//trying to use owner address to since it is specified in "FundMe.sol" that only the owner can withdraw funds

What we are saying is:

1. Create a new instance of the WithdrawFundMe{} called withdrawFundMe:

2. Using this new instance of the contract call the withdrawFundMe() function from "Interactions.s.sol".

3. However, this is where it goes wrong because instead of passing the contract address for FundMe into withdrawFundMe(address mostRecentlyDeployed we are passing the address of the deployer wallet.

4. So solidity is trying to find the most recent FundMe contract so that it can run the script and call that withdraw() function but we are instead passing it a public key (wallet address) and not a contract address and its saying hey there's no contract "FundMe" here, how am I meant to call this withdraw() function that is a part of the FundMe{} contract.

I hope that helps and makes sense this is my first time haha idk if it's right but it's how I understand it hopefully someone else can also chime in and give some input ^^.

Good luck with everything and let me know if I can make anything clearer for you!