眼见不一定为实 —— EVM CALL OPcode 中的 gas 陷阱

function finalizeWithdrawalTransaction(Types.WithdrawalTransaction memory _tx) external {
    ...

    bytes32 withdrawalHash = Hashing.hashWithdrawal(_tx);

    // Check that this withdrawal has not already been finalized, this is replay protection.
    require(
        finalizedWithdrawals[withdrawalHash] == false,
        "OptimismPortal: withdrawal has already been finalized"
    );

    // Mark the withdrawal as finalized so it can't be replayed.
    finalizedWithdrawals[withdrawalHash] = true;

    // We want to maintain the property that the amount of gas supplied to the call to the
    // target contract is at least the gas limit specified by the user. We can do this by
    // enforcing that, at this point in time, we still have gaslimit + buffer gas available.
    require(
        gasleft() >= _tx.gasLimit + FINALIZE_GAS_BUFFER,
        "OptimismPortal: insufficient gas to finalize withdrawal"
    );

    // Set the l2Sender so contracts know who triggered this withdrawal on L2.
    l2Sender = _tx.sender;
    bool success = SafeCall.call(
        _tx.target,
        gasleft() - FINALIZE_GAS_BUFFER,
        _tx.value,
        _tx.data
    );

    ...
}

library SafeCall {
    function call(
        address _target,
        uint256 _gas,
        uint256 _value,
        bytes memory _calldata
    ) internal returns (bool) {
        bool _success;
        assembly {
            _success := call(
                _gas, // gas
                _target, // recipient
                _value, // ether value
                add(_calldata, 0x20), // inloc
                mload(_calldata), // inlen
                0, // outloc
                0 // outlen
            )
        }
        return _success;
    }
}

require(gasleft() >= _tx.gasLimit + FINALIZE_GAS_BUFFER + 5_122); // Add more on gas buffer

func opCall(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
    stack := scope.Stack
    // Pop gas. The actual gas in interpreter.evm.callGasTemp.
    // We can use this as a temporary value
    temp := stack.pop()
    gas := interpreter.evm.callGasTemp
    // Pop other call parameters.
    addr, value, inOffset, inSize, retOffset, retSize := stack.pop(), stack.pop(), stack.pop(), stack.pop(), stack.pop(), stack.pop()
    toAddr := common.Address(addr.Bytes20())

    ...

    ret, returnGas, err := interpreter.evm.Call(scope.Contract, toAddr, args, gas, bigVal)

    ...

    return ret, nil
}

func gasCall(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) {
    ...
    evm.callGasTemp, err = callGas(evm.chainRules.IsEIP150, contract.Gas, gas, stack.Back(0))
    ...
    return gas, nil
}

// callGas returns the actual gas cost of the call.
//
// The cost of gas was changed during the homestead price change HF.
// As part of EIP 150 (TangerineWhistle), the returned gas is gas - base * 63 / 64.
func callGas(isEip150 bool, availableGas, base uint64, callCost *uint256.Int) (uint64, error) {
    if isEip150 {
        availableGas = availableGas - base
        gas := availableGas - availableGas/64
        // If the bit length exceeds 64 bit we know that the newly calculated "gas" for EIP150
        // is smaller than the requested amount. Therefore we return the new gas instead
        // of returning an error.
        if !callCost.IsUint64() || gas < callCost.Uint64() {
            return gas, nil
        }
    }
    if !callCost.IsUint64() {
        return 0, ErrGasUintOverflow
    }

    return callCost.Uint64(), nil
}

function finalizeWithdrawalTransaction(Types.WithdrawalTransaction memory _tx) external {
    ...
    require(
        gasleft() >= _tx.gasLimit + FINALIZE_GAS_BUFFER,
        "OptimismPortal: insufficient gas to finalize withdrawal"
    );

    ...

    bool success = SafeCall.call(
        _tx.target,
        gasleft() - FINALIZE_GAS_BUFFER,
        _tx.value,
        _tx.data
    );
    ...
}

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

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

library SafeCall {
    /**
     * @notice Perform a low level call without copying any returndata
     *
     * @param _target   Address to call
     * @param _gas      Amount of gas to pass to the call
     * @param _value    Amount of value to pass to the call
     * @param _calldata Calldata to pass to the call
     */
    function call(
        address _target,
        uint256 _gas,
        uint256 _value,
        bytes memory _calldata
    ) internal returns (bool) {
        console.log("gas provided to call: ", _gas, ", gasLeft: ", gasleft());
        bool _success;
        assembly {
            _success := call(
                _gas, // gas
                _target, // recipient
                _value, // ether value
                add(_calldata, 0x20), // inloc
                mload(_calldata), // inlen
                0, // outloc
                0 // outlen
            )
        }
        return _success;
    }
}

contract GasUser {
    uint[] public s;

    function store(uint i) public {
        for (uint j = 0; j < i; j++) {
            s.push(1);
        }
    }
}

contract Portal {
    address l2Sender;

    struct Transaction {
        uint gasLimit;
        address sender;
        address target;
        uint value;
        bytes data;
    }

    constructor(address _l2Sender) {
        l2Sender = _l2Sender;
    }

    function execute(Transaction memory _tx) public {
        console.log("gas left in the beginning: ", gasleft());
        require(
            gasleft() >= _tx.gasLimit + 20_000 + 5_122,
            "OptimismPortal: insufficient gas to finalize withdrawal"
        );

        // Set the l2Sender so contracts know who triggered this withdrawal on L2.
        l2Sender = _tx.sender;

        // Trigger the call to the target contract. We use SafeCall because we don't
        // care about the returndata and we don't want target contracts to be able to force this
        // call to run out of gas via a returndata bomb.
        bool success = SafeCall.call(
            _tx.target,
            gasleft() - 20_000,
            _tx.value,
            _tx.data
        );
    }
}

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

import "forge-std/Test.sol";
import {GasUser, Portal} from "../src/Portal.sol";

contract GasUserTest is Test {
    Portal public c;
    GasUser public gu;

    function setUp() public {
        c = new Portal(0x000000000000000000000000000000000000dEaD);
        gu = new GasUser();
    }

    function testGasLimit() public {
        gu.store{gas: 1_368_975}(60);
        assert(gu.s(59) == 1);
    }

    function _executePortalWithGivenGas(uint gas) public {
        c.execute{gas: gas}(
            Portal.Transaction({
                gasLimit: 1_368_975,
                sender: address(69),
                target: address(gu),
                value: 0,
                data: abi.encodeWithSignature("store(uint256)", 60)
            })
        );
    }

    function testPortalCatchesGasTooSmall() public {
        vm.expectRevert(
            bytes("OptimismPortal: insufficient gas to finalize withdrawal")
        );
        _executePortalWithGivenGas(1_368_975 + 20_000);
    }

    function testPortalBugWithEnoughGas() public {
        _executePortalWithGivenGas(1_368_975 + 30_000);

        // It now reverts because the array has a length of 0.
        vm.expectRevert();
        gu.s(0);
    }

    function testPortalSucceedsWithEnoughGas() public {
        _executePortalWithGivenGas(1_368_975 + 50_000); // add more gas to make it succeed
        assert(gu.s(59) == 1);
    }
}

❯ forge test -vvv --match-test testPortalBugWithEnoughGas
...

Running 1 test for test/Portal.t.sol:PortalTest
[PASS] testPortalBugWithEnoughGas() (gas: 1391120)
Logs:
  gas left in the beginning:  1397920
  gas provided to call: 1369583 , gasLeft: 1389336

Test result: ok. 1 passed; 0 failed; finished in 517.92µs