I don’t know what’s going on—why does it show that the left and right sides are not equal? I didn’t follow the tutorial’s approach of converting to int, but instead used uint, because I know which token is flowing in and which token is flowing out in the function. For example: if it’s an outflow token, then actualBalance = start - end; if it’s an inflow token, then actualBalance = end - start. This way, I don’t need to convert to int, but I don’t know which step went wrong.

[jupiter-Pulin]

[FAIL: <empty revert data>]
        [Sequence]
                sender=0x00000000000000000000000000000000000001B2 addr=[test/unit/invarint/handler.t.sol:Handler]0x5991A2dF15A8F6A256D3Ec51E99254Cd3fb576A9 calldata=swapToExactInput(uint256) args=[1126533705872199789001212553088801297114591205161425500696163464808655052683 [1.126e75]]
                sender=0x0000000000000000000000001F241734cCCfeE2A addr=[test/unit/invarint/handler.t.sol:Handler]0x5991A2dF15A8F6A256D3Ec51E99254Cd3fb576A9 calldata=swapToExactOutput(uint256) args=[320143 [3.201e5]]
                sender=0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f addr=[test/unit/invarint/handler.t.sol:Handler]0x5991A2dF15A8F6A256D3Ec51E99254Cd3fb576A9 calldata=swapToExactOutput(uint256) args=[2412247229 [2.412e9]]
                sender=0x0000000000000000000000001F241734cCCfeE2A addr=[test/unit/invarint/handler.t.sol:Handler]0x5991A2dF15A8F6A256D3Ec51E99254Cd3fb576A9 calldata=deposit(uint256) args=[1]
                sender=0x5962974032A062472471eF3da4667C075a5AA5a3 addr=[test/unit/invarint/handler.t.sol:Handler]0x5991A2dF15A8F6A256D3Ec51E99254Cd3fb576A9 calldata=swapToExactOutput(uint256) args=[1252]
                sender=0x000000000000000000000000000000000001d545 addr=[test/unit/invarint/handler.t.sol:Handler]0x5991A2dF15A8F6A256D3Ec51E99254Cd3fb576A9 calldata=swapToExactInput(uint256) args=[1]
                sender=0x2e234DAe75C793f67A35089C9d99245E1C58470b addr=[test/unit/invarint/handler.t.sol:Handler]0x5991A2dF15A8F6A256D3Ec51E99254Cd3fb576A9 calldata=deposit(uint256) args=[394788351815080 [3.947e14]]
                sender=0x0000000000000000000000012Fae7aC31a7d17C2 addr=[test/unit/invarint/handler.t.sol:Handler]0x5991A2dF15A8F6A256D3Ec51E99254Cd3fb576A9 calldata=swapToExactInput(uint256) args=[56163704696640452142197199127252104166317009532074502048454053802634565426 [5.616e73]]
                sender=0x0000000000000000000000000000000000002d52 addr=[test/unit/invarint/handler.t.sol:Handler]0x5991A2dF15A8F6A256D3Ec51E99254Cd3fb576A9 calldata=swapToExactOutput(uint256) args=[0]
                sender=0x000000000000000000000000000000000000155C addr=[test/unit/invarint/handler.t.sol:Handler]0x5991A2dF15A8F6A256D3Ec51E99254Cd3fb576A9 calldata=deposit(uint256) args=[363440698709880954508223195084938678974048863139 [3.634e47]]
                sender=0x55460ac0436b871D7e2931c2BbE6f4B25429e192 addr=[test/unit/invarint/handler.t.sol:Handler]0x5991A2dF15A8F6A256D3Ec51E99254Cd3fb576A9 calldata=swapToExactOutput(uint256) args=[1354998742469660521287166058563920729829936803778688253961216 [1.354e60]]
                sender=0x000000000000000000000000000000008Fc7f8BD addr=[test/unit/invarint/handler.t.sol:Handler]0x5991A2dF15A8F6A256D3Ec51E99254Cd3fb576A9 calldata=swapToExactInput(uint256) args=[2087]
                sender=0x000000000000000000000000000000000000218F addr=[test/unit/invarint/handler.t.sol:Handler]0x5991A2dF15A8F6A256D3Ec51E99254Cd3fb576A9 calldata=swapToExactInput(uint256) args=[139610431935091697179783450 [1.396e26]]
 statefulFuzz_testInvariant() (runs: 0, calls: 0, reverts: 0)
Logs:
  Bound Result 2243944029879266858
  Bound Result 320143
  Bound Result 2412247229
  Bound Result 1000000001
  Bound Result 1252
  Bound Result 1
  Bound Result 394788351815080
  Bound Result 14621766103599858616
  Bound Result 1
  Bound Result 8860299642688614819
  Bound Result 3355433051218645966
  Bound Result 2087
  Bound Result 12549011992530185410
  start fuzzing
  expectedAmountToken 108921414517467485083
  actualAmountToken 109921414517467485083
  Error: a == b not satisfied [uint]
        Left: 108921414517467485083
       Right: 109921414517467485083

handler：

contract Handler is Test {
    ERC20Mock public mockToken;
    ERC20Mock public mockWeth;
    TSwapPool public pool;
    address public liquidityProvider = makeAddr("liquidityProvider");
    address swapper = makeAddr("swapper");

    uint256 public expectedAmountWETH;
    uint256 public actualAmountWETH;
    uint256 public expectedAmountToken;
    uint256 public actualAmountToken;

    uint256 minimumWethToDeposit;

    constructor(TSwapPool _pool) {
        pool = _pool;
        mockWeth = ERC20Mock(pool.getWeth());
        mockToken = ERC20Mock(pool.getPoolToken());
        minimumWethToDeposit = pool.getMinimumWethDepositAmount();
    }

    function deposit(uint256 _wethToDeposit) external {
        uint256 wethToDeposit = bound(
            _wethToDeposit,
            minimumWethToDeposit,
            type(uint64).max
        );
        uint256 startBalance = mockToken.balanceOf(address(pool));
        uint256 startBalanceWeth = mockWeth.balanceOf(address(pool));
        if (
            startBalanceWeth > type(uint128).max ||
            startBalance > type(uint128).max
        ) {
            return;
        }
        expectedAmountToken = pool.getPoolTokensToDepositBasedOnWeth(
            wethToDeposit
        );

        vm.startPrank(liquidityProvider);
        // Mint WETH to liquidityProvider if needed
        if (mockWeth.balanceOf(liquidityProvider) < wethToDeposit) {
            mockWeth.mint(liquidityProvider, wethToDeposit);
        }
        // Mint tokens to liquidityProvider if needed
        if (mockToken.balanceOf(liquidityProvider) < expectedAmountToken) {
            mockToken.mint(liquidityProvider, expectedAmountToken);
        }
        mockWeth.approve(address(pool), type(uint256).max);
        mockToken.approve(address(pool), type(uint256).max);
        pool.deposit({
            wethToDeposit: wethToDeposit,
            minimumLiquidityTokensToMint: 0,
            maximumPoolTokensToDeposit: expectedAmountToken,
            deadline: uint64(block.timestamp + 1000)
        });
        vm.stopPrank();
        uint256 endBalance = mockToken.balanceOf(address(pool));
        uint256 endBalanceWeth = mockWeth.balanceOf(address(pool));
        actualAmountToken = endBalance - startBalance;
        actualAmountWETH = endBalanceWeth - startBalanceWeth;
    }

    
    function swapToExactOutput(uint256 _outputAmount) external {
        if (
            mockWeth.balanceOf(address(pool)) <=
            pool.getMinimumWethDepositAmount()
        ) {
            return;
        }
        uint256 outputAmount = bound(
            _outputAmount,
            1,
            mockWeth.balanceOf(address(pool))
        );

        uint256 startTokenBalance = mockToken.balanceOf(address(pool));
        uint256 startWethBalance = mockWeth.balanceOf(address(pool));

        expectedAmountToken = pool.getInputAmountBasedOnOutput(
            outputAmount,
            startTokenBalance,
            startWethBalance
        );

        vm.startPrank(swapper);
        if (mockToken.balanceOf(swapper) < expectedAmountToken) {
            mockToken.mint(swapper, expectedAmountToken);
        }
        mockToken.approve(address(pool), type(uint256).max);

        pool.swapExactOutput({
            inputToken: mockToken,
            outputToken: mockWeth,
            outputAmount: outputAmount,
            deadline: uint64(block.timestamp + 1000)
        });
        vm.stopPrank();

        uint256 endTokenBalance = mockToken.balanceOf(address(pool));
        uint256 endWethBalance = mockWeth.balanceOf(address(pool));

        actualAmountToken = endTokenBalance - startTokenBalance;
        actualAmountWETH = startWethBalance - endWethBalance;
        expectedAmountWETH = outputAmount;
    }


    function swapToExactInput(uint256 _inputAmount) external {
        if (
            mockWeth.balanceOf(address(pool)) <=
            pool.getMinimumWethDepositAmount()
        ) {
            return;
        }
        uint256 inputAmount = bound(_inputAmount, 1, type(uint64).max);

        uint256 startTokenBalance = mockToken.balanceOf(address(pool));
        uint256 startWethBalance = mockWeth.balanceOf(address(pool));

        expectedAmountToken = pool.getOutputAmountBasedOnInput(
            inputAmount,
            startWethBalance,
            startTokenBalance
        );

        vm.startPrank(swapper);
        if (mockWeth.balanceOf(swapper) < inputAmount) {
            mockWeth.mint(swapper, inputAmount);
        }
        mockWeth.approve(address(pool), type(uint256).max);

        pool.swapExactInput({
            inputToken: mockWeth,
            inputAmount: inputAmount,
            outputToken: mockToken,
            minOutputAmount: 0,
            deadline: uint64(block.timestamp + 1000)
        });
        vm.stopPrank();

        uint256 endTokenBalance = mockToken.balanceOf(address(pool));
        uint256 endWethBalance = mockWeth.balanceOf(address(pool));

        actualAmountToken = startTokenBalance - endTokenBalance;
        actualAmountWETH = endWethBalance - startWethBalance;
    }

    function _updateStartingBalance() external {
        int startBalance = int(mockToken.balanceOf(address(pool)));
        int startBalanceWeth = int(mockWeth.balanceOf(address(pool)));
    }
}

invariant：

contract InvariantTest is StdInvariant, Test {
    ERC20Mock public mockToken;
    ERC20Mock public mockWeth;
    TSwapPool public pool;
    PoolFactory public factory;
    address public user1 = address(0x1);
    Handler public handler;
    bytes4[] selectors;

    function setUp() external {
        mockToken = new ERC20Mock();
        mockWeth = new ERC20Mock();
        mockToken.mint(user1, 1000 ether);
        mockWeth.mint(user1, 100 ether);

        factory = new PoolFactory(address(mockWeth));
        vm.startPrank(user1);
        pool = TSwapPool(factory.createPool(address(mockToken)));
        mockToken.approve(address(pool), type(uint256).max);
        mockWeth.approve(address(pool), type(uint256).max);


        pool.deposit({
            wethToDeposit: 100 ether,
            minimumLiquidityTokensToMint: 0,
            maximumPoolTokensToDeposit: 1000 ether,
            deadline: uint64(block.timestamp + 1000)
        });
        vm.stopPrank();

        handler = new Handler(pool);

        selectors = new bytes4[](3);
        selectors[0] = handler.deposit.selector;
        selectors[1] = handler.swapToExactOutput.selector;
        selectors[2] = handler.swapToExactInput.selector;

        targetSelector(
            FuzzSelector({addr: address(handler), selectors: selectors})
        );
        targetContract(address(handler));
    }

    function statefulFuzz_testInvariant() external {
        console2.log("start fuzzing");
        console2.log("expectedAmountToken", handler.expectedAmountToken());
        console2.log("actualAmountToken", handler.actualAmountToken());
        assertEq(handler.expectedAmountToken(), handler.actualAmountToken());
        //assertEq(handler.expectedAmountWETH(), handler.actualAmountWETH());
    }
}

[EngrPips]

I think the expected behavior is that the test will not pass because after 10 swaps, a fee will be taken on the output token, and we will get less than we are supposed to get, and that is exactly what happened.

[jupiter-Pulin]

get it! i've figured out!thanks

[EngrPips]

I am glad you figured it out. Keep crushing it.