Medusa swap tests

README.md

@@ -105,10 +105,10 @@ smarter than Forge. That's because Medusa has an optimizer to create a path of t
 random.
 
 To run Medusa tests, we first need to install Echidna. To do so, install `echidna` using the 
-[release page](https://github.com/crytic/echidna/releases) or `brew install echidna` in Mac. Notice that the Mac
-installation will also install Crytic-compiller, so this step can be skipped when installing Medusa.
+[release page](https://github.com/crytic/echidna/releases) or `brew install echidna` on a Mac. Notice that the Mac
+installation will also install Crytic-compiler, so this step can be skipped when installing Medusa.
 
-Then, install Medusa using this [installation guide](https://github.com/crytic/medusa/blob/master/docs/src/getting_started/installation.md#building-from-source) (or just copy the adequate precompiled binary to a directory within your `PATH`).
+Then, install Medusa using this [installation guide](https://github.com/crytic/medusa/blob/master/docs/src/getting_started/installation.md#building-from-source), `brew install medusa` on a Mac. Alternatively, just copy the adequate precompiled binary to a directory within your `PATH`.
 
 Finally, run `yarn test:medusa`. This command is available inside the packages `vault`, `pool-weighted` and 
 `pool-stable`.

pkg/pool-stable/medusa.json

@@ -8,7 +8,7 @@
     "callSequenceLength": 10,
     "corpusDirectory": "medusa-corpus",
     "coverageEnabled": true,
-    "targetContracts": ["AddAndRemoveLiquidityStableMedusaTest"],
+    "targetContracts": ["AddAndRemoveLiquidityStableMedusaTest", "SwapMedusaTest"],
     "predeployedContracts": {},
     "targetContractsBalances": [],
     "constructorArgs": {},

pkg/pool-stable/test/foundry/fuzz/SwapStable.medusa.sol

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity ^0.8.24;
+
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+import { IVault } from "@balancer-labs/v3-interfaces/contracts/vault/IVault.sol";
+import "@balancer-labs/v3-interfaces/contracts/vault/VaultTypes.sol";
+
+import { SwapMedusaTest } from "@balancer-labs/v3-vault/test/foundry/fuzz/Swap.medusa.sol";
+
+import { StablePoolFactory } from "../../../contracts/StablePoolFactory.sol";
+import { StablePool } from "../../../contracts/StablePool.sol";
+
+contract SwapStableMedusaTest is SwapMedusaTest {
+    uint256 private constant DEFAULT_SWAP_FEE = 1e16;
+    uint256 internal constant _AMPLIFICATION_PARAMETER = 1000;
+
+    constructor() SwapMedusaTest() {}
+
+    function createPool(
+        IERC20[] memory tokens,
+        uint256[] memory initialBalances
+    ) internal override returns (address newPool) {
+        StablePoolFactory factory = new StablePoolFactory(IVault(address(vault)), 365 days, "Factory v1", "Pool v1");
+        PoolRoleAccounts memory roleAccounts;
+
+        StablePool newPool = StablePool(
+            factory.create(
+                "Stable Pool",
+                "STABLE",
+                vault.buildTokenConfig(tokens),
+                _AMPLIFICATION_PARAMETER,
+                roleAccounts,
+                DEFAULT_SWAP_FEE, // Swap fee is set to 0 in the test constructor
+                address(0), // No hooks
+                false, // Do not enable donations
+                false, // Do not disable unbalanced add/remove liquidity
+                // NOTE: sends a unique salt.
+                bytes32(poolCreationNonce++)
+            )
+        );
+
+        // Initialize liquidity of stable pool.
+        medusa.prank(lp);
+        router.initialize(address(newPool), tokens, initialBalances, 0, false, bytes(""));
+
+        return address(newPool);
+    }
+}

pkg/pool-weighted/medusa.json

@@ -8,16 +8,12 @@
     "callSequenceLength": 10,
     "corpusDirectory": "medusa-corpus",
     "coverageEnabled": true,
-    "targetContracts": ["AddAndRemoveLiquidityWeightedMedusaTest"],
+    "targetContracts": ["AddAndRemoveLiquidityWeightedMedusaTest", "SwapMedusaTest"],
     "predeployedContracts": {},
     "targetContractsBalances": [],
     "constructorArgs": {},
     "deployerAddress": "0x30000",
-    "senderAddresses": [
-      "0x10000",
-      "0x20000",
-      "0x30000"
-    ],
+    "senderAddresses": ["0x10000", "0x20000", "0x30000"],
     "blockNumberDelayMax": 60480,
     "blockTimestampDelayMax": 604800,
     "blockGasLimit": 1250000000,
@@ -46,15 +42,11 @@
       },
       "propertyTesting": {
         "enabled": true,
-        "testPrefixes": [
-          "property_"
-        ]
+        "testPrefixes": ["property_"]
       },
       "optimizationTesting": {
         "enabled": true,
-        "testPrefixes": [
-          "optimize_"
-        ]
+        "testPrefixes": ["optimize_"]
       },
       "targetFunctionSignatures": [],
       "excludeFunctionSignatures": []

pkg/pool-weighted/test/foundry/fuzz/SwapWeighted.medusa.sol

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity ^0.8.24;
+
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+import { IVault } from "@balancer-labs/v3-interfaces/contracts/vault/IVault.sol";
+import "@balancer-labs/v3-interfaces/contracts/vault/VaultTypes.sol";
+
+import { SwapMedusaTest } from "@balancer-labs/v3-vault/test/foundry/fuzz/Swap.medusa.sol";
+
+import { WeightedPoolFactory } from "../../../contracts/WeightedPoolFactory.sol";
+import { WeightedPool } from "../../../contracts/WeightedPool.sol";
+
+contract SwapWeightedMedusaTest is SwapMedusaTest {
+    uint256 private constant DEFAULT_SWAP_FEE = 1e16;
+
+    uint256 private constant _WEIGHT1 = 33e16;
+    uint256 private constant _WEIGHT2 = 33e16;
+
+    constructor() SwapMedusaTest() {}
+
+    function createPool(
+        IERC20[] memory tokens,
+        uint256[] memory initialBalances
+    ) internal override returns (address newPool) {
+        uint256[] memory weights = new uint256[](3);
+        weights[0] = _WEIGHT1;
+        weights[1] = _WEIGHT2;
+        // Sum of weights should equal 100%.
+        weights[2] = 100e16 - (weights[0] + weights[1]);
+
+        WeightedPoolFactory factory = new WeightedPoolFactory(
+            IVault(address(vault)),
+            365 days,
+            "Factory v1",
+            "Pool v1"
+        );
+        PoolRoleAccounts memory roleAccounts;
+
+        WeightedPool newPool = WeightedPool(
+            factory.create(
+                "Weighted Pool",
+                "WP",
+                vault.buildTokenConfig(tokens),
+                weights,
+                roleAccounts,
+                DEFAULT_SWAP_FEE, // Swap fee is set to 0 in the test constructor
+                address(0), // No hooks
+                false, // Do not enable donations
+                false, // Do not disable unbalanced add/remove liquidity
+                // NOTE: sends a unique salt.
+                bytes32(poolCreationNonce++)
+            )
+        );
+
+        // Initialize liquidity of weighted pool.
+        medusa.prank(lp);
+        router.initialize(address(newPool), tokens, initialBalances, 0, false, bytes(""));
+
+        return address(newPool);
+    }
+}

pkg/vault/medusa.json

@@ -8,16 +8,12 @@
     "callSequenceLength": 10,
     "corpusDirectory": "medusa-corpus",
     "coverageEnabled": true,
-    "targetContracts": ["AddAndRemoveLiquidityMedusaTest"],
+    "targetContracts": ["AddAndRemoveLiquidityMedusaTest", "SwapMedusaTest"],
     "predeployedContracts": {},
     "targetContractsBalances": [],
     "constructorArgs": {},
     "deployerAddress": "0x30000",
-    "senderAddresses": [
-      "0x10000",
-      "0x20000",
-      "0x30000"
-    ],
+    "senderAddresses": ["0x10000", "0x20000", "0x30000"],
     "blockNumberDelayMax": 60480,
     "blockTimestampDelayMax": 604800,
     "blockGasLimit": 1250000000,
@@ -46,15 +42,11 @@
       },
       "propertyTesting": {
         "enabled": true,
-        "testPrefixes": [
-          "property_"
-        ]
+        "testPrefixes": ["property_"]
       },
       "optimizationTesting": {
         "enabled": true,
-        "testPrefixes": [
-          "optimize_"
-        ]
+        "testPrefixes": ["optimize_"]
       },
       "targetFunctionSignatures": [],
       "excludeFunctionSignatures": []

pkg/vault/test/foundry/fuzz/Swap.medusa.sol

@@ -0,0 +1,120 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity ^0.8.24;
+
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+import { IBasePool } from "@balancer-labs/v3-interfaces/contracts/vault/IBasePool.sol";
+import { Rounding } from "@balancer-labs/v3-interfaces/contracts/vault/VaultTypes.sol";
+
+import { FixedPoint } from "@balancer-labs/v3-solidity-utils/contracts/math/FixedPoint.sol";
+import { InputHelpers } from "@balancer-labs/v3-solidity-utils/contracts/helpers/InputHelpers.sol";
+
+import { BasePoolMath } from "../../../contracts/BasePoolMath.sol";
+import { BalancerPoolToken } from "../../../contracts/BalancerPoolToken.sol";
+
+import "../utils/BaseMedusaTest.sol";
+
+contract SwapMedusaTest is BaseMedusaTest {
+    using FixedPoint for uint256;
+
+    uint256 internal constant MIN_SWAP_AMOUNT = 1e6;
+    uint256 constant MAX_IN_RATIO = 0.3e18;
+
+    int256 internal initInvariant;
+
+    constructor() BaseMedusaTest() {
+        initInvariant = computeInvariant();
+        vault.manuallySetSwapFee(address(pool), 0);
+
+        emit Debug("prevInvariant", initInvariant);
+    }
+
+    function optimize_currentInvariant() public view returns (int256) {
+        return -int256(computeInvariant());
+    }
+
+    function property_currentInvariant() public returns (bool) {
+        int256 currentInvariant = computeInvariant();
+        return currentInvariant >= initInvariant;
+    }
+
+    function computeSwapExactIn(uint256 tokenIndexIn, uint256 tokenIndexOut, uint256 exactAmountIn) public {
+        (tokenIndexIn, tokenIndexOut) = boundTokenIndexes(tokenIndexIn, tokenIndexOut);
+
+        exactAmountIn = boundSwapAmount(exactAmountIn, tokenIndexIn);
+
+        (IERC20[] memory tokens, , , ) = vault.getPoolTokenInfo(address(pool));
+
+        emit Debug("token index in", tokenIndexIn);
+        emit Debug("token index out", tokenIndexOut);
+        emit Debug("exact amount in", exactAmountIn);
+
+        medusa.prank(alice);
+        router.swapSingleTokenExactIn(
+            address(pool),
+            tokens[tokenIndexIn],
+            tokens[tokenIndexOut],
+            exactAmountIn,
+            0,
+            MAX_UINT256,
+            false,
+            bytes("")
+        );
+
+        emit Debug("currentInvariant", computeInvariant());
+    }
+
+    function computeSwapExactOut(uint256 tokenIndexIn, uint256 tokenIndexOut, uint256 exactAmountOut) public {
+        (tokenIndexIn, tokenIndexOut) = boundTokenIndexes(tokenIndexIn, tokenIndexOut);
+
+        exactAmountOut = boundSwapAmount(exactAmountOut, tokenIndexOut);
+
+        (IERC20[] memory tokens, , , ) = vault.getPoolTokenInfo(address(pool));
+
+        emit Debug("token index in", tokenIndexIn);
+        emit Debug("token index out", tokenIndexOut);
+        emit Debug("exact amount out", exactAmountOut);
+
+        medusa.prank(alice);
+        router.swapSingleTokenExactOut(
+            address(pool),
+            tokens[tokenIndexIn],
+            tokens[tokenIndexOut],
+            exactAmountOut,
+            MAX_UINT256,
+            MAX_UINT256,
+            false,
+            bytes("")
+        );
+
+        emit Debug("currentInvariant", computeInvariant());
+    }
+
+    function computeInvariant() internal view returns (int256) {
+        (, , , uint256[] memory lastBalancesLiveScaled18) = vault.getPoolTokenInfo(address(pool));
+        return int256(pool.computeInvariant(lastBalancesLiveScaled18, Rounding.ROUND_UP));
+    }
+
+    function boundTokenIndexes(
+        uint256 tokenIndexInRaw,
+        uint256 tokenIndexOutRaw
+    ) internal view returns (uint256 tokenIndexIn, uint256 tokenIndexOut) {
+        uint256 len = vault.getPoolTokens(address(pool)).length;
+
+        tokenIndexIn = bound(tokenIndexInRaw, 0, len - 1);
+        tokenIndexOut = bound(tokenIndexOutRaw, 0, len - 1);
+
+        if (tokenIndexIn == tokenIndexOut) {
+            tokenIndexOut = (tokenIndexOut + 1) % len;
+        }
+    }
+
+    function boundSwapAmount(
+        uint256 tokenAmountIn,
+        uint256 tokenIndex
+    ) internal view returns (uint256 boundedAmountIn) {
+        (, , uint256[] memory balancesRaw, ) = vault.getPoolTokenInfo(address(pool));
+        boundedAmountIn = bound(tokenAmountIn, MIN_SWAP_AMOUNT, balancesRaw[tokenIndex].mulDown(MAX_IN_RATIO));
+    }
+}

pkg/vault/test/foundry/utils/BaseMedusaTest.sol

@@ -42,6 +42,7 @@ contract BaseMedusaTest is Test {
     // In certain places, console.log will not print to stdout the intended message, so we use this event to print
     // messages and values.
     event Debug(string, uint256);
+    event Debug(string, int256);
 
     IPermit2 internal permit2;
 
@@ -59,6 +60,12 @@ contract BaseMedusaTest is Test {
     IBasePool internal pool;
     uint256 internal poolCreationNonce;
 
+    uint256 internal constant MAX_UINT128 = type(uint128).max;
+    uint256 internal constant MAX_UINT256 = type(uint256).max;
+
+    // PackedTokenBalance.sol defines a max of 128 bits to store the balance of the pool.
+    uint256 internal constant MAX_BALANCE = MAX_UINT128;
+
     uint256 internal constant DEFAULT_USER_BALANCE = 1e18 * 1e18;
     uint256 internal constant DEFAULT_INITIAL_POOL_BALANCE = 1e6 * 1e18;