Feat/delta params

.gitmodules

@@ -3,3 +3,6 @@
   url = https://github.com/primitivefinance/solstat
   branch = "update-forge-std"
 
+[submodule "lib/forge-std"]
+	path = lib/forge-std
+	url = https://github.com/foundry-rs/forge-std

CONTRIBUTING.md

@@ -1 +1,23 @@
 # Contribution guidelines
+
+### General
+
+A few rules:
+1. Follow our [style guide](#style-guide).
+2. Format on save using Foundry formatter.
+
+## Style Guide
+
+
+### Imports
+
+1. Use named imports as much as possible.
+2. Import external dependencies first (libs, etc).
+
+### Tests
+
+1. Name the tests accordingly using the following format:
+`test_{name of the contract}_{name of the function}_{what should happen}`
+
+For example:
+`test_DFMM_init_IncrementsPoolId`.

README.md

@@ -121,6 +121,25 @@ The DFMM protocol is currently deployed on the following networks:
 | `G3M` | Optimism Sepolia | `0xB5C2c5a4000FB230b289bB54f8b48F4dd8075F3D` |
 | `LogNormal` | Optimism Sepolia | `0x6A74a571c638dDDF13ae52F48A37D1019B916520` |
 
+## Terminology
+
+These terms are used to name specific variables throuhout the codebase and the documentation. They are noted here for clarity and are expected to be reused in the future by strategy developers or contributors.
+
+- The prefix `delta` is used to denote the amount of tokens or liquidity to be added or removed from a pool: `deltaX`, `deltaY`, `deltaLiquidity`.
+- The prefix `adjusted` is used to denote the amount of tokens or liquidity after the addition or removal of liquidity: `adjustedReserveX`, `adjustedReserveY`, `adjustedLiquidity`.
+
+| Term | Definition |
+|---|---|
+| `reserveX` | The amount of token X held by a pool |
+| `reserveY` | The amount of token Y held by a pool |
+| `liquidity` | The amount of liquidity held by a pool |
+| `deltaX` | The amount of token X to be added or removed from a pool |
+| `deltaY` | The amount of token Y to be added or removed from a pool |
+| `deltaLiquidity` | The amount of liquidity to be added or removed from a pool |
+| `adjustedReserveX` | The amount of token X after the addition or removal of liquidity |
+| `adjustedReserveY` | The amount of token Y after the addition or removal of liquidity |
+| `adjustedLiquidity` | The amount of liquidity after the addition or removal of liquidity |
+
 ## Contributing
 
 Contributions are welcome! Check out our [guidelines](./CONTRIBUTING.md).

foundry.toml

@@ -2,14 +2,13 @@
 remappings = [
   "solmate/=lib/solstat/lib/solmate/src/",
   "solstat/=lib/solstat/src/",
-  "forge-std/=lib/solstat/lib/forge-std/src/",
 ]
 solc_version = "0.8.22"
 
 # these are defaults. explicitly setting them here for clarity.
 libs = ["lib"]
 out = "out/"
-via-ir = true
+# via-ir = true
 
 [fmt]
 bracket_spacing = true

src/ConstantSum/ConstantSum.sol

@@ -41,6 +41,7 @@ contract ConstantSum is IStrategy {
     function init(
         address,
         uint256 poolId,
+        IDFMM.Pool calldata pool,
         bytes calldata data
     )
         public
@@ -73,6 +74,7 @@ contract ConstantSum is IStrategy {
     function validateSwap(
         address,
         uint256 poolId,
+        IDFMM.Pool calldata pool,
         bytes calldata data
     )
         external
@@ -89,27 +91,24 @@ contract ConstantSum is IStrategy {
         ConstantSumParams memory params =
             abi.decode(getPoolParams(poolId), (ConstantSumParams));
 
-        (uint256 startRx, uint256 startRy, uint256 startL) =
-            IDFMM(dfmm).getReservesAndLiquidity(poolId);
-
         (nextRx, nextRy, nextL) = abi.decode(data, (uint256, uint256, uint256));
 
         uint256 minLiquidityDelta;
         uint256 amountIn;
         uint256 fees;
-        if (nextRx > startRy) {
-            amountIn = nextRx - startRx;
+        if (nextRx > pool.reserveX) {
+            amountIn = nextRx - pool.reserveX;
             fees = amountIn.mulWadUp(params.swapFee);
             minLiquidityDelta += fees;
-        } else if (nextRy > startRy) {
-            amountIn = nextRy - startRy;
+        } 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(startL);
+        liquidityDelta = int256(nextL) - int256(pool.totalLiquidity);
         assert(liquidityDelta >= int256(minLiquidityDelta));
 
         invariant =
@@ -133,28 +132,59 @@ contract ConstantSum is IStrategy {
     }
 
     // This should literally always work lol
-    function validateAllocateOrDeallocate(
+    function validateAllocate(
         address,
         uint256 poolId,
+        IDFMM.Pool calldata pool,
         bytes calldata data
     )
         external
         view
         returns (
             bool valid,
             int256 invariant,
-            uint256 reserveX,
-            uint256 reserveY,
-            uint256 totalLiquidity
+            uint256 deltaX,
+            uint256 deltaY,
+            uint256 deltaLiquidity
         )
     {
-        (reserveX, reserveY, totalLiquidity) =
+        (deltaX, deltaY, deltaLiquidity) =
             abi.decode(data, (uint256, uint256, uint256));
 
         invariant = ConstantSumLib.tradingFunction(
-            reserveX,
-            reserveY,
-            totalLiquidity,
+            pool.reserveX + deltaX,
+            pool.reserveX + deltaY,
+            pool.totalLiquidity + deltaLiquidity,
+            abi.decode(getPoolParams(poolId), (ConstantSumParams)).price
+        );
+
+        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
         );
 
@@ -164,6 +194,7 @@ contract ConstantSum is IStrategy {
     function update(
         address sender,
         uint256 poolId,
+        IDFMM.Pool calldata pool,
         bytes calldata data
     ) external onlyDFMM {
         if (sender != internalParams[poolId].controller) revert InvalidSender();

src/ConstantSum/ConstantSumSolver.sol

@@ -81,15 +81,20 @@ contract ConstantSumSolver {
             endReserves.rx = startReserves.rx - amountOut;
         }
 
+        IDFMM.Pool memory pool;
+        pool.reserveX = startReserves.rx;
+        pool.reserveY = startReserves.rx;
+        pool.totalLiquidity = startReserves.L;
+
         bytes memory swapData = abi.encode(endReserves);
-        (bool valid,,,,,) =
-            IStrategy(strategy).validateSwap(address(this), poolId, swapData);
+        (bool valid,,,,,) = IStrategy(strategy).validateSwap(
+            address(this), poolId, pool, swapData
+        );
         return (valid, amountOut, swapData);
     }
 
-    function simulateAllocateOrDeallocate(
+    function simulateAllocate(
         uint256 poolId,
-        bool IsAllocate,
         uint256 amountX,
         uint256 amountY
     ) public view returns (bool, bytes memory) {
@@ -102,27 +107,56 @@ contract ConstantSumSolver {
             (ConstantSum.ConstantSumParams)
         );
 
-        if (IsAllocate) {
-            endReserves.rx = startReserves.rx + amountX;
-            endReserves.ry = startReserves.ry + amountY;
-            endReserves.L =
-                endReserves.rx + endReserves.ry.divWadUp(poolParams.price);
-        } else {
-            if (startReserves.rx < amountX || startReserves.ry < amountY) {
-                revert NotEnoughLiquidity();
-            }
-            endReserves.rx = startReserves.rx - amountX;
-            endReserves.ry = startReserves.ry - amountY;
-            endReserves.L =
-                endReserves.rx + endReserves.ry.divWadUp(poolParams.price);
-        }
+        endReserves.rx = startReserves.rx + amountX;
+        endReserves.ry = startReserves.ry + amountY;
+        endReserves.L =
+            endReserves.rx + endReserves.ry.divWadUp(poolParams.price);
+
+        IDFMM.Pool memory pool;
+        pool.reserveX = startReserves.rx;
+        pool.reserveY = startReserves.ry;
+        pool.totalLiquidity = startReserves.L;
 
         bytes memory allocateData = abi.encode(endReserves);
-        (bool valid,,,,) = IStrategy(strategy).validateAllocateOrDeallocate(
-            address(this), poolId, allocateData
+        (bool valid,,,,) = IStrategy(strategy).validateAllocate(
+            address(this), poolId, pool, allocateData
         );
         return (valid, allocateData);
     }
+
+    function simulateDeallocate(
+        uint256 poolId,
+        uint256 amountX,
+        uint256 amountY
+    ) public view returns (bool, bytes memory) {
+        Reserves memory startReserves;
+        Reserves memory endReserves;
+        (startReserves.rx, startReserves.ry, startReserves.L) =
+            IDFMM(IStrategy(strategy).dfmm()).getReservesAndLiquidity(poolId);
+        ConstantSum.ConstantSumParams memory poolParams = abi.decode(
+            IStrategy(strategy).getPoolParams(poolId),
+            (ConstantSum.ConstantSumParams)
+        );
+
+        if (startReserves.rx < amountX || startReserves.ry < amountY) {
+            revert NotEnoughLiquidity();
+        }
+        endReserves.rx = startReserves.rx - amountX;
+        endReserves.ry = startReserves.ry - amountY;
+        endReserves.L =
+            endReserves.rx + endReserves.ry.divWadUp(poolParams.price);
+
+        IDFMM.Pool memory pool;
+        pool.reserveX = startReserves.rx;
+        pool.reserveY = startReserves.ry;
+        pool.totalLiquidity = startReserves.L;
+
+        bytes memory deallocateData = abi.encode(endReserves);
+        (bool valid,,,,) = IStrategy(strategy).validateDeallocate(
+            address(this), poolId, pool, deallocateData
+        );
+        return (valid, deallocateData);
+}
     function preparePriceUpdate(uint256 newPrice) public pure returns (bytes memory) {
         return ConstantSumLib.encodePriceUpdate(newPrice);
     }