chore: fix post-mergem slither and solhint issues

Author: baroooo

contracts/interfaces/IFPMMFactory.sol

@@ -149,6 +149,7 @@ interface IFPMMFactory {
    * @param _proxyAdmin The address of the proxy admin contract
    * @param _breakerBox The address of the breaker box contract
    * @param _governance The address of the governance contract
+   * @param _fpmmImplementation The address of the FPMM implementation
    */
   function initialize(
     address _sortedOracles,
@@ -197,6 +198,7 @@ interface IFPMMFactory {
 
   /**
    * @notice Deploys a new FPMM for a token pair using the default parameters.
+   * @param fpmmImplementation The address of the FPMM implementation
    * @param token0 The address of the first token
    * @param token1 The address of the second token
    * @param referenceRateFeedID The address of the reference rate feed

contracts/swap/FPMM.sol

@@ -241,8 +241,10 @@ contract FPMM is IFPMM, ReentrancyGuardUpgradeable, ERC20Upgradeable, OwnableUpg
 
     (oraclePriceNumerator, oraclePriceDenominator) = _getRateFeed();
 
+    // slither-disable-start divide-before-multiply
     reservePriceNumerator = $.reserve1 * (1e18 / $.decimals1);
     reservePriceDenominator = $.reserve0 * (1e18 / $.decimals0);
+    // slither-disable-end divide-before-multiply
 
     uint256 oracleCrossProduct = oraclePriceNumerator * reservePriceDenominator;
     uint256 reserveCrossProduct = reservePriceNumerator * oraclePriceDenominator;
@@ -612,6 +614,7 @@ contract FPMM is IFPMM, ReentrancyGuardUpgradeable, ERC20Upgradeable, OwnableUpg
     FPMMStorage storage $ = _getFPMMStorage();
 
     uint256 token0ValueInToken1 = convertWithRate(amount0, $.decimals0, 1e18, rateNumerator, rateDenominator);
+    // slither-disable-next-line divide-before-multiply
     amount1 = amount1 * (1e18 / $.decimals1);
     return token0ValueInToken1 + amount1;
   }
@@ -666,6 +669,7 @@ contract FPMM is IFPMM, ReentrancyGuardUpgradeable, ERC20Upgradeable, OwnableUpg
         swapData.rateNumerator,
         swapData.rateDenominator
       );
+      // slither-disable-next-line divide-before-multiply
       expectedAmount1In = expectedAmount1In / (1e18 / $.decimals1);
       uint256 minAmount1In = expectedAmount1In - (expectedAmount1In * $.rebalanceIncentive) / BASIS_POINTS_DENOMINATOR;
       require(swapData.amount1In >= minAmount1In, "FPMM: INSUFFICIENT_AMOUNT_1_IN");
@@ -720,6 +724,7 @@ contract FPMM is IFPMM, ReentrancyGuardUpgradeable, ERC20Upgradeable, OwnableUpg
     );
     uint256 totalFeeInToken1 = fee0InToken1 + fee1;
     // convert to 18 decimals
+    // slither-disable-next-line divide-before-multiply
     totalFeeInToken1 = totalFeeInToken1 * (1e18 / $.decimals1);
 
     // Check the reserve value is not decreased

contracts/swap/ReserveLiquidityStrategy.sol

@@ -181,6 +181,7 @@ contract ReserveLiquidityStrategy is LiquidityStrategy {
 
     require(dec0 <= 1e18 && dec1 <= 1e18, "RLS: TOKEN_DECIMALS_TOO_LARGE");
 
+    // slither-disable-next-line uninitialized-local
     RebalanceParams memory params;
     params.stablePrecision = 1e18 / dec0;
     params.collateralPrecision = 1e18 / dec1;
@@ -228,11 +229,13 @@ contract ReserveLiquidityStrategy is LiquidityStrategy {
       (params.collateralReserve * oraclePriceDenominator);
     uint256 denominator = oraclePriceNumerator + ((oraclePriceNumerator * (BPS_SCALE - incentive)) / BPS_SCALE);
     uint256 stableOutRaw = numerator / denominator;
+    // slither-disable-start divide-before-multiply
     stableOut = stableOutRaw / params.stablePrecision;
 
     uint256 collateralInRaw = (stableOut * params.stablePrecision * oraclePriceNumerator) / oraclePriceDenominator;
 
     collateralIn = collateralInRaw / params.collateralPrecision;
+    // slither-disable-end divide-before-multiply
   }
 
   /**
@@ -257,11 +260,13 @@ contract ReserveLiquidityStrategy is LiquidityStrategy {
       ((params.stableReserve * oraclePriceNumerator) / oraclePriceDenominator);
     uint256 denominator = BPS_SCALE * 2 - incentive;
 
+    // slither-disable-start divide-before-multiply
     uint256 collateralOutRaw = (numerator * BPS_SCALE) / denominator;
     collateralOut = collateralOutRaw / params.collateralPrecision;
 
     uint256 stablesInRaw = (collateralOut * params.collateralPrecision * oraclePriceDenominator) / oraclePriceNumerator;
     stablesIn = stablesInRaw / params.stablePrecision;
+    // slither-disable-end divide-before-multiply
   }
 
   /**

test/fork/BaseForkTest.sol

@@ -129,7 +129,8 @@ abstract contract BaseForkTest is Test {
   }
 
   function transferCeloFromReserve(address to, uint256 amount) internal {
-    vm.prank(address(mentoReserve));
+    vm.startPrank(address(mentoReserve));
     IERC20(lookup("GoldToken")).transfer(to, amount);
+    vm.stopPrank();
   }
 }

test/fork/ForkTests.t.sol

@@ -95,7 +95,7 @@ contract Alfajores_P0E22_ExchangeForkTest is ExchangeForkTest(ALFAJORES_ID, 0, 2
 
 contract Alfajores_P0E23_ExchangeForkTest is ExchangeForkTest(ALFAJORES_ID, 0, 23) {}
 
-contract Celo_ChainForkTest is ChainForkTest(CELO_ID, 1, uints(21)) {}
+contract Celo_ChainForkTest is ChainForkTest(CELO_ID, 1, uints(24)) {}
 
 contract Celo_P0E00_ExchangeForkTest is ExchangeForkTest(CELO_ID, 0, 0) {}
 
@@ -139,6 +139,12 @@ contract Celo_P0E19_ExchangeForkTest is ExchangeForkTest(CELO_ID, 0, 19) {}
 
 contract Celo_P0E20_ExchangeForkTest is ExchangeForkTest(CELO_ID, 0, 20) {}
 
+contract Celo_P0E21_ExchangeForkTest is ExchangeForkTest(CELO_ID, 0, 21) {}
+
+contract Celo_P0E22_ExchangeForkTest is ExchangeForkTest(CELO_ID, 0, 22) {}
+
+contract Celo_P0E23_ExchangeForkTest is ExchangeForkTest(CELO_ID, 0, 23) {}
+
 contract Celo_BancorExchangeProviderForkTest is BancorExchangeProviderForkTest(CELO_ID) {}
 
 contract Celo_GoodDollarTradingLimitsForkTest is GoodDollarTradingLimitsForkTest(CELO_ID) {}

test/unit/swap/FPMM/FPMMFactory.t.sol

@@ -4,9 +4,6 @@ pragma solidity 0.8.18;
 import { Test } from "forge-std/Test.sol";
 import { FPMMFactory } from "contracts/swap/FPMMFactory.sol";
 import { FPMM } from "contracts/swap/FPMM.sol";
-import { FPMMProxy } from "contracts/swap/FPMMProxy.sol";
-import { IERC20 } from "contracts/interfaces/IERC20.sol";
-import { ICreateX } from "contracts/interfaces/ICreateX.sol";
 // solhint-disable-next-line max-line-length
 import { ITransparentUpgradeableProxy } from "openzeppelin-contracts-next/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
 
@@ -752,40 +749,6 @@ abstract contract FPMMFactoryTest_DeployFPMM is FPMMFactoryTest {
     deploy("celo");
   }
 
-  function test_deployFPMM_whenSameSaltIsUsedByDifferentAddress_shouldNotDeployToSameAddress() public {
-    vm.selectFork(celoFork);
-    address alice = makeAddr("Alice");
-
-    vm.startPrank(alice);
-
-    bytes11 customProxySalt = bytes11(
-      uint88(uint256(keccak256(abi.encodePacked(IERC20(token0Celo).symbol(), IERC20(token1Celo).symbol()))))
-    );
-    bytes32 proxySalt = bytes32(abi.encodePacked(address(factoryCelo), hex"00", customProxySalt));
-    bytes memory proxyInitData = abi.encodeWithSelector(
-      FPMM.initialize.selector,
-      token0Celo,
-      token1Celo,
-      expectedSortedOracles,
-      expectedReferenceRateFeedID,
-      expectedBreakerBox,
-      expectedGovernance
-    );
-    bytes memory proxyBytecode = abi.encodePacked(
-      type(FPMMProxy).creationCode,
-      abi.encode(fpmmImplementationCeloAddress, expectedProxyAdmin, proxyInitData)
-    );
-
-    address aliceFPMMProxy = ICreateX(createX).deployCreate3(proxySalt, proxyBytecode);
-    vm.stopPrank();
-
-    vm.prank(governanceCelo);
-    deploy("celo");
-
-    address factoryProxy = address(factoryCelo.deployedFPMMs(token0Celo, token1Celo));
-    assertNotEq(factoryProxy, aliceFPMMProxy);
-  }
-
   function test_deployFPMM_shouldDeploySameFPMMToSameAddressOnDifferentChains() public {
     vm.selectFork(celoFork);
     vm.prank(governanceCelo);

test/unit/swap/StrategyIntegration.t.sol

@@ -0,0 +1,85 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// solhint-disable func-name-mixedcase, var-name-mixedcase, state-visibility
+// solhint-disable const-name-snakecase, max-states-count, contract-name-camelcase
+// solhint-disable modifier-name-mixedcase,
+pragma solidity ^0.8;
+import { Test } from "mento-std/Test.sol";
+
+import { ReserveLiquidityStrategy } from "contracts/swap/ReserveLiquidityStrategy.sol";
+import { IBreakerBox } from "contracts/interfaces/IBreakerBox.sol";
+import { MockERC20 } from "test/utils/mocks/MockERC20.sol";
+import { MockReserve } from "test/utils/mocks/MockReserve.sol";
+import { MockSortedOracles } from "test/utils/mocks/MockSortedOracles.sol";
+import { FPMM } from "contracts/swap/FPMM.sol";
+
+contract StrategyIntegrationTest is Test {
+  MockERC20 public token0;
+  MockERC20 public token1;
+  MockReserve public reserve;
+  MockSortedOracles public sortedOracles;
+  FPMM public pool;
+  ReserveLiquidityStrategy public strategy;
+  address public rateFeed;
+  address public breakerBox;
+  address public trader;
+
+  function setUp() public {
+    breakerBox = makeAddr("BreakerBox");
+    rateFeed = makeAddr("RateFeed");
+    trader = makeAddr("Trader");
+
+    bytes memory tradingModeCalldata = abi.encodeWithSelector(IBreakerBox.getRateFeedTradingMode.selector, rateFeed);
+    vm.mockCall(breakerBox, tradingModeCalldata, abi.encode(0));
+
+    token0 = new MockERC20("Token0", "T0", 18);
+    token1 = new MockERC20("Token1", "T1", 6);
+    reserve = new MockReserve();
+    sortedOracles = new MockSortedOracles();
+    sortedOracles.setMedianRate(rateFeed, 909884940000000000000000);
+    pool = new FPMM(false);
+    strategy = new ReserveLiquidityStrategy(false);
+    strategy.initialize(address(reserve));
+    pool.initialize(
+      address(token0),
+      address(token1),
+      address(sortedOracles),
+      rateFeed,
+      true,
+      address(breakerBox),
+      address(this)
+    );
+    pool.setLiquidityStrategy(address(strategy), true);
+    strategy.addPool(address(pool), 0, 50);
+
+    token0.mint(trader, 2e24);
+    token1.mint(trader, 2e12);
+
+    token1.mint(address(reserve), 10e12);
+
+    vm.startPrank(trader);
+    token0.transfer(address(pool), 1e24);
+    token1.transfer(address(pool), 1e12);
+    pool.mint(trader);
+    vm.stopPrank();
+  }
+
+  function test_rebalance_contraction() public {
+    vm.startPrank(trader);
+    token0.transfer(address(pool), 100_000 * 1e18);
+    uint256 expectedAmountOut = pool.getAmountOut(100_000 * 1e18, address(token0));
+    pool.swap(0, expectedAmountOut, trader, "");
+    vm.stopPrank();
+
+    strategy.rebalance(address(pool));
+  }
+
+  function test_rebalance_expansion() public {
+    vm.startPrank(trader);
+    token1.transfer(address(pool), 100_000 * 1e6);
+    uint256 expectedAmountOut = pool.getAmountOut(100_000 * 1e6, address(token1));
+    pool.swap(expectedAmountOut, 0, trader, "");
+    vm.stopPrank();
+
+    strategy.rebalance(address(pool));
+  }
+}