Invariant testing Handler::swapPoolTokenForWethBasedOnOutputWeth error ERC20InsufficientBalance

[Yashwant23]

Hi , I was going through invariant testing of TSwap contract was facing the error ERC20InsufficientBalance when Handler::swapPoolTokenForWethBasedOnOutputWethis called10xtimes in a single run due less than<1 etherdifference betweenoutputAmountand 'outputTokenReserve'. I tmodified theHandler::swapPoolTokenForWethBasedOnOutputWeth` function by adding checks for weth reserves to be more than 1 Ether and output amount to be less than 1 ether from weth reserve it worked.

swapPoolTokenForWethBasedOnOutputWeth:

    function swapPoolTokenForWethBasedOnOutputWeth(uint256 outputWeth) public {
        if (weth.balanceOf(address(pool)) < 1e18) {
            return;
        }
        if (
            pool.getMinimumWethDepositAmount() >
            weth.balanceOf(address(pool)) - 1e18
        ) {
            return;
        }
        outputWeth = bound(
            outputWeth,
            pool.getMinimumWethDepositAmount(),
            weth.balanceOf(address(pool)) - 1e18
        );
.......
.......

I know what is causing the error , but do not know why Patrick didn't face the issue
and are there other ways to resolve this error
Handler.t.sol without modification of boundries

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;

import {Test, console2} from "forge-std/Test.sol";
import {TSwapPool} from "../../src/TSwapPool.sol";
import {ERC20Mock} from "../mocks/ERC20Mock.sol";

contract Handler is Test {
    TSwapPool pool;
    ERC20Mock weth;
    ERC20Mock poolToken;

    address liquidityProvider = makeAddr("lp");
    address swapper = makeAddr("swapper");

    // Ghost Variables - variables that only exist in our Handler
    int256 public actualDeltaY;
    int256 public expectedDeltaY;

    int256 public actualDeltaX;
    int256 public expectedDeltaX;

    int256 public startingX;
    int256 public startingY;

    constructor(TSwapPool _pool) {
        pool = _pool;
        weth = ERC20Mock(_pool.getWeth());
        poolToken = ERC20Mock(_pool.getPoolToken());
    }

    function deposit(uint256 wethAmount) public {
        if (
            pool.getMinimumWethDepositAmount() > weth.balanceOf(address(pool))
        ) {
            return;
        }
        wethAmount = bound(
            wethAmount,
            pool.getMinimumWethDepositAmount(),
            weth.balanceOf(address(pool))
        );

        startingY = int256(poolToken.balanceOf(address(pool)));
        startingX = int256(weth.balanceOf(address(pool)));

        expectedDeltaX = int256(wethAmount);
        expectedDeltaY = int256(
            pool.getPoolTokensToDepositBasedOnWeth(wethAmount)
        );

        vm.startPrank(liquidityProvider);
        weth.mint(liquidityProvider, wethAmount);
        poolToken.mint(liquidityProvider, uint256(expectedDeltaY));
        weth.approve(address(pool), type(uint256).max);
        poolToken.approve(address(pool), type(uint256).max);

        // Deposit
        pool.deposit(
            wethAmount,
            0,
            pool.getPoolTokensToDepositBasedOnWeth(wethAmount),
            uint64(block.timestamp)
        );
        vm.stopPrank();

        uint256 endingX = poolToken.balanceOf(address(pool));
        uint256 endingY = weth.balanceOf(address(pool));

        // sell tokens == x == poolTokens
        actualDeltaY = int256(endingX) - int256(startingY);
        actualDeltaX = int256(endingY) - int256(startingX);
    }

    function swapPoolTokenForWethBasedOnOutputWeth(uint256 outputWeth) public {
        if (
            pool.getMinimumWethDepositAmount() > weth.balanceOf(address(pool))
        ) {
            return;
        }
        outputWeth = bound(
            outputWeth,
            pool.getMinimumWethDepositAmount(),
            weth.balanceOf(address(pool)) - 1
        );
        if (outputWeth >= weth.balanceOf(address(pool))) {
            return;
        }
        uint256 poolTokenAmount = pool.getInputAmountBasedOnOutput(
            outputWeth,
            poolToken.balanceOf(address(pool)),
            weth.balanceOf(address(pool))
        );

        startingY = int256(poolToken.balanceOf(address(pool)));
        startingX = int256(weth.balanceOf(address(pool)));

        expectedDeltaX = int256(-1) * int256(outputWeth);
        expectedDeltaY = int256(poolTokenAmount);

        if (poolToken.balanceOf(swapper) < poolTokenAmount) {
            poolToken.mint(
                swapper,
                poolTokenAmount - poolToken.balanceOf(swapper) + 1
            );
        }
        vm.startPrank(swapper);
        poolToken.approve(address(pool), type(uint256).max);
        pool.swapExactOutput(
            poolToken,
            weth,
            outputWeth,
            uint64(block.timestamp)
        );
        vm.stopPrank();

        uint256 endingY = poolToken.balanceOf(address(pool));
        uint256 endingX = weth.balanceOf(address(pool));

        actualDeltaY = int256(endingY) - int256(startingY);
        actualDeltaX = int256(endingX) - int256(startingX);
    }
}

  [89836] Handler::swapPoolTokenForWethBasedOnOutputWeth(2032)
    ├─ [2559] ERC20Mock::balanceOf(TSwapPool: [0x4f81992FCe2E1846dD528eC0102e6eE1f61ed3e2]) [staticcall]
    │   └─ ← [Return] 653748392750036368 [6.537e17]
    ├─ [280] TSwapPool::getMinimumWethDepositAmount() [staticcall]
    │   └─ ← [Return] 1000000000 [1e9]
    ├─ [280] TSwapPool::getMinimumWethDepositAmount() [staticcall]
    │   └─ ← [Return] 1000000000 [1e9]
    ├─ [559] ERC20Mock::balanceOf(TSwapPool: [0x4f81992FCe2E1846dD528eC0102e6eE1f61ed3e2]) [staticcall]
    │   └─ ← [Return] 653748392750036368 [6.537e17]
    ├─ [0] console::log("Bound result", 653748391750038400 [6.537e17]) [staticcall]
    │   └─ ← [Stop] 
    ├─ [559] ERC20Mock::balanceOf(TSwapPool: [0x4f81992FCe2E1846dD528eC0102e6eE1f61ed3e2]) [staticcall]
    │   └─ ← [Return] 653748392750036368 [6.537e17]
    ├─ [2559] ERC20Mock::balanceOf(TSwapPool: [0x4f81992FCe2E1846dD528eC0102e6eE1f61ed3e2]) [staticcall]
    │   └─ ← [Return] 4677870611860731103032849 [4.677e24]
    ├─ [559] ERC20Mock::balanceOf(TSwapPool: [0x4f81992FCe2E1846dD528eC0102e6eE1f61ed3e2]) [staticcall]
    │   └─ ← [Return] 653748392750036368 [6.537e17]
    ├─ [930] TSwapPool::getInputAmountBasedOnOutput(653748391750038400 [6.537e17], 4677870611860731103032849 [4.677e24], 653748392750036368 [6.537e17]) [staticcall]
    │   └─ ← [Return] 30673586795315339633612904139785828 [3.067e34]
    ├─ [559] ERC20Mock::balanceOf(TSwapPool: [0x4f81992FCe2E1846dD528eC0102e6eE1f61ed3e2]) [staticcall]
    │   └─ ← [Return] 4677870611860731103032849 [4.677e24]
    ├─ [559] ERC20Mock::balanceOf(TSwapPool: [0x4f81992FCe2E1846dD528eC0102e6eE1f61ed3e2]) [staticcall]
    │   └─ ← [Return] 653748392750036368 [6.537e17]
    ├─ [2559] ERC20Mock::balanceOf(swapper: [0x4A9D6b0b19CBFfCB0255550661eCB7014283c60E]) [staticcall]
    │   └─ ← [Return] 1
    ├─ [559] ERC20Mock::balanceOf(swapper: [0x4A9D6b0b19CBFfCB0255550661eCB7014283c60E]) [staticcall]
    │   └─ ← [Return] 1
    ├─ [10584] ERC20Mock::mint(swapper: [0x4A9D6b0b19CBFfCB0255550661eCB7014283c60E], 30673586795315339633612904139785828 [3.067e34])
    │   ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: swapper: [0x4A9D6b0b19CBFfCB0255550661eCB7014283c60E], value: 30673586795315339633612904139785828 [3.067e34])
    │   └─ ← [Stop] 
    ├─ [0] VM::startPrank(swapper: [0x4A9D6b0b19CBFfCB0255550661eCB7014283c60E])
    │   └─ ← [Return] 
    ├─ [4835] ERC20Mock::approve(TSwapPool: [0x4f81992FCe2E1846dD528eC0102e6eE1f61ed3e2], 115792089237316195423570985008687907853269984665640564039457584007913129639935 [1.157e77])
    │   ├─ emit Approval(owner: swapper: [0x4A9D6b0b19CBFfCB0255550661eCB7014283c60E], spender: TSwapPool: [0x4f81992FCe2E1846dD528eC0102e6eE1f61ed3e2], value: 115792089237316195423570985008687907853269984665640564039457584007913129639935 [1.157e77])
    │   └─ ← [Return] true
    ├─ [10156] TSwapPool::swapExactOutput(ERC20Mock: [0x2e234DAe75C793f67A35089C9d99245E1C58470b], ERC20Mock: [0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f], 653748391750038400 [6.537e17], 1)
    │   ├─ [559] ERC20Mock::balanceOf(TSwapPool: [0x4f81992FCe2E1846dD528eC0102e6eE1f61ed3e2]) [staticcall]
    │   │   └─ ← [Return] 4677870611860731103032849 [4.677e24]
    │   ├─ [559] ERC20Mock::balanceOf(TSwapPool: [0x4f81992FCe2E1846dD528eC0102e6eE1f61ed3e2]) [staticcall]
    │   │   └─ ← [Return] 653748392750036368 [6.537e17]
    │   ├─ [893] ERC20Mock::transfer(swapper: [0x4A9D6b0b19CBFfCB0255550661eCB7014283c60E], 1000000000000000000 [1e18])
    │   │   └─ ← [Revert] ERC20InsufficientBalance(0x4f81992FCe2E1846dD528eC0102e6eE1f61ed3e2, 653748392750036368 [6.537e17], 1000000000000000000 [1e18])
    │   └─ ← [Revert] ERC20InsufficientBalance(0x4f81992FCe2E1846dD528eC0102e6eE1f61ed3e2, 653748392750036368 [6.537e17], 1000000000000000000 [1e18])
    └─ ← [Revert] ERC20InsufficientBalance(0x4f81992FCe2E1846dD528eC0102e6eE1f61ed3e2, 653748392750036368 [6.537e17], 1000000000000000000 [1e18])

  [13298] Invariant::statefulFuzz_constantProductFormulaStaysSameForY()
    ├─ [2373] Handler::actualDeltaY() [staticcall]
    │   └─ ← [Return] 4323210583085922785687901 [4.323e24]
    ├─ [2350] Handler::expectedDeltaY() [staticcall]
    │   └─ ← [Return] 4323210583085922785687901 [4.323e24]
    ├─ [0] VM::assertEq(4323210583085922785687901 [4.323e24], 4323210583085922785687901 [4.323e24]) [staticcall]
    │   └─ ← [Return] 
    └─ ← [Stop] 

[EngrPips]

The protocol takes charge when you make 10 swaps; we wrote the whole fuzzing test to prove that. That is the essence of the fuzz test we wrote.