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

package/ADMINISTRATION.md

@@ -33,7 +33,7 @@ Admin privileges and their scope in univ4-lp-split-hook-v6.
 
 | Function | Required Role | Permission ID | Scope | What It Does |
 |----------|--------------|---------------|-------|-------------|
-| `deployPool(projectId, terminalToken, amount0Min, amount1Min, minCashOutReturn)` | Project owner or SET_BUYBACK_POOL operator. **Becomes permissionless** when the current ruleset weight has decayed to 1/10th or less of `initialWeightOf[projectId]`. | `JBPermissionIds.SET_BUYBACK_POOL` (26) | Per-project, per-terminal-token | Creates a Uniswap V4 pool at the geometric mean of issuance/cashout rates. Cashes out a computed fraction of accumulated project tokens for terminal tokens, mints a concentrated LP position, and transitions the project from accumulation to burn mode. (Lines 491-531) |
+| `deployPool(projectId, terminalToken, amount0Min, amount1Min, minCashOutReturn)` | Project owner or SET_BUYBACK_POOL operator. **Becomes permissionless** when the current ruleset weight has decayed to 1/10th or less of `initialWeightOf[projectId]`. | `JBPermissionIds.SET_BUYBACK_POOL` (26) | Per-project, single terminal-token path | Creates a Uniswap V4 pool at the geometric mean of issuance/cashout rates. Cashes out a computed fraction of accumulated project tokens for terminal tokens, mints a concentrated LP position, and transitions the project from accumulation to burn mode. This permanently commits the hook instance to one terminal-token path for that project. |
 | `rebalanceLiquidity(projectId, terminalToken, ...)` | Project owner or SET_BUYBACK_POOL operator | `JBPermissionIds.SET_BUYBACK_POOL` (26) | Per-project, per-terminal-token | Burns the existing LP position NFT, collects and routes accrued fees, recalculates tick bounds from current issuance/cashout rates, and mints a new position with updated bounds. Reverts with `InsufficientLiquidity` if the new position would have zero liquidity. (Lines 559-658) |
 | `claimFeeTokensFor(projectId, beneficiary)` | Project owner or SET_BUYBACK_POOL operator | `JBPermissionIds.SET_BUYBACK_POOL` (26) | Per-project | Transfers accumulated fee-project tokens to the specified beneficiary address. Validates the caller's permission, not the beneficiary's identity. Zeroes `claimableFeeTokens[projectId]` before transferring. (Lines 441-456) |
 | `processSplitWith(context)` | JB Controller (system) | None (checked via `controllerOf`) | Per-project | Only callable by the project's registered controller. Accumulates project tokens (pre-deployment) or burns them (post-deployment). Validates `context.split.hook == address(this)`, `groupId == 1`, and controller identity. (Lines 534-555) |
@@ -98,6 +98,7 @@ What admins **cannot** do:
 4. **Cannot modify pool parameters after deployment.** The `PoolKey` (fee tier, tick spacing, hook address, currency pair) is set during `_createAndInitializePool()` and stored immutably in `_poolKeys`.
 
 5. **Cannot deploy a second pool for the same project/terminal-token pair.** `deployPool()` reverts with `PoolAlreadyDeployed` if `tokenIdOf[projectId][terminalToken] != 0`.
+6. **Cannot deploy a second terminal-token pool for the same project.** `processSplitWith` only receives the project token, not the terminal token. Once any pool is deployed, the project enters burn mode and `deployPool()` reverts with `OnlyOneTerminalTokenSupported` for other terminal tokens.
 
 6. **Cannot prevent permissionless fee collection.** `collectAndRouteLPFees()` has no access control. Anyone can trigger fee collection and routing for any deployed pool.
 

package/ARCHITECTURE.md

@@ -2,7 +2,7 @@
 
 ## Purpose
 
-Uniswap V4 liquidity pool deployment hook for Juicebox V6. Receives project tokens via reserved token splits, accumulates them until a deployment threshold is met, then creates a Uniswap V4 pool and provides initial liquidity. After deployment, burns new tokens and routes LP fees back to the project.
+Uniswap V4 liquidity pool deployment hook for Juicebox V6. Receives project tokens via reserved token splits, accumulates them until a deployment threshold is met, then creates one Uniswap V4 pool for the project and provides initial liquidity. After deployment, burns new tokens and routes LP fees back to the project.
 
 **Requirement:** The project must have a deployed ERC-20 token (via `JBTokens.deployERC20For`). Projects using only internal credits (`tokenOf == address(0)`) are rejected — credits cannot be paired as Uniswap V4 LP. `processSplitWith` reverts with `InvalidProjectId` if the token is `address(0)`.
 
@@ -26,7 +26,7 @@ Reserved token distribution → JBMultiTerminal.sendPayoutsOf()
     → Track accumulated balance
 
 Owner/Operator → deployPool()
-  → Validate: enough tokens accumulated
+  → Validate: enough tokens accumulated and no other terminal-token pool already exists for the project
   → Create Uniswap V4 pool (projectToken/terminalToken) with ORACLE_HOOK (TWAP via observe())
   → Provide initial liquidity from accumulated tokens
   → Set up LP position

package/README.md

@@ -1,6 +1,6 @@
 # Juicebox UniV4 LP Split Hook
 
-Juicebox split hook that accumulates reserved project tokens over time, then deploys a Uniswap V4 concentrated liquidity position bounded by the project's issuance rate (ceiling) and cash-out rate (floor). After deployment, it manages fee collection, liquidity rebalancing, and routes LP fees back to the project with a configurable fee split.
+Juicebox split hook that accumulates reserved project tokens over time, then deploys a single Uniswap V4 concentrated liquidity position for that project, bounded by the project's issuance rate (ceiling) and cash-out rate (floor). After deployment, it manages fee collection, liquidity rebalancing, and routes LP fees back to the project with a configurable fee split.
 
 [Docs](https://docs.juicebox.money) | [Discord](https://discord.gg/juicebox)
 
@@ -10,7 +10,7 @@ This hook connects Juicebox's reserved token system to Uniswap V4's concentrated
 
 **Stage 1 -- Accumulation:** Configure the hook as a reserved-token split in a project's ruleset. Each time reserved tokens are distributed, the hook accumulates them. This continues across multiple ruleset cycles until enough tokens are collected.
 
-**Stage 2 -- Deployment & Operation:** The project owner calls `deployPool()` to create a V4 pool and mint an LP position. The hook cashes out a geometrically-optimized fraction of the accumulated tokens (typically 15-30%) for terminal tokens, then provides both as concentrated liquidity bounded by the project's economic rates. After deployment, any newly received reserved tokens are burned to prevent LP dilution.
+**Stage 2 -- Deployment & Operation:** The project owner calls `deployPool()` to create a V4 pool and mint an LP position. This permanently selects the project's terminal-token path for this hook instance. The hook cashes out a geometrically-optimized fraction of the accumulated tokens (typically 15-30%) for terminal tokens, then provides both as concentrated liquidity bounded by the project's economic rates. After deployment, any newly received reserved tokens are burned to prevent LP dilution.
 
 The LP position is bounded by two rate-derived ticks:
 - **Lower bound (floor):** The cash-out rate -- what you get from redeeming project tokens via the bonding curve
@@ -153,6 +153,7 @@ script/
 - **Impermanent loss:** The LP position is subject to standard concentrated liquidity IL. If the market price moves outside the [cashOut, issuance] range, the position becomes single-sided.
 - **Stale tick bounds:** If the project's issuance or cash-out rates change significantly (e.g., new ruleset with different weight), the LP position bounds become stale. The project owner must call `rebalanceLiquidity` to update them.
 - **Cash-out price impact:** The initial `deployPool` cashes out a fraction of accumulated tokens, which affects the bonding curve. Large accumulations may create meaningful price impact.
+- **One terminal token per project:** `processSplitWith` does not receive the terminal token, so once any pool is deployed the hook permanently switches the project into burn mode. A second terminal-token pool is intentionally unsupported and `deployPool()` reverts.
 - **One position per pool:** The hook manages a single V4 NFT position per project/terminal-token pair. Rebalancing destroys and recreates it, temporarily leaving no active position.
 - **Fee-project token accumulation:** Fee-project tokens are held by the hook until claimed via `claimFeeTokensFor`. If the fee project token changes or is not deployed, tokens may be stuck.
 - **Rebalance to zero liquidity:** If both token balances are zero when rebalancing, the transaction reverts with `InsufficientLiquidity` to prevent bricking the position (tokenIdOf would become zero while projectDeployed remains true).

package/SKILLS.md

@@ -17,13 +17,13 @@ Juicebox reserved-token split hook that accumulates project tokens, deploys a Un
 
 | Function | What it does |
 |----------|-------------|
-| `processSplitWith(context)` | Called by controller during reserved token distribution. If no pool deployed: accumulates tokens. If pool exists: burns received tokens. Only accepts `groupId == 1` (reserved tokens); reverts on payout splits (`groupId == 0`). |
+| `processSplitWith(context)` | Called by controller during reserved token distribution. If no pool deployed: accumulates tokens. If pool exists: burns received tokens. Only accepts `groupId == 1` (reserved tokens); reverts on payout splits (`groupId == 0`). Because the split context has no terminal token, one deployment permanently switches the project into burn mode. |
 
 ### Pool Deployment
 
 | Function | What it does |
 |----------|-------------|
-| `deployPool(projectId, terminalToken, amount0Min, amount1Min, minCashOutReturn)` | Requires `SET_BUYBACK_POOL` permission unless the current ruleset's weight has decayed to 1/10th or less of `initialWeightOf[projectId]` (becomes permissionless). Creates V4 pool at geometric mean of [cashOut, issuance] rates. Computes optimal cash-out fraction, cashes out tokens via terminal, mints concentrated LP position, handles leftovers (burns project tokens, adds terminal tokens to project balance). Sets `projectDeployed = true`. |
+| `deployPool(projectId, terminalToken, amount0Min, amount1Min, minCashOutReturn)` | Requires `SET_BUYBACK_POOL` permission unless the current ruleset's weight has decayed to 1/10th or less of `initialWeightOf[projectId]` (becomes permissionless). Creates V4 pool at geometric mean of [cashOut, issuance] rates. Computes optimal cash-out fraction, cashes out tokens via terminal, mints concentrated LP position, handles leftovers (burns project tokens, adds terminal tokens to project balance). Once a pool exists, a different `terminalToken` for the same project is rejected. |
 
 ### Fee Management
 
@@ -127,7 +127,7 @@ Juicebox reserved-token split hook that accumulates project tokens, deploys a Un
 | `accumulatedProjectTokens` | `projectId => uint256` | Pre-deployment token accumulation |
 | `initialWeightOf` | `projectId => uint256` | Ruleset weight when first tokens were accumulated (for 10x decay check) |
 | `projectDeployed` | `projectId => terminalToken => bool` | Whether a V4 pool has been deployed for this project/token pair |
-| `deployedPoolCount` | `projectId => uint256` | Number of pools deployed for project (used for accumulate vs burn decision in processSplitWith) |
+| `deployedPoolCount` | `projectId => uint256` | Number of pools deployed for project. Intentionally capped at 1 because processSplitWith cannot distinguish terminal-token paths. |
 | `claimableFeeTokens` | `projectId => uint256` | Fee-project tokens claimable via `claimFeeTokensFor` |
 | `initialized` | `bool` | Prevents re-initialization of clone instances |
 | `ORACLE_HOOK` | `IHooks` (immutable) | Oracle hook for all JB V4 pools. Set in constructor. All pools are created with this hook in the `PoolKey.hooks` field, providing TWAP via `observe()`. |

package/USER_JOURNEYS.md

@@ -46,7 +46,7 @@ A new `JBUniswapV4LPSplitHook` clone is deployed, initialized, and registered. I
 
 ### Precondition
 
-The project's ruleset has a reserved token split configured with `hook = address(lpSplitHook)`. No pool has been deployed yet (`deployedPoolCount[projectId] == 0`).
+The project's ruleset has a reserved token split configured with `hook = address(lpSplitHook)`. No pool has been deployed yet (`deployedPoolCount[projectId] == 0`). This hook instance supports only one terminal-token deployment per project because the split context does not include the terminal token.
 
 ### Steps
 
@@ -94,14 +94,14 @@ The hook holds project tokens in `accumulatedProjectTokens[projectId]`. The toke
 
 ### Precondition
 
-Tokens have been accumulated (`accumulatedProjectTokens[projectId] > 0`). No pool exists for this project/terminal-token pair.
+Tokens have been accumulated (`accumulatedProjectTokens[projectId] > 0`). No pool exists for this project and no terminal-token path has been committed yet.
 
 ### Steps
 
 1. **Caller invokes `deployPool(projectId, terminalToken, minCashOutReturn)`**
 
    - Permission check: requires `SET_BUYBACK_POOL` from project owner, unless `ruleset.weight * 10 <= initialWeightOf[projectId]`
-   - Checks: `tokenIdOf == 0`, `accumulatedProjectTokens > 0`, `primaryTerminalOf(projectId, terminalToken) != address(0)`
+   - Checks: `tokenIdOf == 0`, `deployedPoolCount == 0`, `accumulatedProjectTokens > 0`, `primaryTerminalOf(projectId, terminalToken) != address(0)`
 
 2. **`_createAndInitializePool()` creates the V4 pool**
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bananapus/univ4-lp-split-hook-v6",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -16,9 +16,9 @@
   },
   "dependencies": {
     "@bananapus/address-registry-v6": "^0.0.10",
-    "@bananapus/core-v6": "^0.0.17",
+    "@bananapus/core-v6": "^0.0.23",
     "@bananapus/permission-ids-v6": "^0.0.10",
-    "@bananapus/univ4-router-v6": "^0.0.8",
+    "@bananapus/univ4-router-v6": "^0.0.9",
     "@openzeppelin/contracts": "^5.6.1",
     "@prb/math": "^4.1.0",
     "@uniswap/permit2": "github:Uniswap/permit2",

package/src/JBUniswapV4LPSplitHook.sol

@@ -21,7 +21,6 @@ import {IJBDirectory} from "@bananapus/core-v6/src/interfaces/IJBDirectory.sol";
 import {IJBMultiTerminal} from "@bananapus/core-v6/src/interfaces/IJBMultiTerminal.sol";
 import {IJBPermissions} from "@bananapus/core-v6/src/interfaces/IJBPermissions.sol";
 import {IJBSplitHook} from "@bananapus/core-v6/src/interfaces/IJBSplitHook.sol";
-import {IJBTerminal} from "@bananapus/core-v6/src/interfaces/IJBTerminal.sol";
 import {IJBTokens} from "@bananapus/core-v6/src/interfaces/IJBTokens.sol";
 import {JBConstants} from "@bananapus/core-v6/src/libraries/JBConstants.sol";
 import {JBRulesetMetadataResolver} from "@bananapus/core-v6/src/libraries/JBRulesetMetadataResolver.sol";
@@ -73,6 +72,7 @@ contract JBUniswapV4LPSplitHook is IJBUniswapV4LPSplitHook, IJBSplitHook, JBPerm
     error JBUniswapV4LPSplitHook_InvalidTerminalToken();
     error JBUniswapV4LPSplitHook_NoTokensAccumulated();
     error JBUniswapV4LPSplitHook_NotHookSpecifiedInContext();
+    error JBUniswapV4LPSplitHook_OnlyOneTerminalTokenSupported();
     error JBUniswapV4LPSplitHook_Permit2AmountOverflow();
     error JBUniswapV4LPSplitHook_PoolAlreadyDeployed();
     error JBUniswapV4LPSplitHook_SplitSenderNotValidControllerOrTerminal();
@@ -158,9 +158,9 @@ contract JBUniswapV4LPSplitHook is IJBUniswapV4LPSplitHook, IJBSplitHook, JBPerm
     mapping(uint256 projectId => uint256 accumulatedProjectTokens) public accumulatedProjectTokens;
 
     /// @notice ProjectID => Number of deployed pools for this project.
-    /// @dev Monotonic counter by design — pools are never removed, only added. Used by
-    ///      processSplitWith to decide accumulate vs burn, since the split context only
-    ///      provides the project token, not the terminal token.
+    /// @dev This is intentionally capped at 1. `processSplitWith` only receives the project token and cannot tell
+    ///      which terminal token a reserved-token distribution is intended for, so one deployment permanently flips
+    ///      the project from accumulation to burn mode.
     mapping(uint256 projectId => uint256 count) public deployedPoolCount;
 
     /// @notice ProjectID => Fee tokens claimable by that project
@@ -272,11 +272,9 @@ contract JBUniswapV4LPSplitHook is IJBUniswapV4LPSplitHook, IJBSplitHook, JBPerm
         try IJBMultiTerminal(
                 address(IJBDirectory(DIRECTORY).primaryTerminalOf({projectId: projectId, token: terminalToken}))
             ).STORE()
-            .currentReclaimableSurplusOf({
+            .currentTotalReclaimableSurplusOf({
                 projectId: projectId,
                 cashOutCount: _WAD,
-                terminals: new IJBTerminal[](0),
-                accountingContexts: new JBAccountingContext[](0),
                 decimals: _getTokenDecimals(terminalToken),
                 // Safe: truncation to uint32 is the standard Juicebox currency encoding.
                 // forge-lint: disable-next-line(unsafe-typecast)
@@ -507,7 +505,6 @@ contract JBUniswapV4LPSplitHook is IJBUniswapV4LPSplitHook, IJBSplitHook, JBPerm
     }
 
     /// @notice Collect LP fees and route them back to the project
-    // slither-disable-next-line reentrancy-events
     // forge-lint: disable-next-line(mixed-case-function)
     function collectAndRouteLPFees(uint256 projectId, address terminalToken) external {
         uint256 tokenId = tokenIdOf[projectId][terminalToken];
@@ -527,6 +524,7 @@ contract JBUniswapV4LPSplitHook is IJBUniswapV4LPSplitHook, IJBSplitHook, JBPerm
         params[0] = abi.encode(tokenId, uint256(0), uint128(0), uint128(0), "");
         params[1] = abi.encode(key.currency0, key.currency1, address(this));
 
+        // slither-disable-next-line reentrancy-events,reentrancy-no-eth
         POSITION_MANAGER.modifyLiquidities({
             unlockData: abi.encode(actions, params), deadline: block.timestamp + _DEADLINE_SECONDS
         });
@@ -536,6 +534,7 @@ contract JBUniswapV4LPSplitHook is IJBUniswapV4LPSplitHook, IJBSplitHook, JBPerm
         uint256 amount1 = _currencyBalance(key.currency1) - bal1Before;
 
         // Route terminal token fees back to the project
+        // slither-disable-next-line reentrancy-events,reentrancy-no-eth
         _routeCollectedFees({
             projectId: projectId,
             projectToken: projectToken,
@@ -545,6 +544,7 @@ contract JBUniswapV4LPSplitHook is IJBUniswapV4LPSplitHook, IJBSplitHook, JBPerm
         });
 
         // Burn collected project token fees
+        // slither-disable-next-line reentrancy-events,reentrancy-no-eth
         _burnReceivedTokens({projectId: projectId, projectToken: projectToken});
     }
 
@@ -566,6 +566,7 @@ contract JBUniswapV4LPSplitHook is IJBUniswapV4LPSplitHook, IJBSplitHook, JBPerm
         }
 
         if (tokenIdOf[projectId][terminalToken] != 0) revert JBUniswapV4LPSplitHook_PoolAlreadyDeployed();
+        if (deployedPoolCount[projectId] != 0) revert JBUniswapV4LPSplitHook_OnlyOneTerminalTokenSupported();
 
         address projectToken = address(IJBTokens(TOKENS).tokenOf(projectId));
         uint256 projectTokenBalance = accumulatedProjectTokens[projectId];
@@ -576,6 +577,10 @@ contract JBUniswapV4LPSplitHook is IJBUniswapV4LPSplitHook, IJBSplitHook, JBPerm
             address(IJBDirectory(DIRECTORY).primaryTerminalOf({projectId: projectId, token: terminalToken}));
         if (terminal == address(0)) revert JBUniswapV4LPSplitHook_InvalidTerminalToken();
 
+        // Flip the project into post-deploy burn mode before any external calls so reentrancy cannot
+        // observe the project as still being in accumulation mode.
+        deployedPoolCount[projectId]++;
+
         _deployPoolAndAddLiquidity({
             projectId: projectId,
             projectToken: projectToken,
@@ -583,8 +588,6 @@ contract JBUniswapV4LPSplitHook is IJBUniswapV4LPSplitHook, IJBSplitHook, JBPerm
             minCashOutReturn: minCashOutReturn
         });
 
-        deployedPoolCount[projectId]++;
-
         emit ProjectDeployed(projectId, terminalToken, PoolId.unwrap(_poolKeys[projectId][terminalToken].toId()));
     }
 
@@ -650,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
+        });
     }
 
     //*********************************************************************//
@@ -896,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 {
@@ -986,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,
@@ -1264,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});

package/test/DeploymentStageTest.t.sol

@@ -139,6 +139,20 @@ contract DeploymentStageTest is LPSplitHookV4TestBase {
         hook.deployPool(PROJECT_ID, address(terminalToken), 0);
     }
 
+    /// @notice Once any pool is deployed for a project, a second terminal-token pool is rejected.
+    function test_DeployPool_RevertsIf_SecondTerminalTokenRequested() public {
+        _accumulateAndDeploy(PROJECT_ID, 100e18);
+
+        address secondTerminalToken = makeAddr("secondTerminalToken");
+        _setDirectoryTerminal(PROJECT_ID, secondTerminalToken, address(terminal));
+
+        _accumulateTokens(PROJECT_ID, 50e18);
+
+        vm.expectRevert(JBUniswapV4LPSplitHook.JBUniswapV4LPSplitHook_OnlyOneTerminalTokenSupported.selector);
+        vm.prank(owner);
+        hook.deployPool(PROJECT_ID, secondTerminalToken, 0);
+    }
+
     // ─────────────────────────────────────────────────────────────────────
     // 9. deployPool — reverts if terminal token is invalid
     // ─────────────────────────────────────────────────────────────────────

package/test/SplitHookRegressions.t.sol

@@ -254,9 +254,8 @@ contract SplitHookRegressionsTest is LPSplitHookV4TestBase {
         );
     }
 
-    /// @notice Demonstrates that multiple terminal tokens can have independent
-    ///         projectDeployed flags per the new mapping structure.
-    function test_M2_multiTerminalToken_independentFlags() public {
+    /// @notice Once any pool is deployed, the hook rejects a second terminal-token pool for the project.
+    function test_M2_multiTerminalToken_secondDeployReverts() public {
         // PROJECT_ID already has a pool for terminalToken
         assertTrue(
             hook.isPoolDeployed(PROJECT_ID, address(terminalToken)), "First terminal token pool should be deployed"
@@ -288,9 +287,9 @@ contract SplitHookRegressionsTest is LPSplitHookV4TestBase {
             hook.isPoolDeployed(PROJECT_ID, address(terminalToken)), "First terminal token should still be deployed"
         );
 
-        // Note: processSplitWith limitation -- it uses deployedPoolCount (per-project) to decide
-        // accumulate vs burn. Once any pool is deployed, all subsequent splits burn tokens.
-        // A future improvement could track per-terminal-token accumulation, but this requires
-        // the split context to include the terminal token, which it currently does not.
+        projectToken.mint(address(hook), 10e18);
+        vm.expectRevert(JBUniswapV4LPSplitHook.JBUniswapV4LPSplitHook_OnlyOneTerminalTokenSupported.selector);
+        vm.prank(owner);
+        hook.deployPool(PROJECT_ID, address(secondTerminalToken), 0);
     }
 }

package/test/mock/MockJBContracts.sol

@@ -542,14 +542,31 @@ contract MockJBTerminalStore {
     }
 
     /// @dev Matches
-    /// IJBTerminalStore.currentReclaimableSurplusOf(uint256,uint256,IJBTerminal[],JBAccountingContext[],uint256,uint256)
+    /// IJBTerminalStore.currentReclaimableSurplusOf(uint256,uint256,IJBTerminal[],address[],uint256,uint256)
     function currentReclaimableSurplusOf(
         uint256 projectId,
         uint256 cashOutCount,
         IJBTerminal[] calldata,
         /* terminals */
-        JBAccountingContext[] calldata,
-        /* accountingContexts */
+        address[] calldata,
+        /* tokens */
+        uint256,
+        /* decimals */
+        uint256 /* currency */
+    )
+        external
+        view
+        returns (uint256)
+    {
+        uint256 surplus = surplusPerToken[projectId];
+        if (surplus == 0) return 0;
+        return (surplus * cashOutCount) / 1e18;
+    }
+
+    /// @dev Matches IJBTerminalStore.currentTotalReclaimableSurplusOf(uint256,uint256,uint256,uint256)
+    function currentTotalReclaimableSurplusOf(
+        uint256 projectId,
+        uint256 cashOutCount,
         uint256,
         /* decimals */
         uint256 /* currency */