clean

.forge-snapshots/PositionManager_increaseLiquidity_erc20_withSettlePair.snap

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

.forge-snapshots/PositionManager_mint_nativeWithSweep_withClose.snap

@@ -0,0 +1 @@
+345267

.forge-snapshots/PositionManager_mint_nativeWithSweep_withSettlePair.snap

@@ -0,0 +1 @@
+344532

.forge-snapshots/PositionManager_mint_settleWithBalance_sweep.snap

@@ -1 +1 @@
-370018
+370064

.forge-snapshots/PositionManager_mint_withSettlePair.snap

@@ -0,0 +1 @@
+371253

src/PositionManager.sol

@@ -127,6 +127,9 @@ contract PositionManager is
         } else if (action == Actions.SETTLE_WITH_BALANCE) {
             Currency currency = params.decodeCurrency();
             _settleWithBalance(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, to);
@@ -221,6 +224,13 @@ contract PositionManager is
         _settle(currency, address(this), _getFullSettleAmount(currency));
     }
 
+    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

@@ -23,17 +23,17 @@ library Actions {
     uint256 constant SETTLE = 0x10;
     uint256 constant SETTLE_ALL = 0x11;
     uint256 constant SETTLE_WITH_BALANCE = 0x12;
+    uint256 constant SETTLE_PAIR = 0x13;
     // taking
     uint256 constant TAKE = 0x13;
     uint256 constant TAKE_ALL = 0x14;
     uint256 constant TAKE_PORTION = 0x15;
 
     uint256 constant CLOSE_CURRENCY = 0x16;
-    uint256 constant CLOSE_PAIR = 0x17;
-    uint256 constant CLEAR = 0x18;
-    uint256 constant SWEEP = 0x19;
+    uint256 constant CLEAR = 0x17;
+    uint256 constant SWEEP = 0x18;
 
     // minting/burning 6909s to close deltas
-    uint256 constant MINT_6909 = 0x20;
-    uint256 constant BURN_6909 = 0x21;
+    uint256 constant MINT_6909 = 0x19;
+    uint256 constant BURN_6909 = 0x20;
 }

src/libraries/CalldataDecoder.sol

@@ -117,6 +117,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

@@ -98,6 +98,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

@@ -65,6 +65,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

@@ -78,7 +78,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
@@ -100,7 +100,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 =
@@ -130,7 +162,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 =
@@ -175,7 +207,7 @@ contract ExecuteTest is Test, PosmTestSetup, LiquidityFuzzers {
             Actions.MINT_POSITION,
             abi.encode(newConfig, newLiquidity, MAX_SLIPPAGE_INCREASE, MAX_SLIPPAGE_INCREASE, address(this), 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

@@ -119,7 +119,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();

test/position-managers/NativeToken.t.sol

@@ -96,7 +96,7 @@ contract PositionManagerTest is Test, PosmTestSetup, LiquidityFuzzers {
     }
 
     // minting with excess native tokens are returned to caller
-    function test_fuzz_mint_native_excess(IPoolManager.ModifyLiquidityParams memory params) public {
+    function test_fuzz_mint_native_excess_withClose(IPoolManager.ModifyLiquidityParams memory params) public {
         params = createFuzzyLiquidityParams(nativeKey, params, SQRT_PRICE_1_1);
         vm.assume(params.tickLower < 0 && 0 < params.tickUpper); // two-sided liquidity
 
@@ -144,6 +144,53 @@ contract PositionManagerTest is Test, PosmTestSetup, LiquidityFuzzers {
         assertEq(balance1Before - currency1.balanceOfSelf(), uint256(int256(-delta.amount1())));
     }
 
+    function test_fuzz_mint_native_excess_withSettlePair(IPoolManager.ModifyLiquidityParams memory params) public {
+        params = createFuzzyLiquidityParams(nativeKey, params, SQRT_PRICE_1_1);
+        vm.assume(params.tickLower < 0 && 0 < params.tickUpper); // two-sided liquidity
+
+        uint256 liquidityToAdd =
+            params.liquidityDelta < 0 ? uint256(-params.liquidityDelta) : uint256(params.liquidityDelta);
+        PositionConfig memory config =
+            PositionConfig({poolKey: nativeKey, tickLower: params.tickLower, tickUpper: params.tickUpper});
+
+        uint256 balance0Before = currency0.balanceOfSelf();
+        uint256 balance1Before = currency1.balanceOfSelf();
+
+        uint256 tokenId = lpm.nextTokenId();
+
+        Plan memory planner = Planner.init();
+        planner.add(
+            Actions.MINT_POSITION,
+            abi.encode(config, liquidityToAdd, MAX_SLIPPAGE_INCREASE, MAX_SLIPPAGE_INCREASE, address(this), ZERO_BYTES)
+        );
+        planner.add(Actions.SETTLE_PAIR, abi.encode(nativeKey.currency0, nativeKey.currency1));
+        // sweep the excess eth
+        planner.add(Actions.SWEEP, abi.encode(currency0, address(this)));
+
+        bytes memory calls = planner.encode();
+
+        (uint256 amount0,) = LiquidityAmounts.getAmountsForLiquidity(
+            SQRT_PRICE_1_1,
+            TickMath.getSqrtPriceAtTick(params.tickLower),
+            TickMath.getSqrtPriceAtTick(params.tickUpper),
+            liquidityToAdd.toUint128()
+        );
+
+        // Mint with excess native tokens
+        lpm.modifyLiquidities{value: amount0 * 2 + 1}(calls, _deadline);
+        BalanceDelta delta = getLastDelta();
+
+        bytes32 positionId =
+            Position.calculatePositionKey(address(lpm), config.tickLower, config.tickUpper, bytes32(tokenId));
+        (uint256 liquidity,,) = manager.getPositionInfo(config.poolKey.toId(), positionId);
+        assertEq(liquidity, uint256(params.liquidityDelta));
+
+        // only paid the delta amount, with excess tokens returned to caller
+        assertEq(balance0Before - currency0.balanceOfSelf(), uint256(int256(-delta.amount0())));
+        assertEq(balance0Before - currency0.balanceOfSelf(), amount0 + 1); // TODO: off by one??
+        assertEq(balance1Before - currency1.balanceOfSelf(), uint256(int256(-delta.amount1())));
+    }
+
     function test_fuzz_burn_native_emptyPosition(IPoolManager.ModifyLiquidityParams memory params) public {
         uint256 balance0Start = address(this).balance;
         uint256 balance1Start = currency1.balanceOfSelf();
@@ -287,7 +334,7 @@ contract PositionManagerTest is Test, PosmTestSetup, LiquidityFuzzers {
     }
 
     // overpaying native tokens on increase liquidity is returned to caller
-    function test_fuzz_increaseLiquidity_native_excess(IPoolManager.ModifyLiquidityParams memory params) public {
+    function test_fuzz_increaseLiquidity_native_excess_withClose(IPoolManager.ModifyLiquidityParams memory params) public {
         // fuzz for the range
         params = createFuzzyLiquidityParams(nativeKey, params, SQRT_PRICE_1_1);
         vm.assume(params.tickLower < 0 && 0 < params.tickUpper); // two-sided liquidity
@@ -338,6 +385,56 @@ contract PositionManagerTest is Test, PosmTestSetup, LiquidityFuzzers {
         assertEq(balance1Before - currency1.balanceOfSelf(), uint256(int256(-delta.amount1())));
     }
 
+    function test_fuzz_increaseLiquidity_native_excess_withSettlePair(IPoolManager.ModifyLiquidityParams memory params) public {
+        // fuzz for the range
+        params = createFuzzyLiquidityParams(nativeKey, params, SQRT_PRICE_1_1);
+        vm.assume(params.tickLower < 0 && 0 < params.tickUpper); // two-sided liquidity
+
+        // TODO: figure out if we can fuzz the increase liquidity delta. we're annoyingly getting TickLiquidityOverflow
+        uint256 liquidityToAdd = 1e18;
+        PositionConfig memory config =
+            PositionConfig({poolKey: nativeKey, tickLower: params.tickLower, tickUpper: params.tickUpper});
+
+        // mint the position with native token liquidity
+        uint256 tokenId = lpm.nextTokenId();
+        mintWithNative(SQRT_PRICE_1_1, config, liquidityToAdd, address(this), ZERO_BYTES);
+
+        uint256 balance0Before = address(this).balance;
+        uint256 balance1Before = currency1.balanceOfSelf();
+
+        // calculate how much native token is required for the liquidity increase (doubling the liquidity)
+        (uint256 amount0,) = LiquidityAmounts.getAmountsForLiquidity(
+            SQRT_PRICE_1_1,
+            TickMath.getSqrtPriceAtTick(params.tickLower),
+            TickMath.getSqrtPriceAtTick(params.tickUpper),
+            uint128(liquidityToAdd)
+        );
+
+        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.SETTLE_PAIR, abi.encode(nativeKey.currency0, nativeKey.currency1));
+        // sweep the excess eth
+        planner.add(Actions.SWEEP, abi.encode(currency0, address(this)));
+        bytes memory calls = planner.encode();
+
+        lpm.modifyLiquidities{value: amount0 * 2}(calls, _deadline); // overpay on increase liquidity
+        BalanceDelta delta = getLastDelta();
+
+        // verify position liquidity increased
+        bytes32 positionId =
+            Position.calculatePositionKey(address(lpm), config.tickLower, config.tickUpper, bytes32(tokenId));
+        (uint256 liquidity,,) = manager.getPositionInfo(config.poolKey.toId(), positionId);
+        assertEq(liquidity, liquidityToAdd + liquidityToAdd); // liquidity was doubled
+
+        // verify native token balances changed as expected, with overpaid tokens returned
+        assertEq(balance0Before - currency0.balanceOfSelf(), amount0 + 1 wei);
+        assertEq(balance0Before - currency0.balanceOfSelf(), uint256(int256(-delta.amount0())));
+        assertEq(balance1Before - currency1.balanceOfSelf(), uint256(int256(-delta.amount1())));
+    }
+
     function test_fuzz_decreaseLiquidity_native(
         IPoolManager.ModifyLiquidityParams memory params,
         uint256 decreaseLiquidityDelta