feat: Solvers clean

src/ConstantSum/ConstantSumMath.sol

@@ -50,3 +50,10 @@ function computeSwapDeltaLiquidity(
         return (params.swapFee).mulDivUp(delta, params.price);
     }
 }
+
+/**
+ * @dev Computes the price using the reserve of token X.
+ */
+function computePrice(ConstantSumParams memory params) pure returns (uint256) {
+    return params.price;
+}

src/ConstantSum/ConstantSumSolver.sol

@@ -9,14 +9,19 @@ import {
     encodeFeeUpdate,
     encodeControllerUpdate
 } from "./ConstantSumUtils.sol";
+import {
+    computeAllocationGivenX,
+    computeAllocationGivenY
+} from "src/lib/StrategyLib.sol";
 import {
     ONE,
     computeInitialPoolData,
     FixedPointMathLib,
     computeSwapDeltaLiquidity
 } from "./ConstantSumMath.sol";
+import { PairSolver } from "src/PairSolver.sol";
 
-contract ConstantSumSolver {
+contract ConstantSumSolver is PairSolver {
     error NotEnoughLiquidity();
 
     using FixedPointMathLib for uint256;
@@ -46,6 +51,7 @@ contract ConstantSumSolver {
         uint256 deltaLiquidity;
     }
 
+    /// @notice used by kit
     function simulateSwap(
         uint256 poolId,
         bool swapXIn,
@@ -91,6 +97,7 @@ contract ConstantSumSolver {
         return (valid, state.amountOut, swapData);
     }
 
+    /// @notice used by kit
     function preparePriceUpdate(uint256 newPrice)
         public
         pure
@@ -99,6 +106,7 @@ contract ConstantSumSolver {
         return encodePriceUpdate(newPrice);
     }
 
+    /// @notice used by kit
     function prepareSwapFeeUpdate(uint256 newSwapFee)
         public
         pure
@@ -107,11 +115,50 @@ contract ConstantSumSolver {
         return encodeFeeUpdate(newSwapFee);
     }
 
+    /// @notice used by kit
     function prepareControllerUpdate(address newController)
         public
         pure
         returns (bytes memory)
     {
         return encodeControllerUpdate(newController);
     }
+
+    function getReservesAndLiquidity(uint256 poolId)
+        public
+        view
+        override
+        returns (uint256, uint256, uint256)
+    {
+        Pool memory pool = IDFMM(IStrategy(strategy).dfmm()).pools(poolId);
+        return (pool.reserves[0], pool.reserves[1], pool.totalLiquidity);
+    }
+
+    function getPoolParams(uint256 poolId)
+        public
+        view
+        returns (ConstantSumParams memory)
+    {
+        return abi.decode(
+            IStrategy(strategy).getPoolParams(poolId), (ConstantSumParams)
+        );
+    }
+
+    // These are same for allocation and deallocation
+    // delta y is 0
+    function PrepareAllocationDeltaGivenDeltaX(
+        uint256 poolId,
+        uint256 deltaX
+    ) public view returns (bytes memory) {
+        ConstantSumParams memory params = getPoolParams(poolId);
+        uint256 deltaL = deltaX.mulWadDown(params.price);
+        return abi.encode(deltaX, 0, deltaL);
+    }
+
+    function PrepareAllocationDeltaGivenDeltaY(
+        // uint256 poolId,
+        uint256 deltaY
+    ) public pure returns (bytes memory) {
+        return abi.encode(0, deltaY, deltaY);
+    }
 }

src/ConstantSum/README.md

@@ -20,7 +20,7 @@ $$
 where $L$ is the **liquidity** of the pool. 
 
 ## Price
-The reported price of the pool given the reseres is $P$.
+The reported price of the pool given the reserves is $P$.
 
 ## Pool initialization
 The `ConstantSum` pool can be initialized with any given price and any given value of reserves. 

src/GeometricMean/GeometricMeanSolver.sol

@@ -22,8 +22,9 @@ import {
     computePrice,
     computeSwapDeltaLiquidity
 } from "./G3MMath.sol";
+import { PairSolver } from "src/PairSolver.sol";
 
-contract GeometricMeanSolver {
+contract GeometricMeanSolver is PairSolver {
     using FixedPointMathLib for uint256;
     using FixedPointMathLib for int256;
 
@@ -46,6 +47,7 @@ contract GeometricMeanSolver {
     function getReservesAndLiquidity(uint256 poolId)
         public
         view
+        override
         returns (uint256, uint256, uint256)
     {
         Pool memory pool = IDFMM(IStrategy(strategy).dfmm()).pools(poolId);
@@ -94,50 +96,6 @@ contract GeometricMeanSolver {
         return computeInitialPoolData(rx, S, params);
     }
 
-    function allocateGivenDeltaX(
-        uint256 poolId,
-        uint256 deltaX
-    ) public view returns (uint256, uint256) {
-        (uint256 rX, uint256 rY, uint256 totalLiquidity) =
-            getReservesAndLiquidity(poolId);
-        (uint256 deltaY, uint256 deltaLiquidity) =
-            computeAllocationGivenDeltaX(deltaX, rX, rY, totalLiquidity);
-        return (deltaY, deltaLiquidity);
-    }
-
-    function allocateGivenDeltaY(
-        uint256 poolId,
-        uint256 deltaY
-    ) public view returns (uint256, uint256) {
-        (uint256 rX, uint256 rY, uint256 totalLiquidity) =
-            getReservesAndLiquidity(poolId);
-        (uint256 deltaX, uint256 deltaLiquidity) =
-            computeAllocationGivenDeltaY(deltaY, rX, rY, totalLiquidity);
-        return (deltaX, deltaLiquidity);
-    }
-
-    function deallocateGivenDeltaX(
-        uint256 poolId,
-        uint256 deltaX
-    ) public view returns (uint256, uint256) {
-        (uint256 rX, uint256 rY, uint256 totalLiquidity) =
-            getReservesAndLiquidity(poolId);
-        (uint256 deltaY, uint256 deltaLiquidity) =
-            computeDeallocationGivenDeltaX(deltaX, rX, rY, totalLiquidity);
-        return (deltaY, deltaLiquidity);
-    }
-
-    function deallocateGivenDeltaY(
-        uint256 poolId,
-        uint256 deltaY
-    ) public view returns (uint256, uint256) {
-        (uint256 rX, uint256 rY, uint256 totalLiquidity) =
-            getReservesAndLiquidity(poolId);
-        (uint256 deltaX, uint256 deltaLiquidity) =
-            computeDeallocationGivenDeltaY(deltaY, rX, rY, totalLiquidity);
-        return (deltaX, deltaLiquidity);
-    }
-
     function getNextReserveX(
         uint256 poolId,
         uint256 ry,