Solidity：接收 ETH

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

contract PayableExample {
    address payable public owner;

    // 合约初始化时可以接收ETH
    constructor() payable {
        owner = payable(msg.sender);
    }

    // 查询合约所有者账户下的余额
    function getBalance() public view returns (uint256) {
        return owner.balance;
    }

    // 函数用于向此合约存入Ether。
    // 调用此函数并附带一些Ether。
    // 此合约的余额将自动更新。
    function deposit1() public payable {}

    // 调用此函数并附带一些Ether。
    // 由于此函数不是可支付的，函数将抛出错误。
    // transact to PayableExample.deposit2 errored: Error occurred: revert.

    // revert
    // 	The transaction has been reverted to the initial state.
    // Note: The called function should be payable if you send value and the value you send should be less than your current balance.
    // You may want to cautiously increase the gas limit if the transaction went out of gas.
    function deposit2() public {}

    // 将余额全部发送给合约所有者
    function withdraw() public {
        // 获取存储在此合约中的Ether数量
        uint256 amount = address(this).balance;

        // 将所有Ether发送给所有者
        (bool success, ) = owner.call{value: amount}("");
        require(success, "Failed to send Ether");
    }
}

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

contract MyContract {
    // Event to emit when Ether is received
    event Received(address sender, uint amount);

    // Function to receive Ether. msg.data must be empty
    receive() external payable {
        // Emit the Received event when Ether is received
        emit Received(msg.sender, msg.value);
    }
}

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

// 函数调用关系：TestFallbackInputOutput -> FallbackInputOutput -> Counter
contract FallbackInputOutput {
    address immutable target;

    constructor(address _target) {
        target = _target;
    }

    fallback(bytes calldata data) external payable returns (bytes memory) {
        (bool ok, bytes memory res) = target.call{value: msg.value}(data);
        require(ok, "call failed");
        return res;
    }
}

contract Counter {
    uint256 public count;

    function get() external view returns (uint256) {
        return count;
    }

    function inc() external returns (uint256) {
        count += 1;
        return count;
    }
}

contract TestFallbackInputOutput {
    event Log(bytes res);

    function test(address _fallback, bytes calldata data) external {
        (bool ok, bytes memory res) = _fallback.call(data);
        require(ok, "call failed");
        emit Log(res);
    }

    function getTestData() external pure returns (bytes memory, bytes memory) {
        return
            (abi.encodeCall(Counter.get, ()), abi.encodeCall(Counter.inc, ()));
    }
}