Section 5: for some reason, the handler contract is not fuzzing !!!!! #181

Loko0125 · 2024-05-15T23:13:39Z

Loko0125
May 15, 2024

when I run "forge test --mt statefulFuzz_constantProductFormulaStayTheSame" the handler contract is not fuzzing. i tried everything but i don't know where is the issue !!!

Functions in Invariant contract:

``

// 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 "../Mock/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 {
    // these pool have 2 assets
    ERC20Mock poolToken;
    ERC20Mock weth;

//We need contracts
PoolFactory factory;
TSwapPool pool; // poolToken /Weth
Handler handler;

int256 constant STARTING_X = 100e18;
int256 constant STARTING_Y = 50e18;

function setUp() public {
    poolToken = new ERC20Mock();
    weth = new ERC20Mock();

    factory = new PoolFactory(address(weth));
    pool = TSwapPool(factory.createPool(address(poolToken)));

    // create those intila X and Y balances
    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);

    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_constantProductFormulaStayTheSame() public {
    assertEq(handler.actualDeltaX(), handler.expectedDeltaX());
}

}

``

Functions in handler contract:

`

// 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 "../Mock/ERC20Mock.sol";

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

//Gost variables
int256 public startingY;
int256 public startingX;

int256 public expectedDeltaY;
int256 public expectedDeltaX;

int256 public actualDeltaX;
int256 public actualDeltaY;

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

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

function swapPoolTokenForWethBasedOnOutputweth(uint256 outputweth) public {
    outputweth = bound(outputweth, pool.getMinimumWethDepositAmount(), type(uint64).max);
    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(uint64).max) {
        return;
    }

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

    expectedDeltaY = int256(-1) * int256(outputweth);
    expectedDeltaX = int256(pool.getPoolTokensToDepositBasedOnWeth(poolTokenAmount));

    if (poolToken.balanceOf(swapper) < poolTokenAmount) {
        poolToken.mint(swapper, poolTokenAmount - poolToken.balanceOf(swapper) + 1);
    }

    //swap
    vm.startPrank(swapper);
    poolToken.approve(address(pool), type(uint256).max);
    pool.swapExactOutput(poolToken, weth, outputweth, uint64(block.timestamp));
    vm.stopPrank();

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

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

function deposit(uint256 wethAmount) public {
    // let's make sure to deposit reasonable amount
    // avoid overflow
    wethAmount = bound(wethAmount, 0, type(uint64).max);
    //18.446744073709551615

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

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

    //deposit
    vm.startPrank(liquidityProvider);
    weth.mint(liquidityProvider, uint256(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(this));
    uint256 endingX = poolToken.balanceOf(address(this));

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

}
`

This is my output after run "forge test --mt statefulFuzz_constantProductFormulaStayTheSame -vvvv''

`
Running 1 test for test/unit/Invariant/Invariant.t.sol:Invariant
[FAIL. Reason: Invalid data] statefulFuzz_constantProductFormulaStayTheSame() (runs: 1, calls: 0, reverts: 0)
Traces:
[6638429] Invariant::setUp()
├─ [430367] → new ERC20Mock@0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f
│ └─ ← 1924 bytes of code
├─ [430367] → new ERC20Mock@0x2e234DAe75C793f67A35089C9d99245E1C58470b
│ └─ ← 1924 bytes of code
├─ [1940285] → new PoolFactory@0xF62849F9A0B5Bf2913b396098F7c7019b51A820a
│ └─ ← 9690 bytes of code
├─ [1601851] PoolFactory::createPool(ERC20Mock: [0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f])
│ ├─ [1178] ERC20Mock::name() [staticcall]
│ │ └─ ← mock
│ ├─ [1178] ERC20Mock::name() [staticcall]
│ │ └─ ← mock
│ ├─ [1516432] → new TSwapPool@0x4f81992FCe2E1846dD528eC0102e6eE1f61ed3e2
│ │ └─ ← 7330 bytes of code
│ ├─ emit PoolCreated(tokenAddress: ERC20Mock: [0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f], poolAddress: TSwapPool: [0x4f81992FCe2E1846dD528eC0102e6eE1f61ed3e2])
│ └─ ← TSwapPool: [0x4f81992FCe2E1846dD528eC0102e6eE1f61ed3e2]
├─ [46789] ERC20Mock::mint(Invariant: [0x7FA9385bE102ac3EAc297483Dd6233D62b3e1496], 100000000000000000000 [1e20])
│ ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: Invariant: [0x7FA9385bE102ac3EAc297483Dd6233D62b3e1496], value: 100000000000000000000 [1e20])
│ └─ ← ()
├─ [46789] ERC20Mock::mint(Invariant: [0x7FA9385bE102ac3EAc297483Dd6233D62b3e1496], 50000000000000000000 [5e19])
│ ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: Invariant: [0x7FA9385bE102ac3EAc297483Dd6233D62b3e1496], value: 50000000000000000000 [5e19])
│ └─ ← ()
├─ [24739] ERC20Mock::approve(TSwapPool: [0x4f81992FCe2E1846dD528eC0102e6eE1f61ed3e2], 115792089237316195423570985008687907853269984665640564039457584007913129639935 [1.157e77])
│ ├─ emit Approval(owner: Invariant: [0x7FA9385bE102ac3EAc297483Dd6233D62b3e1496], spender: TSwapPool: [0x4f81992FCe2E1846dD528eC0102e6eE1f61ed3e2], value: 115792089237316195423570985008687907853269984665640564039457584007913129639935 [1.157e77])
│ └─ ← true
├─ [24739] ERC20Mock::approve(TSwapPool: [0x4f81992FCe2E1846dD528eC0102e6eE1f61ed3e2], 115792089237316195423570985008687907853269984665640564039457584007913129639935 [1.157e77])
│ ├─ emit Approval(owner: Invariant: [0x7FA9385bE102ac3EAc297483Dd6233D62b3e1496], spender: TSwapPool: [0x4f81992FCe2E1846dD528eC0102e6eE1f61ed3e2], value: 115792089237316195423570985008687907853269984665640564039457584007913129639935 [1.157e77])
│ └─ ← true
├─ [82545] TSwapPool::deposit(50000000000000000000 [5e19], 50000000000000000000 [5e19], 100000000000000000000 [1e20], 1)
│ ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: Invariant: [0x7FA9385bE102ac3EAc297483Dd6233D62b3e1496], value: 50000000000000000000 [5e19])
│ ├─ emit LiquidityAdded(liquidityProvider: Invariant: [0x7FA9385bE102ac3EAc297483Dd6233D62b3e1496], wethDeposited: 100000000000000000000 [1e20], poolTokensDeposited: 50000000000000000000 [5e19])
│ ├─ [20499] ERC20Mock::transferFrom(Invariant: [0x7FA9385bE102ac3EAc297483Dd6233D62b3e1496], TSwapPool: [0x4f81992FCe2E1846dD528eC0102e6eE1f61ed3e2], 50000000000000000000 [5e19])
│ │ ├─ emit Transfer(from: Invariant: [0x7FA9385bE102ac3EAc297483Dd6233D62b3e1496], to: TSwapPool: [0x4f81992FCe2E1846dD528eC0102e6eE1f61ed3e2], value: 50000000000000000000 [5e19])
│ │ └─ ← true
│ ├─ [20499] ERC20Mock::transferFrom(Invariant: [0x7FA9385bE102ac3EAc297483Dd6233D62b3e1496], TSwapPool: [0x4f81992FCe2E1846dD528eC0102e6eE1f61ed3e2], 100000000000000000000 [1e20])
│ │ ├─ emit Transfer(from: Invariant: [0x7FA9385bE102ac3EAc297483Dd6233D62b3e1496], to: TSwapPool: [0x4f81992FCe2E1846dD528eC0102e6eE1f61ed3e2], value: 100000000000000000000 [1e20])
│ │ └─ ← true
│ └─ ← 50000000000000000000 [5e19]
├─ [1663433] → new Handler@0x5991A2dF15A8F6A256D3Ec51E99254Cd3fb576A9
│ ├─ [0] VM::addr() [staticcall]
│ │ └─ ← lp: [0x44bC268D6f10DfB004c5b9afe91648b1c7c8b6D9]
│ ├─ [0] VM::label(lp: [0x44bC268D6f10DfB004c5b9afe91648b1c7c8b6D9], lp)
│ │ └─ ← ()
│ ├─ [0] VM::addr() [staticcall]
│ │ └─ ← swapper: [0x4A9D6b0b19CBFfCB0255550661eCB7014283c60E]
│ ├─ [0] VM::label(swapper: [0x4A9D6b0b19CBFfCB0255550661eCB7014283c60E], swapper)
│ │ └─ ← ()
│ ├─ [270] TSwapPool::getWeth() [staticcall]
│ │ └─ ← ERC20Mock: [0x2e234DAe75C793f67A35089C9d99245E1C58470b]
│ ├─ [279] TSwapPool::getPoolToken() [staticcall]
│ │ └─ ← ERC20Mock: [0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f]
│ └─ ← 7607 bytes of code
└─ ← ()

[13192] Invariant::statefulFuzz_constantProductFormulaStayTheSame()
├─ [2351] Handler::actualDeltaX() [staticcall]
│ └─ ← 0
├─ [2308] Handler::expectedDeltaX() [staticcall]
│ └─ ← 0
├─ [0] VM::assertEq(0, 0) [staticcall]
│ └─ ← "Invalid data"
└─ ← "Invalid data"

Test result: FAILED. 0 passed; 1 failed; 0 skipped; finished in 10.10ms
Ran 1 test suites: 0 tests passed, 1 failed, 0 skipped (1 total tests)

Failing tests:
Encountered 1 failing test in test/unit/Invariant/Invariant.t.sol:Invariant
[FAIL. Reason: Invalid data] statefulFuzz_constantProductFormulaStayTheSame() (runs: 1, calls: 0, reverts: 0)

Encountered a total of 1 failing tests, 0 tests succeeded`

i have no idea why functions in my handler contract not fuzzing ? (i'm still learning and any help will be so much appreciated)

Answered by EngrPips

May 16, 2024

Hello @Loko0125, Please run foundryup, then retry running the test and show your foundry.toml. The image below shows mine.

View full answer

EngrPips · 2024-05-16T07:20:27Z

EngrPips
May 16, 2024

// 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 "../Mock/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 {
    // these pool have 2 assets
    ERC20Mock poolToken;
    ERC20Mock weth;

//We need contracts
PoolFactory factory;
TSwapPool pool; // poolToken /Weth
Handler handler;

int256 constant STARTING_X = 100e18;
int256 constant STARTING_Y = 50e18;

function setUp() public {
    poolToken = new ERC20Mock();
    weth = new ERC20Mock();

    factory = new PoolFactory(address(weth));
    pool = TSwapPool(factory.createPool(address(poolToken)));

    // create those intila X and Y balances
    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);

    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_constantProductFormulaStayTheSame() public {
    assertEq(handler.actualDeltaX(), handler.expectedDeltaX());
}
}

0 replies

EngrPips · 2024-05-16T07:21:11Z

EngrPips
May 16, 2024

// 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 "../Mock/ERC20Mock.sol";

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

//Gost variables
int256 public startingY;
int256 public startingX;

int256 public expectedDeltaY;
int256 public expectedDeltaX;

int256 public actualDeltaX;
int256 public actualDeltaY;

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

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

function swapPoolTokenForWethBasedOnOutputweth(uint256 outputweth) public {
    outputweth = bound(outputweth, pool.getMinimumWethDepositAmount(), type(uint64).max);
    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(uint64).max) {
        return;
    }

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

    expectedDeltaY = int256(-1) * int256(outputweth);
    expectedDeltaX = int256(pool.getPoolTokensToDepositBasedOnWeth(poolTokenAmount));

    if (poolToken.balanceOf(swapper) < poolTokenAmount) {
        poolToken.mint(swapper, poolTokenAmount - poolToken.balanceOf(swapper) + 1);
    }

    //swap
    vm.startPrank(swapper);
    poolToken.approve(address(pool), type(uint256).max);
    pool.swapExactOutput(poolToken, weth, outputweth, uint64(block.timestamp));
    vm.stopPrank();

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

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

function deposit(uint256 wethAmount) public {
    // let's make sure to deposit reasonable amount
    // avoid overflow
    wethAmount = bound(wethAmount, 0, type(uint64).max);
    //18.446744073709551615

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

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

    //deposit
    vm.startPrank(liquidityProvider);
    weth.mint(liquidityProvider, uint256(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(this));
    uint256 endingX = poolToken.balanceOf(address(this));

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

1 reply

EngrPips May 16, 2024

Running 1 test for test/unit/Invariant/Invariant.t.sol:Invariant
[FAIL. Reason: Invalid data] statefulFuzz_constantProductFormulaStayTheSame() (runs: 1, calls: 0, reverts: 0)
Traces:
[6638429] Invariant::setUp()
├─ [430367] → new ERC20Mock@0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f
│ └─ ← 1924 bytes of code
├─ [430367] → new ERC20Mock@0x2e234DAe75C793f67A35089C9d99245E1C58470b
│ └─ ← 1924 bytes of code
├─ [1940285] → new PoolFactory@0xF62849F9A0B5Bf2913b396098F7c7019b51A820a
│ └─ ← 9690 bytes of code
├─ [1601851] PoolFactory::createPool(ERC20Mock: [0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f])
│ ├─ [1178] ERC20Mock::name() [staticcall]
│ │ └─ ← mock
│ ├─ [1178] ERC20Mock::name() [staticcall]
│ │ └─ ← mock
│ ├─ [1516432] → new TSwapPool@0x4f81992FCe2E1846dD528eC0102e6eE1f61ed3e2
│ │ └─ ← 7330 bytes of code
│ ├─ emit PoolCreated(tokenAddress: ERC20Mock: [0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f], poolAddress: TSwapPool: [0x4f81992FCe2E1846dD528eC0102e6eE1f61ed3e2])
│ └─ ← TSwapPool: [0x4f81992FCe2E1846dD528eC0102e6eE1f61ed3e2]
├─ [46789] ERC20Mock::mint(Invariant: [0x7FA9385bE102ac3EAc297483Dd6233D62b3e1496], 100000000000000000000 [1e20])
│ ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: Invariant: [0x7FA9385bE102ac3EAc297483Dd6233D62b3e1496], value: 100000000000000000000 [1e20])
│ └─ ← ()
├─ [46789] ERC20Mock::mint(Invariant: [0x7FA9385bE102ac3EAc297483Dd6233D62b3e1496], 50000000000000000000 [5e19])
│ ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: Invariant: [0x7FA9385bE102ac3EAc297483Dd6233D62b3e1496], value: 50000000000000000000 [5e19])
│ └─ ← ()
├─ [24739] ERC20Mock::approve(TSwapPool: [0x4f81992FCe2E1846dD528eC0102e6eE1f61ed3e2], 115792089237316195423570985008687907853269984665640564039457584007913129639935 [1.157e77])
│ ├─ emit Approval(owner: Invariant: [0x7FA9385bE102ac3EAc297483Dd6233D62b3e1496], spender: TSwapPool: [0x4f81992FCe2E1846dD528eC0102e6eE1f61ed3e2], value: 115792089237316195423570985008687907853269984665640564039457584007913129639935 [1.157e77])
│ └─ ← true
├─ [24739] ERC20Mock::approve(TSwapPool: [0x4f81992FCe2E1846dD528eC0102e6eE1f61ed3e2], 115792089237316195423570985008687907853269984665640564039457584007913129639935 [1.157e77])
│ ├─ emit Approval(owner: Invariant: [0x7FA9385bE102ac3EAc297483Dd6233D62b3e1496], spender: TSwapPool: [0x4f81992FCe2E1846dD528eC0102e6eE1f61ed3e2], value: 115792089237316195423570985008687907853269984665640564039457584007913129639935 [1.157e77])
│ └─ ← true
├─ [82545] TSwapPool::deposit(50000000000000000000 [5e19], 50000000000000000000 [5e19], 100000000000000000000 [1e20], 1)
│ ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: Invariant: [0x7FA9385bE102ac3EAc297483Dd6233D62b3e1496], value: 50000000000000000000 [5e19])
│ ├─ emit LiquidityAdded(liquidityProvider: Invariant: [0x7FA9385bE102ac3EAc297483Dd6233D62b3e1496], wethDeposited: 100000000000000000000 [1e20], poolTokensDeposited: 50000000000000000000 [5e19])
│ ├─ [20499] ERC20Mock::transferFrom(Invariant: [0x7FA9385bE102ac3EAc297483Dd6233D62b3e1496], TSwapPool: [0x4f81992FCe2E1846dD528eC0102e6eE1f61ed3e2], 50000000000000000000 [5e19])
│ │ ├─ emit Transfer(from: Invariant: [0x7FA9385bE102ac3EAc297483Dd6233D62b3e1496], to: TSwapPool: [0x4f81992FCe2E1846dD528eC0102e6eE1f61ed3e2], value: 50000000000000000000 [5e19])
│ │ └─ ← true
│ ├─ [20499] ERC20Mock::transferFrom(Invariant: [0x7FA9385bE102ac3EAc297483Dd6233D62b3e1496], TSwapPool: [0x4f81992FCe2E1846dD528eC0102e6eE1f61ed3e2], 100000000000000000000 [1e20])
│ │ ├─ emit Transfer(from: Invariant: [0x7FA9385bE102ac3EAc297483Dd6233D62b3e1496], to: TSwapPool: [0x4f81992FCe2E1846dD528eC0102e6eE1f61ed3e2], value: 100000000000000000000 [1e20])
│ │ └─ ← true
│ └─ ← 50000000000000000000 [5e19]
├─ [1663433] → new Handler@0x5991A2dF15A8F6A256D3Ec51E99254Cd3fb576A9
│ ├─ [0] VM::addr() [staticcall]
│ │ └─ ← lp: [0x44bC268D6f10DfB004c5b9afe91648b1c7c8b6D9]
│ ├─ [0] VM::label(lp: [0x44bC268D6f10DfB004c5b9afe91648b1c7c8b6D9], lp)
│ │ └─ ← ()
│ ├─ [0] VM::addr() [staticcall]
│ │ └─ ← swapper: [0x4A9D6b0b19CBFfCB0255550661eCB7014283c60E]
│ ├─ [0] VM::label(swapper: [0x4A9D6b0b19CBFfCB0255550661eCB7014283c60E], swapper)
│ │ └─ ← ()
│ ├─ [270] TSwapPool::getWeth() [staticcall]
│ │ └─ ← ERC20Mock: [0x2e234DAe75C793f67A35089C9d99245E1C58470b]
│ ├─ [279] TSwapPool::getPoolToken() [staticcall]
│ │ └─ ← ERC20Mock: [0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f]
│ └─ ← 7607 bytes of code
└─ ← ()

[13192] Invariant::statefulFuzz_constantProductFormulaStayTheSame()
├─ [2351] Handler::actualDeltaX() [staticcall]
│ └─ ← 0
├─ [2308] Handler::expectedDeltaX() [staticcall]
│ └─ ← 0
├─ [0] VM::assertEq(0, 0) [staticcall]
│ └─ ← "Invalid data"
└─ ← "Invalid data"

Test result: FAILED. 0 passed; 1 failed; 0 skipped; finished in 10.10ms
Ran 1 test suites: 0 tests passed, 1 failed, 0 skipped (1 total tests)

Failing tests:
Encountered 1 failing test in test/unit/Invariant/Invariant.t.sol:Invariant
[FAIL. Reason: Invalid data] statefulFuzz_constantProductFormulaStayTheSame() (runs: 1, calls: 0, reverts: 0)

Encountered a total of 1 failing tests, 0 tests succeeded`

EngrPips · 2024-05-16T08:07:59Z

EngrPips
May 16, 2024

Hello @Loko0125, Please run foundryup, then retry running the test and show your foundry.toml. The image below shows mine.

2 replies

Loko0125 May 16, 2024
Author

Thank you so much, i was stuck for couple days and i just need to run foundryup. thank you again and i appreciate you :)

EngrPips May 16, 2024

You are welcome, Friend. Keep crushing it!

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Section 5: for some reason, the handler contract is not fuzzing !!!!! #181

{{title}}

Replies: 3 comments 3 replies

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

Select a reply

Section 5: for some reason, the handler contract is not fuzzing !!!!! #181

Loko0125 May 15, 2024

Replies: 3 comments · 3 replies

EngrPips May 16, 2024

EngrPips May 16, 2024

EngrPips May 16, 2024

EngrPips May 16, 2024

Loko0125 May 16, 2024 Author

EngrPips May 16, 2024

Loko0125
May 15, 2024

Replies: 3 comments 3 replies

EngrPips
May 16, 2024

EngrPips
May 16, 2024

EngrPips
May 16, 2024

Loko0125 May 16, 2024
Author