Foundry, composed of the Forge testing framework and the Cast toolkit for Ethereum smart contracts, integrates seamlessly with stateless fuzzing methodologies. Forge is designed with both stateless and stateful fuzzing in mind, providing developers with the necessary tools to conduct comprehensive testing of their smart contracts.

Implementing Stateless Fuzzing with Foundry

Below is a step-by-step guide to implementing stateless fuzzing on a simple Automated Market Maker (AMM) smart contract using Foundry. This example will highlight key invariants within the smart contract and demonstrate how to write and run stateless fuzz tests using Forge.

Step 1: Setup Foundry

Make sure Foundry is installed and updated in your development environment. You can initialize a new Foundry project by executing:

forge init my_project
cd my_project

Step 2: Define the Smart Contract

Consider a simple AMM smart contract, SimpleAMM.sol, with functions to add liquidity, remove liquidity, and swap tokens. The contract maintains reserves for two tokens (TokenA and TokenB) and ensures certain invariants such as the constant product formula and non-negativity of reserves.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract SimpleAMM {
    uint256 public constant MINIMUM_RESERVE_THRESHOLD = 500;
    uint256 public reserveTokenA;
    uint256 public reserveTokenB;
    uint256 public constantProduct;

    // Contract functions (addLiquidity, removeLiquidity, swapTokenAForTokenB)...

Step 3: Identify Invariants

Before writing tests, identify the invariants for SimpleAMM.sol. Examples include:

  • Constant Product Invariant: After any operation (add/remove liquidity, swap), the product of the reserves (reserveTokenA * reserveTokenB) should equal constantProduct.
  • Reserve Non-Negativity: The reserves (reserveTokenA and reserveTokenB) must never be negative.
  • Positive Liquidity: Liquidity added must always be positive.

Step 4: Writing Stateless Fuzz Tests

Create a test file in the test directory, for example, SimpleAMM.t.sol, and write stateless fuzz tests using Forge. Here’s how you might test the Constant Product Invariant:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "forge-std/Test.sol";
import "../src/SimpleAMM.sol";

contract SimpleAMMTest is Test {
    SimpleAMM simpleAMM;

    function setUp() public {
        simpleAMM = new SimpleAMM();
        simpleAMM.addLiquidity(1000, 1000); // Initial liquidity

    // Test Constant Product Invariant
    function testConstantProductInvariant() public {
        uint256 a = uint256(keccak256(abi.encodePacked(block.timestamp, block.difficulty))) % 1000;
        uint256 b = uint256(keccak256(abi.encodePacked(block.timestamp, block.difficulty))) % 1000;
        simpleAMM.addLiquidity(a, b);
        uint256 product = simpleAMM.reserveTokenA() * simpleAMM.reserveTokenB();
        assertEq(product, simpleAMM.constantProduct(), "Constant Product Invariant violated");

Step 5: Running the Tests

To execute the fuzz tests, run the following command in your project’s root directory:

forge test

Forge will automatically generate random inputs for your test functions and execute them, reporting any failures or violations of the invariants you’ve specified.


Stateless fuzzing is a powerful technique for ensuring the security and correctness of smart contracts. By leveraging Foundry’s Forge, developers can automate the process of generating random inputs to test their

contracts’ invariants thoroughly. Implementing stateless fuzzing as part of the smart contract development and testing lifecycle can significantly reduce the risk of vulnerabilities and ensure the reliability of blockchain applications.