Replaces next reserves by deltas in swap functions

.gitignore

@@ -7,8 +7,6 @@ optimized-out
 kit/target
 target
 
-# VSCode
-.vscode
 .env
 report/main.aux
 report/main.pyg

.vscode/extensions.json

@@ -0,0 +1,6 @@
+{
+    "recommendations": [
+        "remisa.mathover",
+        "nomicfoundation.hardhat-solidity"
+    ]
+}

.vscode/settings.json

@@ -0,0 +1,10 @@
+{
+    "editor.formatOnSave": true,
+    "solidity.formatter": "forge",
+    "[solidity]": {
+        "editor.defaultFormatter": "NomicFoundation.hardhat-solidity"
+    },
+    "mathover.matchRegex": "\\$\\$(.*?)\\$\\$",
+    "mathover.forwardSkip": 2,
+    "mathover.backwardSkip": 2
+}

CONTRIBUTING.md

@@ -8,11 +8,11 @@ A few rules:
 
 ## Style Guide
 
-
 ### Imports
 
 1. Use named imports as much as possible.
 2. Import external dependencies first (libs, etc).
+3. Import from root `src/DFMM.sol` instead of `../DFMM.sol`.
 
 ### Tests
 

README.md

@@ -97,6 +97,8 @@ To run all the tests, simply run the following command:
 forge t
 ```
 
+Learn more about our testing suite [here](./test/README.md).
+
 ### Deployment
 
 You can deploy the contracts with the following command:

src/ConstantSum/ConstantSum.sol

@@ -3,10 +3,9 @@ pragma solidity ^0.8.13;
 
 import "./ConstantSumLib.sol";
 import "src/interfaces/IDFMM.sol";
-import "src/interfaces/IStrategy.sol";
-import "forge-std/Test.sol";
+import { Strategy, IStrategy } from "src/Strategy.sol";
 
-contract ConstantSum is IStrategy {
+contract ConstantSum is Strategy {
     using FixedPointMathLib for uint256;
 
     struct InternalParams {
@@ -21,27 +20,17 @@ contract ConstantSum is IStrategy {
         address controller;
     }
 
-    /// @inheritdoc IStrategy
-    address public dfmm;
-
     /// @inheritdoc IStrategy
     string public constant name = "ConstantSum";
 
     mapping(uint256 => InternalParams) public internalParams;
 
-    constructor(address dfmm_) {
-        dfmm = dfmm_;
-    }
-
-    modifier onlyDFMM() {
-        if (msg.sender != dfmm) revert NotDFMM();
-        _;
-    }
+    constructor(address dfmm_) Strategy(dfmm_) { }
 
     function init(
         address,
         uint256 poolId,
-        IDFMM.Pool calldata pool,
+        IDFMM.Pool calldata,
         bytes calldata data
     )
         public
@@ -71,67 +60,7 @@ contract ConstantSum is IStrategy {
         return (valid, invariant, reserveX, reserveY, totalLiquidity);
     }
 
-    function validateSwap(
-        address,
-        uint256 poolId,
-        IDFMM.Pool calldata pool,
-        bytes calldata data
-    )
-        external
-        view
-        returns (
-            bool valid,
-            int256 invariant,
-            int256 liquidityDelta,
-            uint256 nextRx,
-            uint256 nextRy,
-            uint256 nextL
-        )
-    {
-        ConstantSumParams memory params =
-            abi.decode(getPoolParams(poolId), (ConstantSumParams));
-
-        (nextRx, nextRy, nextL) = abi.decode(data, (uint256, uint256, uint256));
-
-        uint256 minLiquidityDelta;
-        uint256 amountIn;
-        uint256 fees;
-        if (nextRx > pool.reserveX) {
-            amountIn = nextRx - pool.reserveX;
-            fees = amountIn.mulWadUp(params.swapFee);
-            minLiquidityDelta += fees;
-        } else if (nextRy > pool.reserveY) {
-            amountIn = nextRy - pool.reserveY;
-            fees = amountIn.mulWadUp(params.swapFee);
-            minLiquidityDelta += fees.divWadUp(params.price);
-        } else {
-            revert("invalid swap: inputs x and y have the same sign!");
-        }
-
-        liquidityDelta = int256(nextL) - int256(pool.totalLiquidity);
-        assert(liquidityDelta >= int256(minLiquidityDelta));
-
-        invariant =
-            ConstantSumLib.tradingFunction(nextRx, nextRy, nextL, params.price);
-
-        valid = -EPSILON < invariant && invariant < EPSILON;
-    }
-
-    function computeSwapConstant(
-        uint256 poolId,
-        bytes memory data
-    ) external view returns (int256) {
-        (uint256 reserveX, uint256 reserveY, uint256 totalLiquidity) =
-            abi.decode(data, (uint256, uint256, uint256));
-        return ConstantSumLib.tradingFunction(
-            reserveX,
-            reserveY,
-            totalLiquidity,
-            abi.decode(getPoolParams(poolId), (ConstantSumParams)).price
-        );
-    }
-
-    // This should literally always work lol
+    /// @inheritdoc IStrategy
     function validateAllocate(
         address,
         uint256 poolId,
@@ -140,6 +69,7 @@ contract ConstantSum is IStrategy {
     )
         external
         view
+        override
         returns (
             bool valid,
             int256 invariant,
@@ -151,50 +81,20 @@ contract ConstantSum is IStrategy {
         (deltaX, deltaY, deltaLiquidity) =
             abi.decode(data, (uint256, uint256, uint256));
 
-        invariant = ConstantSumLib.tradingFunction(
+        invariant = tradingFunction(
             pool.reserveX + deltaX,
-            pool.reserveX + deltaY,
+            pool.reserveY + deltaY,
             pool.totalLiquidity + deltaLiquidity,
-            abi.decode(getPoolParams(poolId), (ConstantSumParams)).price
+            getPoolParams(poolId)
         );
 
-        valid = -EPSILON < invariant && invariant < EPSILON;
-    }
-
-    // This should literally always work lol
-    function validateDeallocate(
-        address,
-        uint256 poolId,
-        IDFMM.Pool calldata pool,
-        bytes calldata data
-    )
-        external
-        view
-        returns (
-            bool valid,
-            int256 invariant,
-            uint256 deltaX,
-            uint256 deltaY,
-            uint256 deltaLiquidity
-        )
-    {
-        (deltaX, deltaY, deltaLiquidity) =
-            abi.decode(data, (uint256, uint256, uint256));
-
-        invariant = ConstantSumLib.tradingFunction(
-            pool.reserveX - deltaX,
-            pool.reserveY - deltaY,
-            pool.totalLiquidity - deltaLiquidity,
-            abi.decode(getPoolParams(poolId), (ConstantSumParams)).price
-        );
-
-        valid = -EPSILON < invariant && invariant < EPSILON;
+        valid = -(EPSILON) < invariant && invariant < EPSILON;
     }
 
     function update(
         address sender,
         uint256 poolId,
-        IDFMM.Pool calldata pool,
+        IDFMM.Pool calldata,
         bytes calldata data
     ) external onlyDFMM {
         if (sender != internalParams[poolId].controller) revert InvalidSender();
@@ -217,12 +117,49 @@ contract ConstantSum is IStrategy {
         }
     }
 
-    function getPoolParams(uint256 poolId) public view returns (bytes memory) {
+    function getPoolParams(uint256 poolId)
+        public
+        view
+        override
+        returns (bytes memory)
+    {
         ConstantSumParams memory params;
 
         params.price = internalParams[poolId].price;
         params.swapFee = internalParams[poolId].swapFee;
 
         return abi.encode(params);
     }
+
+    function tradingFunction(
+        uint256 reserveX,
+        uint256 reserveY,
+        uint256 totalLiquidity,
+        bytes memory params
+    ) public pure override returns (int256) {
+        return ConstantSumLib.tradingFunction(
+            reserveX,
+            reserveY,
+            totalLiquidity,
+            abi.decode(params, (ConstantSumParams)).price
+        );
+    }
+
+    function _computeDeltaXGivenDeltaL(
+        uint256 deltaLiquidity,
+        IDFMM.Pool calldata,
+        bytes memory
+    ) internal view virtual override returns (uint256) {
+        // TODO: Implement this.
+        return deltaLiquidity;
+    }
+
+    function _computeDeltaYGivenDeltaL(
+        uint256 deltaLiquidity,
+        IDFMM.Pool calldata,
+        bytes memory
+    ) internal view virtual override returns (uint256) {
+        // TODO: Implement this.
+        return deltaLiquidity;
+    }
 }