feat(cheatcodes): add `vm.callTimeout` and `vm.setGas` for improved gas control

[Azvect]

Component

Forge

Describe the feature you would like

When you use vm.pauseGasMetering() and call an address, if the address is a contract address and the contract uses the gasleft() function in a loop, the call can get stuck in an infinite loop. The reason is that the gasleft() function keeps returning the same gas limit indefinitely. While using vm.resumeGasMetering() can prevent this issue, it's not always effective.

For instance, I have a script that calls many contracts, and I don't want to encounter gas limit exceeded or out-of-gas errors. Thus, setting the gas limit again after it's lowered by vm.resumeGasMetering() isn't always possible.

A possible solution is to introduce an option like vm.callTimeout(address, data, timeout), which could be highly useful in various contexts such as fuzzing.

Alternatively, adding a function like vm.setGas(uint256) to adjust the gas limit inside the contract, allowing it to increase after execution, would be extremely beneficial.

Proposed Feature:

1. vm.callTimeout(address, data, timeout)

   • Calls an address with a specified data payload and a timeout.
   • Terminates the call if the timeout duration is exceeded.

2. vm.setGas(uint256)

   • Sets the gas limit to the specified value.
   • Allows resetting the gas limit to a higher value after execution.

These options would offer developers more control over gas usage and prevent infinite loops in contract calls.

Additional context

No response

[grandizzy]

@Azvect there were quite some changes in the way pause / resume gas metering works (e.g. #8743) could you please retest your scenario with latest forge and see if any better? thank you

[Azvect]

@grandizzy I'm still running into the same problem, and the reason I suggested adding a vm.callTimeout feature is to save time when fuzzing contracts.

Let’s say I have 1000 contracts to test. If I’m fuzzing them, a simple loop like this can cause serious delays:

while (gasleft() > 0) {
    // some action
}

For example, if this code is part of a contract at address 0xgasdemo and inside a function 0xdemofunc, I’d usually call it with:
0xgasdemo.call(0xdemofunc)

But since I need to check so many contracts, I use vm.pauseGasMetering() to avoid running out of gas. However, this really slows things down. To work around it, I ended up writing a Python script that checks if a call takes more than 15 seconds—if it does, the script kills the process and moves on. Even it works, it’s a slow and complicated solution.

If there was a vm.callTimeout cheat code, I could simply do something like:
vm.callTimeout(0xgasdemo, 0xdemofunc, 15)
That would let me set a timeout (in seconds) for the call, which would be incredibly helpful.

In short, the issue isn’t just with gas metering—it’s that we need a timeout for contract calls to avoid wasting time during fuzzing.