Unable to debug the fuzz revert error in Section 5: TSwap Video_num:25: Debugging the Fuzzer

[sharonphiliplima]

I am going through this video - https://updraft.cyfrin.io/courses/security/tswap/debugging-the-fuzzer?lesson_format=video

The code in the video and code in the text format given there have used the X and Y variables interchangeably. I have used the code provided in the text format given there, and I am receiving the following error:

Ran 1 test for test/invariant/Invariant.t.sol:Invariant
[FAIL: statefulFuzz_constantProductFormulaStaysTheSameY persisted failure revert]
        [Sequence]
                sender=0x0000000000000000000000000000000095d89B40 addr=[test/invariant/Handler.t.sol:Handler]0x5991A2dF15A8F6A256D3Ec51E99254Cd3fb576A9 calldata=deposit(uint256) args=[1126533705872199789001212553088801297114591205161425500696163464808655052683 [1.126e75]]
 statefulFuzz_constantProductFormulaStaysTheSameY() (runs: 1, calls: 1, reverts: 1)
Logs:
Bound result 38799437315672751381

The code and the foundry.toml file:

// 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 {
        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(expectedDeltaX));
        weth.approve(address(pool), type(uint256).max);
        poolToken.approve(address(pool), type(uint256).max);

        // Deposit
        pool.deposit(
            wethAmount,
            0,
            uint256(expectedDeltaX),
            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 (
            weth.balanceOf(address(pool)) <= pool.getMinimumWethDepositAmount()
        ) {
            return;
        }
        outputWeth = bound(
            outputWeth,
            pool.getMinimumWethDepositAmount(),
            weth.balanceOf(address(pool))
        );
        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);
    }
}

Invariant.t.sol:

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;

import {Test} from "forge-std/Test.sol";
import {StdInvariant} from "forge-std/StdInvariant.sol";
import {ERC20Mock} from "test/mocks/ERC20Mock.sol";
import {PoolFactory} from "../../src/PoolFactory.sol";
import {TSwapPool} from "../../src/TSwapPool.sol";
import {Handler} from "./Handler.t.sol";

contract Invariant is StdInvariant, Test {
    ERC20Mock poolToken;
    ERC20Mock weth;

    PoolFactory factory;
    TSwapPool pool; // poolToken, weth
    int256 public constant STARTING_X = 100e18;
    int256 public constant STARTING_Y = 50e18;

    Handler handler;

    function setUp() public {
        poolToken = new ERC20Mock();
        weth = new ERC20Mock();
        factory = new PoolFactory(address(weth));
        pool = TSwapPool(factory.createPool(address(poolToken)));

        poolToken.mint(address(this), uint256(STARTING_X));
        weth.mint(address(this), uint256(STARTING_Y));

        poolToken.approve(address(pool), type(uint256).max);
        weth.approve(address(pool), type(uint256).max);

        // Deposit Into Pool
        pool.deposit(
            uint256(STARTING_Y),
            uint256(STARTING_Y),
            uint256(STARTING_X),
            uint64(block.timestamp)
        );

        handler = new Handler(pool);
        bytes4[] memory selectors = new bytes4[](2);
        selectors[0] = handler.deposit.selector;
        selectors[1] = handler.swapPoolTokenForWethBasedOnOutputWeth.selector;
        targetSelector(
            FuzzSelector({addr: address(handler), selectors: selectors})
        );
        targetContract(address(handler));
    }

    function statefulFuzz_constantProductFormulaStaysTheSameY() public {
        assertEq(handler.actualDeltaX(), handler.expectedDeltaX());
    }
}

foundry.toml

[profile.default]
src = "src"
out = "out"
libs = ["lib"]
solc = "0.8.20"
remappings = ['@openzeppelin/contracts=lib/openzeppelin-contracts/contracts']

[fuzz]
seed = "0x1"

[invariant]
runs = 256
depth = 32
fail_on_revert = true

[fmt]
bracket_spacing = true
int_types = "long"
line_length = 120
multiline_func_header = "all"
quote_style = "double"
tab_width = 4
wrap_comments = true
# See more config options https://github.com/foundry-rs/foundry/blob/master/crates/config/README.md#all-options

[EngrPips]

Try the steps below. Let's see if it helps

• running forge clean
• deleting the cache folder if you have any
• running foundryup
• retry the test process

[sharonphiliplima]

Tried the above

The test doesn't fail if the fail_on_revert is set to false

[EngrPips]

That revert error in the stack trace makes sense, and you should be able to figure out why the amount you are depositing is too high and how to prevent that from happening. That's a custom error from TSwapPool complaining that the amount you are trying to deposit is too high.

[sharonphiliplima]

Hi, I re-took the lessons and tried writing the Handler and Invariant test files.
Seems like I have found the bug

// 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 startingX;
    int256 startingY;

    int256 public actualDeltaY;
    int256 public actualDeltaX;

    int256 public expectedDeltaY;
    int256 public expectedDeltaX;

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

    // y is gonna be the weth
    // x is gonna be the ERC20 or the poolToken

    function swapPoolTokenForWethBasedOnOutputWeth(uint256 outputWeth) public {
        // if (
        //     weth.balanceOf(address(pool)) <= pool.getMinimumWethDepositAmount()
        // ) {
        //     return;
        // }

        outputWeth = bound(
            outputWeth,
            pool.getMinimumWethDepositAmount(),
            type(uint64).max
        );

        // we dont wanna swap all the weth of the pool
        if (outputWeth >= weth.balanceOf(address(pool))) {
            return;
        }

        // ∆x = (β/(1-β)) * x

        uint256 poolTokenAmount = pool.getInputAmountBasedOnOutput(
            outputWeth,
            poolToken.balanceOf(address(pool)),
            weth.balanceOf(address(pool))
        );
        if (poolTokenAmount > type(uint256).max) {
            return;
        }

        startingY = int256(weth.balanceOf(address(pool)));
        startingX = int256(poolToken.balanceOf(address(pool)));
        expectedDeltaY = int256(-1) * int256(outputWeth); // negative because the pool is losing weth
        expectedDeltaX = 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();

        // actual

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

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

    function deposit(uint256 wethAmount) public {
        wethAmount = bound(
            wethAmount,
            pool.getMinimumWethDepositAmount(),
            type(uint64).max
        );

        startingY = int256(weth.balanceOf(address(pool)));
        startingX = int256(poolToken.balanceOf(address(pool)));
        expectedDeltaY = int256(wethAmount);
        expectedDeltaX = int256(
            pool.getPoolTokensToDepositBasedOnWeth(wethAmount)
        );

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

        pool.deposit(
            wethAmount,
            0,
            uint256(expectedDeltaX),
            uint64(block.timestamp)
        );
        vm.stopPrank();

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

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

And the Invariant file -

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;

import {Test} from "forge-std/Test.sol";
import {StdInvariant} from "forge-std/StdInvariant.sol";
import {ERC20Mock} from "test/mocks/ERC20Mock.sol";
import {PoolFactory} from "../../src/PoolFactory.sol";
import {TSwapPool} from "../../src/TSwapPool.sol";
import {Handler} from "./Handler.t.sol";

contract Invariant is StdInvariant, Test {
    ERC20Mock poolToken;
    ERC20Mock weth;

    PoolFactory factory;
    TSwapPool pool; // poolToken, weth
    int256 public constant STARTING_X = 100e18; // Starting poolToken
    int256 public constant STARTING_Y = 50e18; // Starting WETH

    Handler handler;

    function setUp() public {
        poolToken = new ERC20Mock();
        weth = new ERC20Mock();
        factory = new PoolFactory(address(weth));
        pool = TSwapPool(factory.createPool(address(poolToken)));

        poolToken.mint(address(this), uint256(STARTING_X));
        weth.mint(address(this), uint256(STARTING_Y));

        poolToken.approve(address(pool), type(uint256).max);
        weth.approve(address(pool), type(uint256).max);

        // Deposit Into Pool
        pool.deposit(
            uint256(STARTING_Y),
            uint256(STARTING_Y),
            uint256(STARTING_X),
            uint64(block.timestamp)
        );

        handler = new Handler(pool);
        bytes4[] memory selectors = new bytes4[](2);
        selectors[0] = handler.deposit.selector;
        selectors[1] = handler.swapPoolTokenForWethBasedOnOutputWeth.selector;
        targetSelector(
            FuzzSelector({addr: address(handler), selectors: selectors})
        );
        targetContract(address(handler));
    }

    function statefulFuzz_constantProductFormulaStaysTheSameY() public {
        // the change in the pool size of weth should follow the invariant function
        // ∆x = (β/(1-β)) * x
        // In a handler we can have an actual delta x and compare it to the expected delta x

        assertEq(handler.actualDeltaX(), handler.expectedDeltaX());
    }
}

The test result (with forge test --mt statefulFuzz_constantProductFormulaStaysTheSameY -vvvvv):
The transfer is called three times, which is not intended when it sends 1e18 on the 10th execution

But I am not sure, if this is the proper way to find it out coz when I rechecked Patrick's video, he had bounded the swapPoolTokenForWethBasedOnOutputWeth 's input outputWeth between pool.getMinimumWethDepositAmount(), and weth.balanceOf(address(pool)) whereas my test kinda fails when I do that:

Can someone guide me with the correct thought pattern I should be having here?
Thanks.

[EngrPips]

Your test says max is less than min, which seems like an error you can look into and resolve.

[sharonphiliplima]

I tried resolving it through many methods, and the only way I could get it to work is by using type(uint64).max as the upper bound. Also, Patrick doesn't get the same error.
The code given in the text section is completely different too.

[EngrPips]

The more advanced you go, the more you might need to make things work your own way.

[sharonphiliplima]

Thank you. I felt I had made some mistakes myself!

[EngrPips]

Anytime, Friend. The best way we learn is through our mistakes.