bug(`cheatcodes`): unexpected behavior when using `mockCall` for payable functions

[srdtrk]

Component

Forge

Have you ensured that all of these are up to date?

• Foundry
• Foundryup

What version of Foundry are you on?

forge Version: 1.2.3-nightly
Commit SHA: bfc53de
Build Timestamp: 2025-06-19T06:03:45.745585000Z (1750313025)
Build Profile: maxperf

What version of Foundryup are you on?

Installed via nix

What command(s) is the bug in?

forge test

Operating System

macOS (Apple Silicon)

Describe the bug

If the mock call simulates a payable function, then when the address is called, the call succeeds but the balance is not transferred.

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.28;

import { Test } from "forge-std/Test.sol";

contract MockCallBugTest is Test {
    function setUp() public { }

    function testMockCallBug() public {
        vm.deal(address(this), 1 ether);

        address target = makeAddr("target");
        uint256 value = 0.1 ether;
        bytes memory data = "someData";
        bytes memory resp = "mockedResponse";

        assertEq(target.balance, 0, "Initial balance should be zero");

        // Mock a call to the target address
        vm.mockCall(target, value, data, resp);

        // Make the call
        (bool success, bytes memory returnData) = target.call{value: value}(data);
        assertTrue(success, "Call should succeed");
        assertEq(returnData, resp, "Return data should match");

        // Check the target's balance after the call
        assertEq(target.balance, 0, "Target balance should NOT be zero after mock call");
        // BUG: This is a bug since the value is not transferred to the target but the call is not reverted.
        // should pass: assertEq(target.balance, value, "Target balance should NOT be zero after mock call");
    }

    function testRealCall() public {
        vm.deal(address(this), 1 ether);

        address target = address(new RealCallContract());
        uint256 value = 0.1 ether;
        bytes memory data = abi.encodeCall(RealCallContract.payableFunction, ());
        bytes memory resp = abi.encode("mockedResponse");

        assertEq(target.balance, 0, "Initial balance should be zero");

        // Make the real call
        (bool success, bytes memory returnData) = target.call{value: value}(data);
        assertTrue(success, "Call should succeed");
        assertEq(returnData, resp, "Return data should match");

        // Check the target's balance after the call
        assertEq(target.balance, value, "Target balance should be equal to the value sent");
    }
}

contract RealCallContract {
    function payableFunction() external payable returns (bytes memory) {
        return "mockedResponse";
    }
}

I don't know why this occurs. I have verified this behavior with slight variations:

• Making sure target has some code length. (vm.etch(target, "mock"))
• Casting target into a payable address

[grandizzy]

hey @srdtrk thank you, basically you're mocking only the target.call fn but not the target.balance one, erc20s can be mocked like in examples here https://getfoundry.sh/reference/cheatcodes/mock-call#examples but not eth balances. I guess that's something we could improve and update balances (but we're not doing atm), meanwhile you can workaround it by dealing same amount to target address

foundry/crates/cheatcodes/src/inspector.rs

Lines 768 to 782 in 0c3dc32

	if let Some(return_data) = if return_data_queue.len() == 1 {
	// If the mocked calls stack has a single element in it, don't empty it
	return_data_queue.front().map(|x| x.to_owned())
	} else {
	// Else, we pop the front element
	return_data_queue.pop_front()
	} {
	return Some(CallOutcome {
	result: InterpreterResult {
	result: return_data.ret_type,
	output: return_data.data,
	gas,
	},
	memory_offset: call.return_memory_offset.clone(),
	});

we can check here transfer value and update balances of call.transfer_from and call.transfer_to