Add transfer support

.forge-snapshots/PositionManager_increaseLiquidity_erc20.snap

@@ -1 +1 @@
-152726
+152736

.forge-snapshots/PositionManager_increaseLiquidity_native.snap

@@ -1 +1 @@
-134609
+134536

.forge-snapshots/PositionManager_mint.snap

@@ -1 +1 @@
-372827
+372837

.forge-snapshots/PositionManager_mint_native.snap

@@ -1 +1 @@
-337610
+337537

.forge-snapshots/PositionManager_mint_nativeWithSweep.snap

@@ -1 +1 @@
-344548
+346399

.forge-snapshots/PositionManager_mint_onSameTickLower.snap

@@ -1 +1 @@
-315509
+315519

.forge-snapshots/PositionManager_mint_onSameTickUpper.snap

@@ -1 +1 @@
-316151
+316161

.forge-snapshots/PositionManager_mint_sameRange.snap

@@ -1 +1 @@
-241733
+241743

.forge-snapshots/PositionManager_mint_settleWithBalance_sweep.snap

@@ -0,0 +1 @@
+371451

.forge-snapshots/PositionManager_mint_warmedPool_differentRange.snap

@@ -1 +1 @@
-321527
+321537

.forge-snapshots/PositionManager_multicall_initialize_mint.snap

@@ -1 +1 @@
-417163
+417173

src/PositionManager.sol

@@ -83,6 +83,10 @@ contract PositionManager is
         } else if (action == Actions.BURN_POSITION) {
             // Will automatically decrease liquidity to 0 if the position is not already empty.
             _burn(params);
+        } else if (action == Actions.SETTLE_WITH_BALANCE) {
+            _settleWithBalance(params);
+        } else if (action == Actions.SWEEP) {
+            _sweep(params);
         } else {
             revert UnsupportedAction(action);
         }
@@ -146,14 +150,20 @@ contract PositionManager is
         address caller = _msgSender();
         if (currencyDelta < 0) {
             _settle(currency, caller, uint256(-currencyDelta));
-
-            // if there are native tokens left over after settling, return to locker
-            if (currency.isNative()) _sweepNativeToken(caller);
         } else if (currencyDelta > 0) {
             _take(currency, caller, uint256(currencyDelta));
         }
     }
 
+    /// @param params is an encoding of Currency
+    /// @dev uses this addresses balance to settle a negative delta
+    function _settleWithBalance(bytes memory params) internal {
+        Currency currency = abi.decode(params, (Currency));
+
+        // set the payer to this address, performs a transfer.
+        _settle(currency, address(this), _getFullSettleAmount(currency));
+    }
+
     /// @param params is an encoding of uint256 tokenId, PositionConfig memory config, bytes hookData
     /// @dev this is overloaded with ERC721Permit._burn
     function _burn(bytes memory params) internal {
@@ -202,16 +212,28 @@ contract PositionManager is
         liquidity = poolManager.getPositionLiquidity(config.poolKey.toId(), positionId);
     }
 
-    /// @dev Send excess native tokens back to the recipient (locker)
-    /// @param recipient the receiver of the excess native tokens. Should be the caller, the one that sent the native tokens
-    function _sweepNativeToken(address recipient) internal {
-        uint256 nativeBalance = address(this).balance;
-        if (nativeBalance > 0) recipient.safeTransferETH(nativeBalance);
+    /// @notice Sweeps the entire contract balance of specified currency to the recipient
+    /// @param params an encoding of Currency, address
+    function _sweep(bytes calldata params) internal {
+        (Currency currency, address to) = abi.decode(params, (Currency, address));
+        uint256 balance = currency.balanceOfSelf();
+        if (balance > 0) currency.transfer(to, balance);
     }
 
     // implementation of abstract function DeltaResolver._pay
-    function _pay(Currency token, address payer, uint256 amount) internal override {
-        // TODO: Should we also support direct transfer?
-        permit2.transferFrom(payer, address(poolManager), uint160(amount), Currency.unwrap(token));
+    function _pay(Currency currency, address payer, uint256 amount) internal override {
+        if (payer == address(this)) {
+            // TODO: currency is guaranteed to not be eth so the native check in transfer is not optimal.
+            currency.transfer(address(poolManager), amount);
+        } else {
+            permit2.transferFrom(payer, address(poolManager), uint160(amount), Currency.unwrap(currency));
+        }
+    }
+
+    function _getFullSettleAmount(Currency currency) private view returns (uint256 amount) {
+        int256 _amount = poolManager.currencyDelta(address(this), currency);
+        // If the amount is positive, it should be taken not settled for.
+        if (_amount > 0) revert IncorrectUseOfSettle();
+        amount = uint256(-_amount);
     }
 }

src/interfaces/IPositionManager.sol

@@ -6,6 +6,7 @@ import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
 interface IPositionManager {
     error NotApproved(address caller);
     error DeadlinePassed();
+    error IncorrectUseOfSettle();
     error IncorrectPositionConfigForTokenId(uint256 tokenId);
 
     /// @notice Maps the ERC721 tokenId to a configId, which is a keccak256 hash of the position's pool key, and range (tickLower, tickUpper)

src/libraries/Actions.sol

@@ -32,4 +32,8 @@ library Actions {
     // mint + burn ERC721 position
     uint256 constant MINT_POSITION = 0x22;
     uint256 constant BURN_POSITION = 0x23;
+
+    // settle using the balance contract
+    uint256 constant SETTLE_WITH_BALANCE = 0x24;
+    uint256 constant SWEEP = 0x25;
 }

test/position-managers/IncreaseLiquidity.t.sol

@@ -338,4 +338,42 @@ contract IncreaseLiquidityTest is Test, PosmTestSetup, Fuzzers {
             );
         }
     }
+
+    function test_mint_settleWithBalance() public {
+        uint256 liquidityAlice = 3_000e18;
+
+        Plan memory planner = Planner.init();
+        planner.add(Actions.MINT_POSITION, abi.encode(config, liquidityAlice, alice, ZERO_BYTES));
+        planner.add(Actions.SETTLE_WITH_BALANCE, abi.encode(currency0));
+        planner.add(Actions.SETTLE_WITH_BALANCE, abi.encode(currency1));
+        planner.add(Actions.SWEEP, abi.encode(currency0, address(this)));
+        planner.add(Actions.SWEEP, abi.encode(currency1, address(this)));
+
+        uint256 balanceBefore0 = currency0.balanceOf(address(this));
+        uint256 balanceBefore1 = currency1.balanceOf(address(this));
+
+        assertEq(currency0.balanceOf(address(lpm)), 0);
+        assertEq(currency0.balanceOf(address(lpm)), 0);
+
+        currency0.transfer(address(lpm), 100e18);
+        currency1.transfer(address(lpm), 100e18);
+
+        assertEq(currency0.balanceOf(address(lpm)), 100e18);
+        assertEq(currency0.balanceOf(address(lpm)), 100e18);
+
+        bytes memory calls = planner.encode();
+
+        vm.prank(alice);
+        lpm.modifyLiquidities(calls, _deadline);
+        BalanceDelta delta = getLastDelta();
+        uint256 amount0 = uint128(-delta.amount0());
+        uint256 amount1 = uint128(-delta.amount1());
+
+        // The balances were swept back to this address.
+        assertEq(IERC20(Currency.unwrap(currency0)).balanceOf(address(lpm)), 0);
+        assertEq(IERC20(Currency.unwrap(currency1)).balanceOf(address(lpm)), 0);
+
+        assertEq(currency0.balanceOf(address(this)), balanceBefore0 - amount0);
+        assertEq(currency1.balanceOf(address(this)), balanceBefore1 - amount1);
+    }
 }

test/position-managers/NativeToken.t.sol

@@ -109,7 +109,15 @@ contract PositionManagerTest is Test, PosmTestSetup, LiquidityFuzzers {
         uint256 balance1Before = currency1.balanceOfSelf();
 
         uint256 tokenId = lpm.nextTokenId();
-        bytes memory calls = getMintEncoded(config, liquidityToAdd, address(this), ZERO_BYTES);
+
+        Plan memory planner = Planner.init();
+        planner.add(Actions.MINT_POSITION, abi.encode(config, liquidityToAdd, address(this), ZERO_BYTES));
+        planner.add(Actions.CLOSE_CURRENCY, abi.encode(nativeKey.currency0));
+        planner.add(Actions.CLOSE_CURRENCY, abi.encode(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,
@@ -301,7 +309,14 @@ contract PositionManagerTest is Test, PosmTestSetup, LiquidityFuzzers {
             uint128(liquidityToAdd)
         );
 
-        bytes memory calls = getIncreaseEncoded(tokenId, config, liquidityToAdd, ZERO_BYTES); // double the liquidity
+        Plan memory planner = Planner.init();
+        planner.add(Actions.INCREASE_LIQUIDITY, abi.encode(tokenId, config, liquidityToAdd, ZERO_BYTES));
+        planner.add(Actions.CLOSE_CURRENCY, abi.encode(nativeKey.currency0));
+        planner.add(Actions.CLOSE_CURRENCY, abi.encode(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();
 

test/position-managers/PositionManager.gas.t.sol

@@ -376,7 +376,13 @@ contract PosMGasTest is Test, PosmTestSetup, GasSnapshot {
 
     function test_gas_mint_native_excess() public {
         uint256 liquidityToAdd = 10_000 ether;
-        bytes memory calls = getMintEncoded(configNative, liquidityToAdd, address(this), ZERO_BYTES);
+
+        Plan memory planner = Planner.init();
+        planner.add(Actions.MINT_POSITION, abi.encode(configNative, liquidityToAdd, address(this), ZERO_BYTES));
+        planner.add(Actions.CLOSE_CURRENCY, abi.encode(nativeKey.currency0));
+        planner.add(Actions.CLOSE_CURRENCY, abi.encode(nativeKey.currency1));
+        planner.add(Actions.SWEEP, abi.encode(CurrencyLibrary.NATIVE, address(this)));
+        bytes memory calls = planner.encode();
 
         (uint256 amount0,) = LiquidityAmounts.getAmountsForLiquidity(
             SQRT_PRICE_1_1,
@@ -466,4 +472,24 @@ contract PosMGasTest is Test, PosmTestSetup, GasSnapshot {
         lpm.modifyLiquidities(calls, _deadline);
         snapLastCall("PositionManager_decrease_burnEmpty_native");
     }
+
+    function test_gas_mint_settleWithBalance_sweep() public {
+        uint256 liquidityAlice = 3_000e18;
+
+        Plan memory planner = Planner.init();
+        planner.add(Actions.MINT_POSITION, abi.encode(config, liquidityAlice, alice, ZERO_BYTES));
+        planner.add(Actions.SETTLE_WITH_BALANCE, abi.encode(currency0));
+        planner.add(Actions.SETTLE_WITH_BALANCE, abi.encode(currency1));
+        planner.add(Actions.SWEEP, abi.encode(currency0, address(this)));
+        planner.add(Actions.SWEEP, abi.encode(currency1, address(this)));
+
+        currency0.transfer(address(lpm), 100e18);
+        currency1.transfer(address(lpm), 100e18);
+
+        bytes memory calls = planner.encode();
+
+        vm.prank(alice);
+        lpm.modifyLiquidities(calls, _deadline);
+        snapLastCall("PositionManager_mint_settleWithBalance_sweep");
+    }
 }