Gas Management

hook.target.call{gas: hook.gasLimit}(hook.callData);

// A call forwards all but 1/64th of the available gas. The
// math is used as a heuristic to account for this.
uint256 forwardedGas = gasleft() * 63 / 64;

uint256 forwardedGas = gasleft() * 63 / 64;
if (forwardedGas < hook.gasLimit) {
    revertByWastingGas();
}

(bool success,) = hook.target.call{gas: hook.gasLimit}(hook.callData);

function revertByWastingGas() private pure {
    while (true) {}
}

function test_RevertsWhenNotEnoughGas() public {
    uint256 requiredGas = 100_000;
    Hummer hummer = new Hummer();

    HooksTrampoline.Hook[] memory hooks = new HooksTrampoline.Hook[](1);
    hooks[0] = HooksTrampoline.Hook({
        target: address(hummer),
        callData: abi.encodeCall(Hummer.drive, ()),
        gasLimit: requiredGas
    });

    // Limit the available gas to be less than what the hook requires
    uint256 limitedGas = requiredGas - 1;

    vm.prank(settlement);
    vm.expectRevert(bytes(""));
    trampoline.execute{gas: limitedGas}(hooks);
}

function test_SpecifiesGasLimit() public {
    GasRecorder gas = new GasRecorder();
    uint256 gasLimit = 133700;

    HooksTrampoline.Hook[] memory hooks = new HooksTrampoline.Hook[](1);
    hooks[0] = HooksTrampoline.Hook({
        target: address(gas),
        callData: abi.encodeCall(GasRecorder.record, ()),
        gasLimit: gasLimit
    });

    vm.prank(settlement);
    trampoline.execute(hooks);

    // NOTE: we use a range here, the exact moment we call `gasleft()` is
    // after Solidity runtime setup, so we cannot, in a well-defined way,
    // know the exact amount of gas at this point
    assertApproxEqAbs(gas.value(), gasLimit, 200);
}

function test_RevertsWhenNotEnoughGasForMultipleHooks() public {
    uint256 requiredGas = 100_000;
    Hummer hummer1 = new Hummer();
    Hummer hummer2 = new Hummer();

    HooksTrampoline.Hook[] memory hooks = new HooksTrampoline.Hook[](2);
    bytes memory callData = abi.encodeCall(Hummer.drive, ());
    hooks[0] = HooksTrampoline.Hook({target: address(hummer1), callData: callData, gasLimit: requiredGas});
    hooks[1] = HooksTrampoline.Hook({target: address(hummer2), callData: callData, gasLimit: requiredGas});

    // Limit the available gas to be less than what both hooks require
    uint256 totalRequiredGas = requiredGas * hooks.length;
    uint256 limitedGas = totalRequiredGas - 1;

    vm.prank(settlement);
    vm.expectRevert(bytes(""));
    trampoline.execute{gas: limitedGas}(hooks);
}

/// @dev This constant captures the fact that the trampoline executes a few
/// operations before calling the desired contract.
uint256 constant TRAMPOLINE_OVERHEAD = 4_000;

/// @dev The gas craver contract has some minimal overhead before checking
/// the gas used in the call. The amount is exact and derived from the
/// debugger.
uint256 constant GAS_CRAVER_OVERHEAD = 117;

/// @dev A bound on how much actual gas is spent when executing the function
/// in the gas craver contract.
uint256 constant BOUND_ON_GAS_COST = 60_000;

uint256 callOverhead = (2600 + 700) * 2; // cold storage access + call cost

function limitForForwarding(uint256 gas) private pure returns (uint256) {
    return (gas + TRAMPOLINE_OVERHEAD) * 64 / 63;
}

Required gas = (100,000 + 4,000) * 64/63
             = 104,000 * 64/63
             = 105,650 gas (approximately)

/// @dev This test shows an undesired behavior of the trampoline contract.
/// It comes from the fact that we can't exactly say in the trampoline how
/// much gas is forwarded in the call exactly and so it can't enforce that
/// the amount in the call is exactly the desired amount.
function test_undesiredBehavior_TrampolineWithInsufficientAvailableGas() public gasPadded {
    uint256 criticalAmount = 3000;
    // ... test shows hook doesn't execute but trampoline doesn't revert
}

function test_TrampolineGasEfficiency() public gasPadded {
    // ... execute trampoline

    // THEN: the gas consumed should be reasonable
    assertLt(gasMetering, BOUND_ON_GAS_COST, "Trampoline should be gas efficient");
}

contract Hummer {
    function drive() external {
        // Hummers are cars that use way too much gas... Accessing the `n`th
        // memory address past `msize()` requires paying to 0-out the memory
        // from `msize()` to `n`. This costs 3-gas per 32-bytes at first and
        // grows as `msize()` gets bigger.
        uint256 n = type(uint256).max;
        assembly {
            sstore(0, mload(n))
        }
    }
}

function test_HandlesOutOfGas() public {
    Hummer hummer = new Hummer();
    HooksTrampoline.Hook[] memory hooks = new HooksTrampoline.Hook[](1);
    hooks[0] = HooksTrampoline.Hook({
        target: address(hummer),
        callData: abi.encodeCall(Hummer.drive, ()),
        gasLimit: 133700
    });

    vm.prank(settlement);
    uint256 gas = gasleft();
    trampoline.execute(hooks);
    uint256 gasUsed = gas - gasleft();
    uint256 callOverhead = (2600 + 700) * 2;

    assertApproxEqAbs(gasUsed, hooks[0].gasLimit + callOverhead, 500);
}