RAN INTO THIS ERROR AFTER WRITING THE HANDLER AND INVARIANT

[pherm0007]

[EngrPips]

Hello @pherm0007, Read through your test code and give the necessary address the allowance needed and the error should be resolved.

[EngrPips]

Anytime, Friend. Keep crushing it.

[SpringxDSay]

I am experiencing similar issue as above when running the test for testInvariantBroken. Here is the test suite:
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

import { Test, console } from "forge-std/Test.sol";
import { TSwapPool } from "../../src/PoolFactory.sol";
import { ERC20Mock } from "@openzeppelin/contracts/mocks/token/ERC20Mock.sol";
import { IERC20 } from "@openzeppelin/contracts/interfaces/IERC20.sol";

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

address liquidityProvider = makeAddr("liquidityProvider");
address user = makeAddr("user");

function setUp() public {
    poolToken = new ERC20Mock();
    weth = new ERC20Mock();
    pool = new TSwapPool(address(poolToken), address(weth), "LTokenA", "LA");

    weth.mint(liquidityProvider, 200e18);
    poolToken.mint(liquidityProvider, 200e18);

    weth.mint(user, 10e18);
    poolToken.mint(user, 10e18);
}

function testDeposit() public {
    vm.startPrank(liquidityProvider);
    weth.approve(address(pool), 100e18);
    poolToken.approve(address(pool), 100e18);
    pool.deposit(100e18, 100e18, 100e18, uint64(block.timestamp));

    assertEq(pool.balanceOf(liquidityProvider), 100e18);
    assertEq(weth.balanceOf(liquidityProvider), 100e18);
    assertEq(poolToken.balanceOf(liquidityProvider), 100e18);

    assertEq(weth.balanceOf(address(pool)), 100e18);
    assertEq(poolToken.balanceOf(address(pool)), 100e18);
}

function testDepositSwap() public {
    vm.startPrank(liquidityProvider);
    weth.approve(address(pool), 100e18);
    poolToken.approve(address(pool), 100e18);
    pool.deposit(100e18, 100e18, 100e18, uint64(block.timestamp));
    vm.stopPrank();

    vm.startPrank(user);
    poolToken.approve(address(pool), 10e18);
    // After we swap, there will be ~110 tokenA, and ~91 WETH
    // 100 * 100 = 10,000
    // 110 * ~91 = 10,000
    uint256 expected = 9e18;

    pool.swapExactInput(poolToken, 10e18, weth, expected, uint64(block.timestamp));
    assert(weth.balanceOf(user) >= expected);
}

function testWithdraw() public {
    vm.startPrank(liquidityProvider);
    weth.approve(address(pool), 100e18);
    poolToken.approve(address(pool), 100e18);
    pool.deposit(100e18, 100e18, 100e18, uint64(block.timestamp));

    pool.approve(address(pool), 100e18);
    pool.withdraw(100e18, 100e18, 100e18, uint64(block.timestamp));

    assertEq(pool.totalSupply(), 0);
    assertEq(weth.balanceOf(liquidityProvider), 200e18);
    assertEq(poolToken.balanceOf(liquidityProvider), 200e18);
}

function testCollectFees() public {
    vm.startPrank(liquidityProvider);
    weth.approve(address(pool), 100e18);
    poolToken.approve(address(pool), 100e18);
    pool.deposit(100e18, 100e18, 100e18, uint64(block.timestamp));
    vm.stopPrank();

    vm.startPrank(user);
    uint256 expected = 9e18;
    poolToken.approve(address(pool), 10e18);
    pool.swapExactInput(poolToken, 10e18, weth, expected, uint64(block.timestamp));
    vm.stopPrank();

    vm.startPrank(liquidityProvider);
    pool.approve(address(pool), 100e18);
    pool.withdraw(100e18, 90e18, 100e18, uint64(block.timestamp));
    assertEq(pool.totalSupply(), 0);
    assert(weth.balanceOf(liquidityProvider) + poolToken.balanceOf(liquidityProvider) > 400e18);
}

function testInvariantBroken() public {
    vm.startPrank(liquidityProvider);
    weth.approve(address(pool), 100e18);
    poolToken.approve(address(pool), 100e18);
    pool.deposit(100e18, 100e18, 100e18, uint64(block.timestamp));
    vm.stopPrank();

    uint256 outputWeth = 1e17;
    int256 actualStartingY = int256(weth.balanceOf(address(pool)));
    int256 expectedDeltaY = int256(-1) * int256(outputWeth);

    vm.startPrank(user);
    pool.approve(address(pool), 100e18);
    pool.swapExactOutput(poolToken, weth, outputWeth, uint64(block.timestamp));
    pool.swapExactOutput(poolToken, weth, outputWeth, uint64(block.timestamp));
    pool.swapExactOutput(poolToken, weth, outputWeth, uint64(block.timestamp));
    pool.swapExactOutput(poolToken, weth, outputWeth, uint64(block.timestamp));
    pool.swapExactOutput(poolToken, weth, outputWeth, uint64(block.timestamp));
    pool.swapExactOutput(poolToken, weth, outputWeth, uint64(block.timestamp));
    pool.swapExactOutput(poolToken, weth, outputWeth, uint64(block.timestamp));
    pool.swapExactOutput(poolToken, weth, outputWeth, uint64(block.timestamp));
    pool.swapExactOutput(poolToken, weth, outputWeth, uint64(block.timestamp));
    pool.swapExactOutput(poolToken, weth, outputWeth, uint64(block.timestamp));
    vm.stopPrank();

    uint256 endingY = weth.balanceOf(address(pool));
   
    int256 actualDeltaY = int256(endingY) - int256(actualStartingY);
    assert(actualDeltaY == expectedDeltaY);
}

}

And here is the test result:

[257998] TSwapPoolTest::testInvariantBroken()
├─ [0] VM::startPrank(liquidityProvider: [0xE9323E1440012e53E2DDb91Fc38EF24C20F2628d])
│ └─ ← [Return]
├─ [25298] ERC20Mock::approve(TSwapPool: [0xF62849F9A0B5Bf2913b396098F7c7019b51A820a], 100000000000000000000 [1e20])
│ ├─ emit Approval(owner: liquidityProvider: [0xE9323E1440012e53E2DDb91Fc38EF24C20F2628d], spender: TSwapPool: [0xF62849F9A0B5Bf2913b396098F7c7019b51A820a], value: 100000000000000000000 [1e20])
│ └─ ← [Return] true
├─ [25298] ERC20Mock::approve(TSwapPool: [0xF62849F9A0B5Bf2913b396098F7c7019b51A820a], 100000000000000000000 [1e20])
│ ├─ emit Approval(owner: liquidityProvider: [0xE9323E1440012e53E2DDb91Fc38EF24C20F2628d], spender: TSwapPool: [0xF62849F9A0B5Bf2913b396098F7c7019b51A820a], value: 100000000000000000000 [1e20])
│ └─ ← [Return] true
├─ [115149] TSwapPool::deposit(100000000000000000000 [1e20], 100000000000000000000 [1e20], 100000000000000000000 [1e20], 1)
│ ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: liquidityProvider: [0xE9323E1440012e53E2DDb91Fc38EF24C20F2628d], value: 100000000000000000000 [1e20])
│ ├─ emit LiquidityAdded(liquidityProvider: liquidityProvider: [0xE9323E1440012e53E2DDb91Fc38EF24C20F2628d], wethDeposited: 100000000000000000000 [1e20], poolTokensDeposited: 100000000000000000000 [1e20])
│ ├─ [31619] ERC20Mock::transferFrom(liquidityProvider: [0xE9323E1440012e53E2DDb91Fc38EF24C20F2628d], TSwapPool: [0xF62849F9A0B5Bf2913b396098F7c7019b51A820a], 100000000000000000000 [1e20])
│ │ ├─ emit Transfer(from: liquidityProvider: [0xE9323E1440012e53E2DDb91Fc38EF24C20F2628d], to: TSwapPool: [0xF62849F9A0B5Bf2913b396098F7c7019b51A820a], value: 100000000000000000000 [1e20])
│ │ └─ ← [Return] true
│ ├─ [31619] ERC20Mock::transferFrom(liquidityProvider: [0xE9323E1440012e53E2DDb91Fc38EF24C20F2628d], TSwapPool: [0xF62849F9A0B5Bf2913b396098F7c7019b51A820a], 100000000000000000000 [1e20])
│ │ ├─ emit Transfer(from: liquidityProvider: [0xE9323E1440012e53E2DDb91Fc38EF24C20F2628d], to: TSwapPool: [0xF62849F9A0B5Bf2913b396098F7c7019b51A820a], value: 100000000000000000000 [1e20])
│ │ └─ ← [Return] true
│ └─ ← [Return] 100000000000000000000 [1e20]
├─ [0] VM::stopPrank()
│ └─ ← [Return]
├─ [851] ERC20Mock::balanceOf(TSwapPool: [0xF62849F9A0B5Bf2913b396098F7c7019b51A820a]) [staticcall]
│ └─ ← [Return] 100000000000000000000 [1e20]
├─ [0] VM::startPrank(user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D])
│ └─ ← [Return]
├─ [25321] TSwapPool::approve(TSwapPool: [0xF62849F9A0B5Bf2913b396098F7c7019b51A820a], 100000000000000000000 [1e20])
│ ├─ emit Approval(owner: user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], spender: TSwapPool: [0xF62849F9A0B5Bf2913b396098F7c7019b51A820a], value: 100000000000000000000 [1e20])
│ └─ ← [Return] true
├─ [36017] TSwapPool::swapExactOutput(ERC20Mock: [0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f], ERC20Mock: [0x2e234DAe75C793f67A35089C9d99245E1C58470b], 100000000000000000 [1e17], 1)
│ ├─ [851] ERC20Mock::balanceOf(TSwapPool: [0xF62849F9A0B5Bf2913b396098F7c7019b51A820a]) [staticcall]
│ │ └─ ← [Return] 100000000000000000000 [1e20]
│ ├─ [851] ERC20Mock::balanceOf(TSwapPool: [0xF62849F9A0B5Bf2913b396098F7c7019b51A820a]) [staticcall]
│ │ └─ ← [Return] 100000000000000000000 [1e20]
│ ├─ emit Swap(swapper: user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], tokenIn: ERC20Mock: [0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f], amountTokenIn: 1004013040121365096 [1.004e18], tokenOut: ERC20Mock: [0x2e234DAe75C793f67A35089C9d99245E1C58470b], amountTokenOut: 100000000000000000 [1e17])
│ ├─ [3789] ERC20Mock::transferFrom(user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], TSwapPool: [0xF62849F9A0B5Bf2913b396098F7c7019b51A820a], 1004013040121365096 [1.004e18])
│ │ └─ ← [Revert] ERC20InsufficientAllowance(0xF62849F9A0B5Bf2913b396098F7c7019b51A820a, 0, 1004013040121365096 [1.004e18])
│ └─ ← [Revert] ERC20InsufficientAllowance(0xF62849F9A0B5Bf2913b396098F7c7019b51A820a, 0, 1004013040121365096 [1.004e18])
└─ ← [Revert] ERC20InsufficientAllowance(0xF62849F9A0B5Bf2913b396098F7c7019b51A820a, 0, 1004013040121365096 [1.004e18])

Suite result: FAILED. 0 passed; 1 failed; 0 skipped; finished in 25.23ms (7.79ms CPU time)

Ran 1 test suite in 2.23s (25.23ms CPU time): 0 tests passed, 1 failed, 0 skipped (1 total tests)

Failing tests:
Encountered 1 failing test in test/unit/TSwapPool.t.sol:TSwapPoolTest
[FAIL: ERC20InsufficientAllowance(0xF62849F9A0B5Bf2913b396098F7c7019b51A820a, 0, 1004013040121365096 [1.004e18])] testInvariantBroken() (gas: 257998)

[EngrPips]

This error ← [Revert] ERC20InsufficientAllowance(0xF62849F9A0B5Bf2913b396098F7c7019b51A820a, 0, 1004013040121365096 [1.004e18]) should not be difficult to figure out. InsufficientAllowance means you didn't give allowance to user A to spend the token user B, but user A tried to spend the token of user B

[SpringxDSay]

I just realised it should have been poolToken.approve() not pool.approve()

[EngrPips]

Awesome, This error sometimes can be easily figured out with just patience and carefully reading of the error messages.

[0xHajime]

@EngrPips Hi, I have this issue

[EngrPips]

Hello @0xHajime, Your process is reverting with a custom error (TSwapPool__MaxPoolTokenDepositTooHigh) This is an error you created and used yourself, so it should be easy to figure out what is wrong and fix it. Basically, it means the amount of pool token you are trying to deposit is too high which makes me think maybe you didn't properly bound some variables.