Settle pair (#242)

* clean

* format

* with currencydeltas library

* remove currencydeltas library

.forge-snapshots/PositionManager_increaseLiquidity_erc20_withSettlePair.snap

@@ -0,0 +1 @@
+151341

.forge-snapshots/PositionManager_mint_nativeWithSweep_withClose.snap

@@ -0,0 +1 @@
+345169

.forge-snapshots/PositionManager_mint_nativeWithSweep_withSettlePair.snap

@@ -0,0 +1 @@
+344710

.forge-snapshots/PositionManager_mint_settleWithBalance_sweep.snap

@@ -1 +1 @@
-370923
+370969

.forge-snapshots/PositionManager_mint_withSettlePair.snap

@@ -0,0 +1 @@
+371342

src/PositionManager.sol

@@ -126,6 +126,9 @@ contract PositionManager is
         } else if (action == Actions.SETTLE) {
             (Currency currency, uint256 amount, bool payerIsUser) = params.decodeCurrencyUint256AndBool();
             _settle(currency, _mapPayer(payerIsUser), _mapSettleAmount(amount, currency));
+        } else if (action == Actions.SETTLE_PAIR) {
+            (Currency currency0, Currency currency1) = params.decodeCurrencyPair();
+            _settlePair(currency0, currency1);
         } else if (action == Actions.SWEEP) {
             (Currency currency, address to) = params.decodeCurrencyAndAddress();
             _sweep(currency, _mapRecipient(to));
@@ -214,6 +217,13 @@ contract PositionManager is
         poolManager.clear(currency, uint256(currencyDelta));
     }
 
+    function _settlePair(Currency currency0, Currency currency1) internal {
+        // the locker is the payer when settling
+        address caller = _msgSender();
+        _settle(currency0, caller, _getFullSettleAmount(currency0));
+        _settle(currency1, caller, _getFullSettleAmount(currency1));
+    }
+
     /// @dev this is overloaded with ERC721Permit._burn
     function _burn(
         uint256 tokenId,

src/libraries/Actions.sol

@@ -20,19 +20,19 @@ library Actions {
 
     // closing deltas on the pool manager
     // settling
-    uint256 constant SETTLE_ALL = 0x10;
-    uint256 constant SETTLE = 0x11;
+    uint256 constant SETTLE_ALL = 0x09;
+    uint256 constant SETTLE = 0x10;
+    uint256 constant SETTLE_PAIR = 0x11;
     // taking
-    uint256 constant TAKE = 0x13;
-    uint256 constant TAKE_ALL = 0x14;
-    uint256 constant TAKE_PORTION = 0x15;
+    uint256 constant TAKE = 0x12;
+    uint256 constant TAKE_ALL = 0x13;
+    uint256 constant TAKE_PORTION = 0x14;
 
-    uint256 constant CLOSE_CURRENCY = 0x16;
-    uint256 constant CLOSE_PAIR = 0x17;
-    uint256 constant CLEAR = 0x18;
-    uint256 constant SWEEP = 0x19;
+    uint256 constant CLOSE_CURRENCY = 0x15;
+    uint256 constant CLEAR = 0x16;
+    uint256 constant SWEEP = 0x17;
 
     // minting/burning 6909s to close deltas
-    uint256 constant MINT_6909 = 0x20;
-    uint256 constant BURN_6909 = 0x21;
+    uint256 constant MINT_6909 = 0x18;
+    uint256 constant BURN_6909 = 0x19;
 }

src/libraries/CalldataDecoder.sol

@@ -166,6 +166,14 @@ library CalldataDecoder {
         }
     }
 
+    /// @dev equivalent to: abi.decode(params, (Currency, Currency)) in calldata
+    function decodeCurrencyPair(bytes calldata params) internal pure returns (Currency currency0, Currency currency1) {
+        assembly ("memory-safe") {
+            currency0 := calldataload(params.offset)
+            currency1 := calldataload(add(params.offset, 0x20))
+        }
+    }
+
     /// @dev equivalent to: abi.decode(params, (Currency, address)) in calldata
     function decodeCurrencyAndAddress(bytes calldata params)
         internal

test/libraries/CalldataDecoder.t.sol

@@ -152,6 +152,14 @@ contract CalldataDecoderTest is Test {
         assertEq(Currency.unwrap(currency), Currency.unwrap(_currency));
     }
 
+    function test_fuzz_decodeCurrencyPair(Currency _currency0, Currency _currency1) public view {
+        bytes memory params = abi.encode(_currency0, _currency1);
+        (Currency currency0, Currency currency1) = decoder.decodeCurrencyPair(params);
+
+        assertEq(Currency.unwrap(currency0), Currency.unwrap(_currency0));
+        assertEq(Currency.unwrap(currency1), Currency.unwrap(_currency1));
+    }
+
     function test_fuzz_decodeCurrencyAndUint256(Currency _currency, uint256 _amount) public view {
         bytes memory params = abi.encode(_currency, _amount);
         (Currency currency, uint256 amount) = decoder.decodeCurrencyAndUint256(params);

test/mocks/MockCalldataDecoder.sol

@@ -98,6 +98,10 @@ contract MockCalldataDecoder {
         return params.decodeCurrency();
     }
 
+    function decodeCurrencyPair(bytes calldata params) external pure returns (Currency currency0, Currency currency1) {
+        return params.decodeCurrencyPair();
+    }
+
     function decodeCurrencyAndUint256(bytes calldata params) external pure returns (Currency currency, uint256 _uint) {
         return params.decodeCurrencyAndUint256();
     }

test/position-managers/Execute.t.sol

@@ -79,7 +79,7 @@ contract ExecuteTest is Test, PosmTestSetup, LiquidityFuzzers {
         assertEq(liquidity, initialLiquidity + liquidityToAdd);
     }
 
-    function test_fuzz_execute_increaseLiquidity_twice(
+    function test_fuzz_execute_increaseLiquidity_twice_withClose(
         uint256 initialLiquidity,
         uint256 liquidityToAdd,
         uint256 liquidityToAdd2
@@ -101,7 +101,39 @@ contract ExecuteTest is Test, PosmTestSetup, LiquidityFuzzers {
             abi.encode(tokenId, config, liquidityToAdd2, MAX_SLIPPAGE_INCREASE, MAX_SLIPPAGE_INCREASE, ZERO_BYTES)
         );
 
-        bytes memory calls = planner.finalizeModifyLiquidity(config.poolKey);
+        bytes memory calls = planner.finalizeModifyLiquidityWithClose(config.poolKey);
+        lpm.modifyLiquidities(calls, _deadline);
+
+        bytes32 positionId =
+            Position.calculatePositionKey(address(lpm), config.tickLower, config.tickUpper, bytes32(tokenId));
+        (uint256 liquidity,,) = manager.getPositionInfo(config.poolKey.toId(), positionId);
+
+        assertEq(liquidity, initialLiquidity + liquidityToAdd + liquidityToAdd2);
+    }
+
+    function test_fuzz_execute_increaseLiquidity_twice_withSettlePair(
+        uint256 initialLiquidity,
+        uint256 liquidityToAdd,
+        uint256 liquidityToAdd2
+    ) public {
+        initialLiquidity = bound(initialLiquidity, 1e18, 1000e18);
+        liquidityToAdd = bound(liquidityToAdd, 1e18, 1000e18);
+        liquidityToAdd2 = bound(liquidityToAdd2, 1e18, 1000e18);
+        uint256 tokenId = lpm.nextTokenId();
+        mint(config, initialLiquidity, address(this), ZERO_BYTES);
+
+        Plan memory planner = Planner.init();
+
+        planner.add(
+            Actions.INCREASE_LIQUIDITY,
+            abi.encode(tokenId, config, liquidityToAdd, MAX_SLIPPAGE_INCREASE, MAX_SLIPPAGE_INCREASE, ZERO_BYTES)
+        );
+        planner.add(
+            Actions.INCREASE_LIQUIDITY,
+            abi.encode(tokenId, config, liquidityToAdd2, MAX_SLIPPAGE_INCREASE, MAX_SLIPPAGE_INCREASE, ZERO_BYTES)
+        );
+
+        bytes memory calls = planner.finalizeModifyLiquidityWithSettlePair(config.poolKey);
         lpm.modifyLiquidities(calls, _deadline);
 
         bytes32 positionId =
@@ -131,7 +163,7 @@ contract ExecuteTest is Test, PosmTestSetup, LiquidityFuzzers {
             abi.encode(tokenId, config, liquidityToAdd, MAX_SLIPPAGE_INCREASE, MAX_SLIPPAGE_INCREASE, ZERO_BYTES)
         );
 
-        bytes memory calls = planner.finalizeModifyLiquidity(config.poolKey);
+        bytes memory calls = planner.finalizeModifyLiquidityWithClose(config.poolKey);
         lpm.modifyLiquidities(calls, _deadline);
 
         bytes32 positionId =
@@ -178,7 +210,7 @@ contract ExecuteTest is Test, PosmTestSetup, LiquidityFuzzers {
                 newConfig, newLiquidity, MAX_SLIPPAGE_INCREASE, MAX_SLIPPAGE_INCREASE, Constants.MSG_SENDER, ZERO_BYTES
             )
         );
-        bytes memory calls = planner.finalizeModifyLiquidity(config.poolKey);
+        bytes memory calls = planner.finalizeModifyLiquidityWithClose(config.poolKey);
 
         lpm.modifyLiquidities(calls, _deadline);
         {

test/position-managers/IncreaseLiquidity.t.sol

@@ -120,7 +120,7 @@ contract IncreaseLiquidityTest is Test, PosmTestSetup, Fuzzers {
         planner.add(
             Actions.INCREASE_LIQUIDITY, abi.encode(tokenIdAlice, config, liquidityDelta, 0 wei, 0 wei, ZERO_BYTES)
         );
-        bytes memory calls = planner.finalizeModifyLiquidity(config.poolKey);
+        bytes memory calls = planner.finalizeModifyLiquidityWithClose(config.poolKey);
         vm.startPrank(alice);
         lpm.modifyLiquidities(calls, _deadline);
         vm.stopPrank();