StatefulFuzzCatchesTest passed instead of it to fail.

[Kidhapelmzy]

Writing the invariant(stateful) test for StatefulFuzzCatches, it passed even though it wa supposed to fail.

pragma solidity 0.8.20;

// INVARIANT: doMoreMathAgain should never return 0
contract StatefulFuzzCatches {
    uint256 public myValue = 1;
    uint256 public storedValue = 100;

    /*
     * @dev Should never return 0
     */
    function doMoreMathAgain(uint128 myNumber) public returns (uint256) {
        uint256 response = (uint256(myNumber) / 1) + myValue + 1;
        storedValue = response;
        return response;
    }

    function changeValue(uint256 newValue) public {
        myValue = newValue;
    }
}

here is the test suit

pragma solidity 0.8.20;

import {Test} from "forge-std/Test.sol";

import {StatefulFuzzCatches} from "../../src/invariant-break/StatefulFuzzCatches.sol";
import {StdInvariant} from "forge-std/StdInvariant.sol";

contract StatefulFuzzCatchesTest is StdInvariant, Test {
    StatefulFuzzCatches statefulFuzzCatches;

    function setUp() public {
        statefulFuzzCatches = new StatefulFuzzCatches();
        // Set the target contract to the StatefulFuzzCatches contract.
        targetContract(address(statefulFuzzCatches));
    }

    function testDoMoreMathAgain(uint128 randomNumber) public {
        assert(statefulFuzzCatches.doMoreMathAgain(randomNumber) != 0);
    }

    function statefulFuzz_catchesInvariant() public view {
        assert(statefulFuzzCatches.storedValue() != 0);
    }
}

did i miss something, help please because this test is supposed to break the invariant.

[EngrPips]

The doMoreMathAgain function in the course repo is different from yours? Why is that?

THE COURSE REPO doMoreMathAgain FUNCTION

function doMoreMathAgain(uint128 myNumber) public returns (uint256) {
        uint256 response = (uint256(myNumber) / 1) + myValue;
        storedValue = response;
        return response;
    }

YOUR doMoreMathAgain FUNCTION

function doMoreMathAgain(uint128 myNumber) public returns (uint256) {
        uint256 response = (uint256(myNumber) / 1) + myValue + 1;
        storedValue = response;
        return response;
    }

Where did you see the + 1 in this line uint256 response = (uint256(myNumber) / 1) + myValue + 1;

[EngrPips]

it worked thanks. But it didn't work for the handlerStatefulFuzzCatches, that also was suppose to fail instead it passed.

If you have gone this far, you need to start learning how to tinker to make stuff work. I just wanted to let you know that not all answer will be provided to you.

[Kidhapelmzy]

I understand, but can you help me with a number of things to look out for when i encounter problems like this. Obviously nothing is wrong with the code itself, but there might be other factors responsible for giving wrong or unexpected outputs. Just like you said "tinker" . Big thanks.

[EngrPips]

I think first of all you need to understand the implementation contract that you want to fuzz what I mean by that is you need to understand the contract behavior and know what is the invariant of the contract so base on that you can understand what to look at if the test does not fail as you expect, also there is no golden seed that works for every contract so you may need to try different seed to break different contract. Finally, increasing the number of runs sometimes can give you the extra run you need to break the contract.

[Kidhapelmzy]

Thanks thanks thanks.

[EngrPips]

Any time, Friend. Keep crushing it.

[Kidhapelmzy]

here is the code base for the attemptedBreakTest

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

import {Test} from "forge-std/Test.sol";
import {StdInvariant} from "forge-std/StdInvariant.sol";
import {HandlerStatefulFuzzCatches} from "../../../src/invariant-break/HandlerStatefulFuzzCatches.sol";
import {MockUSDC} from "../../mocks/MockUSDC.sol";
import {YeildERC20} from "../../mocks/YeildERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract AttemptedBreakTest is StdInvariant, Test {
    HandlerStatefulFuzzCatches handlerStatefulFuzzCatches;
    MockUSDC mockUSDC;
    YeildERC20 yeildERC20;
    IERC20[] supportedTokens;
    uint256 startingAmount;

    address user = makeAddr("user");

    function setUp() public {
        vm.startPrank(user);
        yeildERC20 = new YeildERC20();
        mockUSDC = new MockUSDC();
        startingAmount = yeildERC20.INITIAL_SUPPLY();
        mockUSDC.mint(user, startingAmount);
        vm.stopPrank();

        supportedTokens.push(mockUSDC);
        supportedTokens.push(yeildERC20);
        handlerStatefulFuzzCatches = new HandlerStatefulFuzzCatches(
            supportedTokens
        );

        targetContract(address(handlerStatefulFuzzCatches));
    }

    function testStartingAmountTheSame() public {
        assert(startingAmount == yeildERC20.balanceOf(user));
        assert(startingAmount == mockUSDC.balanceOf(user));
    }

    function statefulFuzz_testInvariantBreaks() public {
        vm.startPrank(user);
        handlerStatefulFuzzCatches.withdrawToken(mockUSDC);
        handlerStatefulFuzzCatches.withdrawToken(yeildERC20);
        vm.stopPrank();

        assert(mockUSDC.balanceOf(address(handlerStatefulFuzzCatches)) == 0);
        assert(yeildERC20.balanceOf(address(handlerStatefulFuzzCatches)) == 0);

        assert(mockUSDC.balanceOf(user) == startingAmount);
        assert(yeildERC20.balanceOf(user) == startingAmount);
    }
}

[Kidhapelmzy]

this is the code base for HandlerStatefulFuzzCatches

pragma solidity 0.8.20;

import {IERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

/*
 * This contract represents a vault for ERC20 tokens.
 *
 * INVARIANT: Users must always be able to withdraw the exact balance amout out. 
 */
contract HandlerStatefulFuzzCatches {
    error HandlerStatefulFuzzCatches__UnsupportedToken();

    using SafeERC20 for IERC20;

    mapping(IERC20 => bool) public tokenIsSupported;
    mapping(address user => mapping(IERC20 token => uint256 balance)) public tokenBalances;

    modifier requireSupportedToken(IERC20 token) {
        if (!tokenIsSupported[token]) revert HandlerStatefulFuzzCatches__UnsupportedToken();
        _;
    }

    constructor(IERC20[] memory _supportedTokens) {
        for (uint256 i; i < _supportedTokens.length; i++) {
            tokenIsSupported[_supportedTokens[i]] = true;
        }
    }

    function depositToken(IERC20 token, uint256 amount) external requireSupportedToken(token) {
        tokenBalances[msg.sender][token] += amount;
        token.safeTransferFrom(msg.sender, address(this), amount);
    }

    function withdrawToken(IERC20 token) external requireSupportedToken(token) {
        uint256 currentBalance = tokenBalances[msg.sender][token];
        tokenBalances[msg.sender][token] = 0;
        token.safeTransfer(msg.sender, currentBalance);
    }
}

[brunacunha]

I also had this problem. Sometimes, as the runs are put on randomly, the number of runs inside your foundry.toml needs to be higher. Give it a try and tell me what happened. 😄

[EngrPips]

Great Heads-up.