@bananapus/univ4-lp-split-hook-v6 0.0.10 → 0.0.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bananapus/univ4-lp-split-hook-v6",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/JBUniswapV4LPSplitHook.sol

@@ -653,105 +653,17 @@ contract JBUniswapV4LPSplitHook is IJBUniswapV4LPSplitHook, IJBSplitHook, JBPerm
         address projectToken = address(IJBTokens(TOKENS).tokenOf(projectId));
         PoolKey memory key = _poolKeys[projectId][terminalToken];
 
-        // Step 1: Collect accrued fees via DECREASE_LIQUIDITY(0) + TAKE_PAIR
-        {
-            uint256 bal0Before = _currencyBalance(key.currency0);
-            uint256 bal1Before = _currencyBalance(key.currency1);
-
-            bytes memory feeActions = abi.encodePacked(uint8(Actions.DECREASE_LIQUIDITY), uint8(Actions.TAKE_PAIR));
-
-            bytes[] memory feeParams = new bytes[](2);
-            feeParams[0] = abi.encode(tokenId, uint256(0), uint128(0), uint128(0), "");
-            feeParams[1] = abi.encode(key.currency0, key.currency1, address(this));
-
-            POSITION_MANAGER.modifyLiquidities({
-                unlockData: abi.encode(feeActions, feeParams), deadline: block.timestamp + _DEADLINE_SECONDS
-            });
-
-            uint256 feeAmount0 = _currencyBalance(key.currency0) - bal0Before;
-            uint256 feeAmount1 = _currencyBalance(key.currency1) - bal1Before;
-
-            _routeCollectedFees({
-                projectId: projectId,
-                projectToken: projectToken,
-                terminalToken: terminalToken,
-                amount0: feeAmount0,
-                amount1: feeAmount1
-            });
-            _burnReceivedTokens({projectId: projectId, projectToken: projectToken});
-        }
-
-        // Step 2: Burn position to recover principal via BURN_POSITION + TAKE_PAIR
-        {
-            bytes memory burnActions = abi.encodePacked(uint8(Actions.BURN_POSITION), uint8(Actions.TAKE_PAIR));
-
-            bytes[] memory burnParams = new bytes[](2);
-            // Safe: min amounts are user-provided slippage params; PositionManager accepts uint128.
-            // forge-lint: disable-next-line(unsafe-typecast)
-            burnParams[0] = abi.encode(tokenId, uint128(decreaseAmount0Min), uint128(decreaseAmount1Min), "");
-            burnParams[1] = abi.encode(key.currency0, key.currency1, address(this));
-
-            POSITION_MANAGER.modifyLiquidities({
-                unlockData: abi.encode(burnActions, burnParams), deadline: block.timestamp + _DEADLINE_SECONDS
-            });
-        }
-
-        // Step 2: Mint new position with updated tick bounds
-        {
-            uint256 projectTokenBalance = IERC20(projectToken).balanceOf(address(this));
-            uint256 terminalTokenBalance = _getTerminalTokenBalance(terminalToken);
-
-            (int24 tickLower, int24 tickUpper) =
-                _calculateTickBounds({projectId: projectId, terminalToken: terminalToken, projectToken: projectToken});
-
-            // Use the actual pool price for liquidity calculation so the target matches the pool's
-            // current state. Using JB issuance price here would produce suboptimal liquidity when the
-            // pool price has diverged.
-            // slither-disable-next-line unused-return
-            (uint160 sqrtPriceX96,,,) = POOL_MANAGER.getSlot0(key.toId());
-            uint160 sqrtPriceA = TickMath.getSqrtPriceAtTick(tickLower);
-            uint160 sqrtPriceB = TickMath.getSqrtPriceAtTick(tickUpper);
-
-            // Sort amounts by currency order
-            Currency terminalCurrency = _toCurrency(terminalToken);
-            (address token0,) = _sortTokens({tokenA: projectToken, tokenB: Currency.unwrap(terminalCurrency)});
-            uint256 amount0 = projectToken == token0 ? projectTokenBalance : terminalTokenBalance;
-            uint256 amount1 = projectToken == token0 ? terminalTokenBalance : projectTokenBalance;
-
-            // Calculate liquidity from amounts
-            uint128 liquidity = LiquidityAmounts.getLiquidityForAmounts({
-                sqrtPriceX96: sqrtPriceX96,
-                sqrtPriceAX96: sqrtPriceA,
-                sqrtPriceBX96: sqrtPriceB,
-                amount0: amount0,
-                amount1: amount1
-            });
-
-            if (liquidity > 0) {
-                uint256 newTokenId = POSITION_MANAGER.nextTokenId();
-
-                _mintPosition({
-                    key: key,
-                    tickLower: tickLower,
-                    tickUpper: tickUpper,
-                    liquidity: liquidity,
-                    amount0: amount0,
-                    amount1: amount1
-                });
+        _collectAndRouteFees({
+            projectId: projectId, projectToken: projectToken, terminalToken: terminalToken, tokenId: tokenId, key: key
+        });
 
-                tokenIdOf[projectId][terminalToken] = newTokenId;
-            } else {
-                // Zero liquidity means the position cannot be re-created (e.g., price moved
-                // outside tick range making the position single-sided with zero on one side).
-                // Revert to prevent bricking the project's LP — the old position was already
-                // burned by the BURN_POSITION action above, so this protects the invariant
-                // that tokenIdOf is always nonzero for deployed projects.
-                revert JBUniswapV4LPSplitHook_InsufficientLiquidity();
-            }
+        _burnExistingPosition({
+            tokenId: tokenId, key: key, decreaseAmount0Min: decreaseAmount0Min, decreaseAmount1Min: decreaseAmount1Min
+        });
 
-            // Handle leftover tokens
-            _handleLeftoverTokens({projectId: projectId, projectToken: projectToken, terminalToken: terminalToken});
-        }
+        _mintRebalancedPosition({
+            projectId: projectId, projectToken: projectToken, terminalToken: terminalToken, key: key
+        });
     }
 
     //*********************************************************************//
@@ -899,6 +811,38 @@ contract JBUniswapV4LPSplitHook is IJBUniswapV4LPSplitHook, IJBSplitHook, JBPerm
         return rounded;
     }
 
+    /// @notice Burn an existing LP position via `BURN_POSITION` + `TAKE_PAIR` and recover its principal.
+    /// @dev Called during rebalancing after fees have already been collected. The recovered tokens remain in
+    /// this contract for the subsequent `_mintRebalancedPosition` call.
+    /// @param tokenId The Uniswap V4 position NFT token ID to burn.
+    /// @param key The pool key identifying the Uniswap V4 pool.
+    /// @param decreaseAmount0Min Minimum amount of token0 to receive (slippage protection).
+    /// @param decreaseAmount1Min Minimum amount of token1 to receive (slippage protection).
+    function _burnExistingPosition(
+        uint256 tokenId,
+        PoolKey memory key,
+        uint256 decreaseAmount0Min,
+        uint256 decreaseAmount1Min
+    )
+        internal
+    {
+        // BURN_POSITION removes all remaining liquidity and destroys the NFT.
+        // TAKE_PAIR transfers the recovered token0 and token1 to this contract.
+        bytes memory burnActions = abi.encodePacked(uint8(Actions.BURN_POSITION), uint8(Actions.TAKE_PAIR));
+
+        bytes[] memory burnParams = new bytes[](2);
+        // BURN_POSITION params: (tokenId, minAmount0, minAmount1, hookData).
+        // Min amounts are caller-supplied slippage bounds; PositionManager accepts uint128.
+        // forge-lint: disable-next-line(unsafe-typecast)
+        burnParams[0] = abi.encode(tokenId, uint128(decreaseAmount0Min), uint128(decreaseAmount1Min), "");
+        // TAKE_PAIR params: (currency0, currency1, recipient).
+        burnParams[1] = abi.encode(key.currency0, key.currency1, address(this));
+
+        POSITION_MANAGER.modifyLiquidities({
+            unlockData: abi.encode(burnActions, burnParams), deadline: block.timestamp + _DEADLINE_SECONDS
+        });
+    }
+
     /// @notice Burn project tokens using the controller
     // slither-disable-next-line incorrect-equality,reentrancy-events
     function _burnProjectTokens(uint256 projectId, address projectToken, uint256 amount, string memory memo) internal {
@@ -989,6 +933,59 @@ contract JBUniswapV4LPSplitHook is IJBUniswapV4LPSplitHook, IJBSplitHook, JBPerm
         }
     }
 
+    /// @notice Collect accrued Uniswap LP trading fees and route them to the project's terminal balance.
+    /// @dev Uses `DECREASE_LIQUIDITY(0)` to trigger fee collection without removing any principal, followed by
+    /// `TAKE_PAIR` to transfer the fees to this contract. Terminal-token fees are added to the project's balance;
+    /// project-token fees are burned to avoid inflating supply.
+    /// @param projectId The ID of the Juicebox project whose LP fees are being collected.
+    /// @param projectToken The project's ERC-20 token address.
+    /// @param terminalToken The terminal token (e.g. ETH or USDC) paired with the project token.
+    /// @param tokenId The Uniswap V4 position NFT token ID to collect fees from.
+    /// @param key The pool key identifying the Uniswap V4 pool.
+    // slither-disable-next-line reentrancy-eth,reentrancy-benign,reentrancy-events
+    function _collectAndRouteFees(
+        uint256 projectId,
+        address projectToken,
+        address terminalToken,
+        uint256 tokenId,
+        PoolKey memory key
+    )
+        internal
+    {
+        // Snapshot balances before collection to isolate fee amounts from any existing balance.
+        uint256 bal0Before = _currencyBalance(key.currency0);
+        uint256 bal1Before = _currencyBalance(key.currency1);
+
+        // DECREASE_LIQUIDITY with amount=0 triggers fee collection without removing principal.
+        // TAKE_PAIR transfers the collected fees (both currencies) to this contract.
+        bytes memory feeActions = abi.encodePacked(uint8(Actions.DECREASE_LIQUIDITY), uint8(Actions.TAKE_PAIR));
+
+        bytes[] memory feeParams = new bytes[](2);
+        // DECREASE_LIQUIDITY params: (tokenId, liquidity=0, minAmount0=0, minAmount1=0, hookData).
+        feeParams[0] = abi.encode(tokenId, uint256(0), uint128(0), uint128(0), "");
+        // TAKE_PAIR params: (currency0, currency1, recipient).
+        feeParams[1] = abi.encode(key.currency0, key.currency1, address(this));
+
+        POSITION_MANAGER.modifyLiquidities({
+            unlockData: abi.encode(feeActions, feeParams), deadline: block.timestamp + _DEADLINE_SECONDS
+        });
+
+        // Diff balances to determine exactly how much was collected as fees.
+        uint256 feeAmount0 = _currencyBalance(key.currency0) - bal0Before;
+        uint256 feeAmount1 = _currencyBalance(key.currency1) - bal1Before;
+
+        // Route terminal-token fees to the project's balance; project-token fees are burned below.
+        _routeCollectedFees({
+            projectId: projectId,
+            projectToken: projectToken,
+            terminalToken: terminalToken,
+            amount0: feeAmount0,
+            amount1: feeAmount1
+        });
+        // Burn any project tokens received as fees to avoid inflating circulating supply.
+        _burnReceivedTokens({projectId: projectId, projectToken: projectToken});
+    }
+
     /// @notice Compute the initial sqrtPriceX96 for pool initialization
     function _computeInitialSqrtPrice(
         uint256 projectId,
@@ -1267,6 +1264,80 @@ contract JBUniswapV4LPSplitHook is IJBUniswapV4LPSplitHook, IJBSplitHook, JBPerm
         });
     }
 
+    /// @notice Mint a new LP position with tick bounds recalculated from current issuance and cash-out rates.
+    /// @dev Called after `_burnExistingPosition` has recovered the old position's principal. Computes liquidity from
+    /// this contract's current token balances and the pool's live `sqrtPriceX96`. Reverts with
+    /// `JBUniswapV4LPSplitHook_InsufficientLiquidity` if the resulting liquidity is zero (e.g. price moved entirely
+    /// outside the new tick range), preventing `tokenIdOf` from being left stale. Any leftover tokens after minting
+    /// are routed back to the project via `_handleLeftoverTokens`.
+    /// @param projectId The ID of the Juicebox project being rebalanced.
+    /// @param projectToken The project's ERC-20 token address.
+    /// @param terminalToken The terminal token paired with the project token.
+    /// @param key The pool key identifying the Uniswap V4 pool.
+    // slither-disable-next-line reentrancy-eth,reentrancy-benign,reentrancy-events
+    function _mintRebalancedPosition(
+        uint256 projectId,
+        address projectToken,
+        address terminalToken,
+        PoolKey memory key
+    )
+        internal
+    {
+        uint256 projectTokenBalance = IERC20(projectToken).balanceOf(address(this));
+        uint256 terminalTokenBalance = _getTerminalTokenBalance(terminalToken);
+
+        (int24 tickLower, int24 tickUpper) =
+            _calculateTickBounds({projectId: projectId, terminalToken: terminalToken, projectToken: projectToken});
+
+        // Use the actual pool price for liquidity calculation so the target matches the pool's
+        // current state. Using JB issuance price here would produce suboptimal liquidity when the
+        // pool price has diverged.
+        // slither-disable-next-line unused-return
+        (uint160 sqrtPriceX96,,,) = POOL_MANAGER.getSlot0(key.toId());
+        uint160 sqrtPriceA = TickMath.getSqrtPriceAtTick(tickLower);
+        uint160 sqrtPriceB = TickMath.getSqrtPriceAtTick(tickUpper);
+
+        // Map token balances to (amount0, amount1) matching the pool's currency ordering.
+        Currency terminalCurrency = _toCurrency(terminalToken);
+        (address token0,) = _sortTokens({tokenA: projectToken, tokenB: Currency.unwrap(terminalCurrency)});
+        uint256 amount0 = projectToken == token0 ? projectTokenBalance : terminalTokenBalance;
+        uint256 amount1 = projectToken == token0 ? terminalTokenBalance : projectTokenBalance;
+
+        // Derive the maximum liquidity mintable from our balances at the current pool price.
+        uint128 liquidity = LiquidityAmounts.getLiquidityForAmounts({
+            sqrtPriceX96: sqrtPriceX96,
+            sqrtPriceAX96: sqrtPriceA,
+            sqrtPriceBX96: sqrtPriceB,
+            amount0: amount0,
+            amount1: amount1
+        });
+
+        if (liquidity > 0) {
+            uint256 newTokenId = POSITION_MANAGER.nextTokenId();
+
+            _mintPosition({
+                key: key,
+                tickLower: tickLower,
+                tickUpper: tickUpper,
+                liquidity: liquidity,
+                amount0: amount0,
+                amount1: amount1
+            });
+
+            tokenIdOf[projectId][terminalToken] = newTokenId;
+        } else {
+            // Zero liquidity means the position cannot be re-created (e.g., price moved
+            // outside tick range making the position single-sided with zero on one side).
+            // Revert to prevent bricking the project's LP — the old position was already
+            // burned by the BURN_POSITION action above, so this protects the invariant
+            // that tokenIdOf is always nonzero for deployed projects.
+            revert JBUniswapV4LPSplitHook_InsufficientLiquidity();
+        }
+
+        // Return any dust left over after minting (due to rounding or single-sided excess) to the project.
+        _handleLeftoverTokens({projectId: projectId, projectToken: projectToken, terminalToken: terminalToken});
+    }
+
     /// @notice Approve an ERC20 token via Permit2 so PositionManager can pull it during SETTLE.
     function _approveViaPermit2(address token, uint256 amount) internal {
         IERC20(token).forceApprove({spender: address(PERMIT2), value: amount});