@bananapus/buyback-hook-v6 0.0.9 → 0.0.10

package/STYLE_GUIDE.md

@@ -386,6 +386,8 @@ jobs:
         uses: foundry-rs/foundry-toolchain@v1
       - name: Run tests
         run: forge test --fail-fast --summary --detailed --skip "*/script/**"
+        env:
+          RPC_ETHEREUM_MAINNET: ${{ secrets.RPC_ETHEREUM_MAINNET }}
       - name: Check contract sizes
         run: FOUNDRY_PROFILE=ci_sizes forge build --sizes --skip "*/test/**" --skip "*/script/**" --skip SphinxUtils
 ```
@@ -450,6 +452,15 @@ Run `forge fmt` before committing. The `[fmt]` config in `foundry.toml` enforces
 
 CI checks formatting via `forge fmt --check`.
 
+### CI Secrets
+
+| Secret | Purpose |
+|--------|--------|
+| `NPM_TOKEN` | npm publish access (used by `publish.yml`) |
+| `RPC_ETHEREUM_MAINNET` | Ethereum mainnet RPC URL for fork tests (used by `test.yml`) |
+
+Fork tests require `RPC_ETHEREUM_MAINNET` — they fail if it's missing.
+
 ### Branching
 
 - `main` is the primary branch

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bananapus/buyback-hook-v6",
-  "version": "0.0.9",
+  "version": "0.0.10",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/JBBuybackHook.sol

@@ -29,6 +29,7 @@ import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol
 import {Context} from "@openzeppelin/contracts/utils/Context.sol";
 import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 import {mulDiv} from "@prb/math/src/Common.sol";
+import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
 import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
 import {IUnlockCallback} from "@uniswap/v4-core/src/interfaces/callback/IUnlockCallback.sol";
 import {StateLibrary} from "@uniswap/v4-core/src/libraries/StateLibrary.sol";
@@ -108,8 +109,8 @@ contract JBBuybackHook is JBPermissioned, ERC2771Context, IUnlockCallback, IJBBu
     /// @notice The Uniswap V4 PoolManager singleton.
     IPoolManager public immutable override POOL_MANAGER;
 
-    /// @notice The wETH contract.
-    IWETH9 public immutable override WETH;
+    /// @notice The wrapped native token contract (e.g. WETH on Ethereum, WMATIC on Polygon).
+    IWETH9 public immutable override WRAPPED_NATIVE_TOKEN;
 
     //*********************************************************************//
     // --------------------- public stored properties -------------------- //
@@ -117,7 +118,7 @@ contract JBBuybackHook is JBPermissioned, ERC2771Context, IUnlockCallback, IJBBu
 
     /// @notice The PoolKey for a given project's token and terminal token pair.
     /// @custom:param projectId The ID of the project whose token is traded in the pool.
-    /// @custom:param terminalToken The address of the terminal token (normalized to WETH for native).
+    /// @custom:param terminalToken The address of the terminal token (normalized to wrapped native token for native).
     mapping(uint256 projectId => mapping(address terminalToken => PoolKey)) internal _poolKeyOf;
 
     /// @notice The address of each project's token.
@@ -157,7 +158,7 @@ contract JBBuybackHook is JBPermissioned, ERC2771Context, IUnlockCallback, IJBBu
     /// @param prices The contract that exposes price feeds.
     /// @param projects The project registry.
     /// @param tokens The token registry.
-    /// @param weth The WETH contract.
+    /// @param wrappedNativeToken The wrapped native token contract (e.g. WETH on Ethereum).
     /// @param poolManager The Uniswap V4 PoolManager singleton.
     /// @param trustedForwarder A trusted forwarder of transactions to this contract.
     constructor(
@@ -166,7 +167,7 @@ contract JBBuybackHook is JBPermissioned, ERC2771Context, IUnlockCallback, IJBBu
         IJBPrices prices,
         IJBProjects projects,
         IJBTokens tokens,
-        IWETH9 weth,
+        IWETH9 wrappedNativeToken,
         IPoolManager poolManager,
         address trustedForwarder
     )
@@ -178,7 +179,7 @@ contract JBBuybackHook is JBPermissioned, ERC2771Context, IUnlockCallback, IJBBu
         PROJECTS = projects;
         PRICES = prices;
         POOL_MANAGER = poolManager;
-        WETH = weth;
+        WRAPPED_NATIVE_TOKEN = wrappedNativeToken;
     }
 
     //*********************************************************************//
@@ -231,11 +232,11 @@ contract JBBuybackHook is JBPermissioned, ERC2771Context, IUnlockCallback, IJBBu
             revert JBBuybackHook_SpecifiedSlippageExceeded(exactSwapAmountOut, minimumSwapAmountOut);
         }
 
-        // If native ETH was wrapped to WETH for the swap (pool uses WETH), unwrap any leftover WETH
-        // back to ETH so the balance delta below correctly captures leftovers.
+        // If native tokens were wrapped for the swap, unwrap any leftover wrapped tokens
+        // back to native so the balance delta below correctly captures leftovers.
         if (context.forwardedAmount.token == JBConstants.NATIVE_TOKEN) {
-            uint256 wethBalance = IERC20(address(WETH)).balanceOf(address(this));
-            if (wethBalance != 0) WETH.withdraw(wethBalance);
+            uint256 wrappedBalance = IERC20(address(WRAPPED_NATIVE_TOKEN)).balanceOf(address(this));
+            if (wrappedBalance != 0) WRAPPED_NATIVE_TOKEN.withdraw(wrappedBalance);
         }
 
         // Compute leftover terminal tokens as a delta (balanceAfter - balanceBefore).
@@ -323,63 +324,57 @@ contract JBBuybackHook is JBPermissioned, ERC2771Context, IUnlockCallback, IJBBu
             account: PROJECTS.ownerOf(projectId), projectId: projectId, permissionId: JBPermissionIds.SET_BUYBACK_POOL
         });
 
-        // Normalize the terminal token — use WETH for native.
-        address normalizedTerminalToken = terminalToken == JBConstants.NATIVE_TOKEN ? address(WETH) : terminalToken;
-
-        // Make sure this pool hasn't already been set for this project/token pair.
-        if (_poolIsSet[projectId][normalizedTerminalToken]) {
-            revert JBBuybackHook_PoolAlreadySet(_poolKeyOf[projectId][normalizedTerminalToken].toId());
-        }
-
-        // Make sure the provided TWAP window is within reasonable bounds.
-        if (twapWindow < MIN_TWAP_WINDOW || twapWindow > MAX_TWAP_WINDOW) {
-            revert JBBuybackHook_InvalidTwapWindow(twapWindow, MIN_TWAP_WINDOW, MAX_TWAP_WINDOW);
-        }
-
-        // Make sure the terminal token is not zero.
-        if (normalizedTerminalToken == address(0)) revert JBBuybackHook_ZeroTerminalToken();
+        // Normalize the terminal token — use wrapped native token for native.
+        address normalizedTerminalToken =
+            terminalToken == JBConstants.NATIVE_TOKEN ? address(WRAPPED_NATIVE_TOKEN) : terminalToken;
 
         // Get the project's token.
         address projectToken = address(TOKENS.tokenOf(projectId));
 
-        // Make sure the project has issued a token.
-        if (projectToken == address(0)) revert JBBuybackHook_ZeroProjectToken();
-
-        // Make sure the terminal token is not the project token.
-        if (normalizedTerminalToken == projectToken) {
-            revert JBBuybackHook_TerminalTokenIsProjectToken(normalizedTerminalToken, projectToken);
-        }
-
-        // Validate the pool is initialized in the PoolManager.
-        PoolId poolId = poolKey.toId();
-        // slither-disable-next-line unused-return
-        (uint160 sqrtPriceX96,,,) = POOL_MANAGER.getSlot0(poolId);
-        if (sqrtPriceX96 == 0) revert JBBuybackHook_PoolNotInitialized(poolId);
+        _setPoolFor(projectId, poolKey, twapWindow, normalizedTerminalToken, projectToken);
+    }
 
-        // Validate the PoolKey currencies match the project token and terminal token.
-        address currency0 = Currency.unwrap(poolKey.currency0);
-        address currency1 = Currency.unwrap(poolKey.currency1);
-        bool validPair = (currency0 == projectToken && currency1 == normalizedTerminalToken)
-            || (currency0 == normalizedTerminalToken && currency1 == projectToken);
-        require(validPair, "JBBuybackHook: pool key currencies mismatch");
+    /// @notice Set the V4 pool to use for a given project and terminal token pair, constructing the PoolKey internally.
+    /// @dev Uses address(0) for the hooks field. The hook sorts the project token and terminal token into the correct
+    /// currency order. Pool keys are intentionally immutable once set.
+    /// @param projectId The ID of the project to set the pool for.
+    /// @param fee The Uniswap V4 pool fee tier.
+    /// @param tickSpacing The Uniswap V4 pool tick spacing.
+    /// @param twapWindow The period of time over which the TWAP is computed.
+    /// @param terminalToken The address of the terminal token that payments to the project are made in.
+    function setPoolFor(
+        uint256 projectId,
+        uint24 fee,
+        int24 tickSpacing,
+        uint256 twapWindow,
+        address terminalToken
+    )
+        external
+        override
+    {
+        // Enforce permissions.
+        _requirePermissionFrom({
+            account: PROJECTS.ownerOf(projectId), projectId: projectId, permissionId: JBPermissionIds.SET_BUYBACK_POOL
+        });
 
-        // Store the pool key and mark it as set.
-        _poolKeyOf[projectId][normalizedTerminalToken] = poolKey;
-        _poolIsSet[projectId][normalizedTerminalToken] = true;
+        // Normalize the terminal token — use wrapped native token for native.
+        address normalizedTerminalToken =
+            terminalToken == JBConstants.NATIVE_TOKEN ? address(WRAPPED_NATIVE_TOKEN) : terminalToken;
 
-        // Read the current TWAP window before overwriting (for accurate event emission).
-        uint256 oldWindow = twapWindowOf[projectId];
+        // Get the project's token.
+        address projectToken = address(TOKENS.tokenOf(projectId));
 
-        // Store the TWAP window and project token.
-        twapWindowOf[projectId] = twapWindow;
-        projectTokenOf[projectId] = projectToken;
+        // Sort currencies numerically (lower address = currency0).
+        (Currency currency0, Currency currency1) = normalizedTerminalToken < projectToken
+            ? (Currency.wrap(normalizedTerminalToken), Currency.wrap(projectToken))
+            : (Currency.wrap(projectToken), Currency.wrap(normalizedTerminalToken));
 
-        emit TwapWindowChanged({
-            projectId: projectId, oldWindow: oldWindow, newWindow: twapWindow, caller: _msgSender()
-        });
-        emit PoolAdded({
-            projectId: projectId, terminalToken: normalizedTerminalToken, poolId: poolId, caller: _msgSender()
+        // Construct the pool key with no hooks.
+        PoolKey memory poolKey = PoolKey({
+            currency0: currency0, currency1: currency1, fee: fee, tickSpacing: tickSpacing, hooks: IHooks(address(0))
         });
+
+        _setPoolFor(projectId, poolKey, twapWindow, normalizedTerminalToken, projectToken);
     }
 
     /// @notice Change the TWAP window for a project.
@@ -476,7 +471,7 @@ contract JBBuybackHook is JBPermissioned, ERC2771Context, IUnlockCallback, IJBBu
         return abi.encode(outputAmount);
     }
 
-    /// @notice Receive native ETH. Required for V4 native ETH take() and WETH unwrap.
+    /// @notice Receive native tokens. Required for V4 native take() and wrapped token unwrap.
     receive() external payable {}
 
     //*********************************************************************//
@@ -560,7 +555,8 @@ contract JBBuybackHook is JBPermissioned, ERC2771Context, IUnlockCallback, IJBBu
         address projectToken = projectTokenOf[context.projectId];
 
         // Keep a reference to the token being used by the terminal. Default to wETH if the terminal uses native.
-        address terminalToken = context.amount.token == JBConstants.NATIVE_TOKEN ? address(WETH) : context.amount.token;
+        address terminalToken =
+            context.amount.token == JBConstants.NATIVE_TOKEN ? address(WRAPPED_NATIVE_TOKEN) : context.amount.token;
 
         // Always compute the TWAP-based minimum.
         uint256 twapMinimum = _getQuote({
@@ -607,7 +603,7 @@ contract JBBuybackHook is JBPermissioned, ERC2771Context, IUnlockCallback, IJBBu
 
     /// @notice Returns the PoolKey for a given project and terminal token pair.
     /// @param projectId The ID of the project.
-    /// @param terminalToken The terminal token address (normalized to WETH for native).
+    /// @param terminalToken The terminal token address (normalized to wrapped native token for native).
     /// @return key The V4 PoolKey.
     function poolKeyOf(uint256 projectId, address terminalToken) public view override returns (PoolKey memory key) {
         return _poolKeyOf[projectId][terminalToken];
@@ -623,6 +619,75 @@ contract JBBuybackHook is JBPermissioned, ERC2771Context, IUnlockCallback, IJBBu
     // ---------------------- internal transactions ---------------------- //
     //*********************************************************************//
 
+    /// @notice Shared internal logic for setting a pool. Both `setPoolFor` overloads delegate here after permission
+    /// checks and token normalization.
+    /// @param projectId The ID of the project.
+    /// @param poolKey The V4 PoolKey identifying the pool.
+    /// @param twapWindow The period of time over which the TWAP is computed.
+    /// @param normalizedTerminalToken The terminal token address (already normalized: wrapped native token for native).
+    /// @param projectToken The project's ERC-20 token address.
+    function _setPoolFor(
+        uint256 projectId,
+        PoolKey memory poolKey,
+        uint256 twapWindow,
+        address normalizedTerminalToken,
+        address projectToken
+    )
+        internal
+    {
+        // Make sure this pool hasn't already been set for this project/token pair.
+        if (_poolIsSet[projectId][normalizedTerminalToken]) {
+            revert JBBuybackHook_PoolAlreadySet(_poolKeyOf[projectId][normalizedTerminalToken].toId());
+        }
+
+        // Make sure the provided TWAP window is within reasonable bounds.
+        if (twapWindow < MIN_TWAP_WINDOW || twapWindow > MAX_TWAP_WINDOW) {
+            revert JBBuybackHook_InvalidTwapWindow(twapWindow, MIN_TWAP_WINDOW, MAX_TWAP_WINDOW);
+        }
+
+        // Make sure the terminal token is not zero.
+        if (normalizedTerminalToken == address(0)) revert JBBuybackHook_ZeroTerminalToken();
+
+        // Make sure the project has issued a token.
+        if (projectToken == address(0)) revert JBBuybackHook_ZeroProjectToken();
+
+        // Make sure the terminal token is not the project token.
+        if (normalizedTerminalToken == projectToken) {
+            revert JBBuybackHook_TerminalTokenIsProjectToken(normalizedTerminalToken, projectToken);
+        }
+
+        // Validate the pool is initialized in the PoolManager.
+        PoolId poolId = poolKey.toId();
+        // slither-disable-next-line unused-return
+        (uint160 sqrtPriceX96,,,) = POOL_MANAGER.getSlot0(poolId);
+        if (sqrtPriceX96 == 0) revert JBBuybackHook_PoolNotInitialized(poolId);
+
+        // Validate the PoolKey currencies match the project token and terminal token.
+        address currency0 = Currency.unwrap(poolKey.currency0);
+        address currency1 = Currency.unwrap(poolKey.currency1);
+        bool validPair = (currency0 == projectToken && currency1 == normalizedTerminalToken)
+            || (currency0 == normalizedTerminalToken && currency1 == projectToken);
+        require(validPair, "JBBuybackHook: pool key currencies mismatch");
+
+        // Store the pool key and mark it as set.
+        _poolKeyOf[projectId][normalizedTerminalToken] = poolKey;
+        _poolIsSet[projectId][normalizedTerminalToken] = true;
+
+        // Read the current TWAP window before overwriting (for accurate event emission).
+        uint256 oldWindow = twapWindowOf[projectId];
+
+        // Store the TWAP window and project token.
+        twapWindowOf[projectId] = twapWindow;
+        projectTokenOf[projectId] = projectToken;
+
+        emit TwapWindowChanged({
+            projectId: projectId, oldWindow: oldWindow, newWindow: twapWindow, caller: _msgSender()
+        });
+        emit PoolAdded({
+            projectId: projectId, terminalToken: normalizedTerminalToken, poolId: poolId, caller: _msgSender()
+        });
+    }
+
     /// @notice Swap the terminal token to receive project tokens via V4.
     /// @param context The `afterPayRecordedContext` passed in by the terminal.
     /// @param projectTokenIs0 Whether the project token is currency0 in the pool.
@@ -641,21 +706,22 @@ contract JBBuybackHook is JBPermissioned, ERC2771Context, IUnlockCallback, IJBBu
     {
         uint256 amountToSwapWith = context.forwardedAmount.value;
 
-        // Get the terminal token, normalized to WETH.
-        address terminalTokenWithWETH =
-            context.forwardedAmount.token == JBConstants.NATIVE_TOKEN ? address(WETH) : context.forwardedAmount.token;
+        // Get the terminal token, normalized to the wrapped native token.
+        address terminalTokenWithWETH = context.forwardedAmount.token == JBConstants.NATIVE_TOKEN
+            ? address(WRAPPED_NATIVE_TOKEN)
+            : context.forwardedAmount.token;
 
         // Get the pool key for this project/token pair.
         PoolKey memory key = _poolKeyOf[context.projectId][terminalTokenWithWETH];
 
-        // Wrap native tokens to WETH if needed (for ERC-20 settle path).
+        // Wrap native tokens if needed (for ERC-20 settle path).
         // For native ETH pools (currency0 or currency1 is address(0)), we use settle{value:} instead.
         bool inputIsNative = context.forwardedAmount.token == JBConstants.NATIVE_TOKEN;
         Currency inputCurrency = projectTokenIs0 ? key.currency1 : key.currency0;
 
         if (inputIsNative && !inputCurrency.isAddressZero()) {
-            // Pool uses WETH, but we received ETH — wrap it.
-            WETH.deposit{value: amountToSwapWith}();
+            // Pool uses the wrapped native token, but we received native — wrap it.
+            WRAPPED_NATIVE_TOKEN.deposit{value: amountToSwapWith}();
         }
 
         // Encode the callback data.
@@ -706,7 +772,7 @@ contract JBBuybackHook is JBPermissioned, ERC2771Context, IUnlockCallback, IJBBu
     /// @param projectId The ID of the project.
     /// @param projectToken The project token being swapped for.
     /// @param amountIn The number of terminal tokens being used to swap.
-    /// @param terminalToken The terminal token being paid in (normalized to WETH for native).
+    /// @param terminalToken The terminal token being paid in (normalized to wrapped native token for native).
     /// @return amountOut The minimum number of tokens to receive based on the TWAP and slippage.
     function _getQuote(
         uint256 projectId,

package/src/JBBuybackHookRegistry.sol

@@ -16,6 +16,7 @@ import {ERC2771Context} from "@openzeppelin/contracts/metatx/ERC2771Context.sol"
 import {Context} from "@openzeppelin/contracts/utils/Context.sol";
 import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 
+import {IJBBuybackHook} from "./interfaces/IJBBuybackHook.sol";
 import {IJBBuybackHookRegistry} from "./interfaces/IJBBuybackHookRegistry.sol";
 
 contract JBBuybackHookRegistry is IJBBuybackHookRegistry, ERC2771Context, JBPermissioned, Ownable {
@@ -177,6 +178,42 @@ contract JBBuybackHookRegistry is IJBBuybackHookRegistry, ERC2771Context, JBPerm
         emit JBBuybackHookRegistry_SetHook(projectId, hook);
     }
 
+    /// @notice Set the Uniswap V4 pool for a project by forwarding to the resolved buyback hook implementation.
+    /// @param projectId The ID of the project to set the pool for.
+    /// @param fee The Uniswap V4 pool fee tier.
+    /// @param tickSpacing The Uniswap V4 pool tick spacing.
+    /// @param twapWindow The period of time over which the TWAP is computed.
+    /// @param terminalToken The address of the terminal token that payments to the project are made in.
+    function setPoolFor(
+        uint256 projectId,
+        uint24 fee,
+        int24 tickSpacing,
+        uint256 twapWindow,
+        address terminalToken
+    )
+        external
+        override
+    {
+        // Enforce permissions.
+        _requirePermissionFrom({
+            account: PROJECTS.ownerOf(projectId), projectId: projectId, permissionId: JBPermissionIds.SET_BUYBACK_POOL
+        });
+
+        // Get the hook for the project (falls back to default).
+        IJBRulesetDataHook hook = _hookOf[projectId];
+        if (hook == IJBRulesetDataHook(address(0))) hook = defaultHook;
+
+        // Forward the call to the resolved hook.
+        IJBBuybackHook(address(hook))
+            .setPoolFor({
+                projectId: projectId,
+                fee: fee,
+                tickSpacing: tickSpacing,
+                twapWindow: twapWindow,
+                terminalToken: terminalToken
+            });
+    }
+
     //*********************************************************************//
     // ------------------------- external views -------------------------- //
     //*********************************************************************//

package/src/interfaces/IJBBuybackHook.sol

@@ -81,9 +81,9 @@ interface IJBBuybackHook is IJBPayHook, IJBRulesetDataHook {
     /// @return The slippage denominator.
     function TWAP_SLIPPAGE_DENOMINATOR() external view returns (uint256);
 
-    /// @notice The wETH contract.
-    /// @return The WETH contract.
-    function WETH() external view returns (IWETH9);
+    /// @notice The wrapped native token contract (e.g. WETH on Ethereum, WMATIC on Polygon).
+    /// @return The wrapped native token contract.
+    function WRAPPED_NATIVE_TOKEN() external view returns (IWETH9);
 
     /// @notice The PoolKey for a given project and terminal token pair.
     /// @param projectId The ID of the project.
@@ -114,6 +114,23 @@ interface IJBBuybackHook is IJBPayHook, IJBRulesetDataHook {
     )
         external;
 
+    /// @notice Set the pool to use for a given project and terminal token, constructing the PoolKey internally.
+    /// @dev Uses address(0) for the hooks field. The hook sorts the project token and terminal token into the correct
+    /// currency order.
+    /// @param projectId The ID of the project to set the pool for.
+    /// @param fee The Uniswap V4 pool fee tier.
+    /// @param tickSpacing The Uniswap V4 pool tick spacing.
+    /// @param twapWindow The period of time over which the TWAP is computed.
+    /// @param terminalToken The address of the terminal token that payments to the project are made in.
+    function setPoolFor(
+        uint256 projectId,
+        uint24 fee,
+        int24 tickSpacing,
+        uint256 twapWindow,
+        address terminalToken
+    )
+        external;
+
     /// @notice Change the TWAP window for a project.
     /// @param projectId The ID of the project to set the TWAP window of.
     /// @param newWindow The new TWAP window.

package/src/interfaces/IJBBuybackHookRegistry.sol

@@ -71,4 +71,20 @@ interface IJBBuybackHookRegistry is IJBRulesetDataHook {
     /// @param projectId The ID of the project to set the hook for.
     /// @param hook The hook to set.
     function setHookFor(uint256 projectId, IJBRulesetDataHook hook) external;
+
+    /// @notice Set the Uniswap V4 pool for a project, forwarding to the resolved buyback hook implementation.
+    /// @dev Resolves the hook for the project (or the default), then calls setPoolFor on it.
+    /// @param projectId The ID of the project to set the pool for.
+    /// @param fee The Uniswap V4 pool fee tier.
+    /// @param tickSpacing The Uniswap V4 pool tick spacing.
+    /// @param twapWindow The period of time over which the TWAP is computed.
+    /// @param terminalToken The address of the terminal token that payments to the project are made in.
+    function setPoolFor(
+        uint256 projectId,
+        uint24 fee,
+        int24 tickSpacing,
+        uint256 twapWindow,
+        address terminalToken
+    )
+        external;
 }

package/test/Registry.t.sol

@@ -17,6 +17,7 @@ import "@bananapus/core-v6/src/libraries/JBConstants.sol";
 import "@bananapus/permission-ids-v6/src/JBPermissionIds.sol";
 
 import "src/JBBuybackHookRegistry.sol";
+import {IJBBuybackHook} from "src/interfaces/IJBBuybackHook.sol";
 
 /// @notice Unit tests for `JBBuybackHookRegistry`.
 contract Test_BuybackHookRegistry_Unit is Test {
@@ -479,6 +480,133 @@ contract Test_BuybackHookRegistry_Unit is Test {
         registry.lockHookFor(projectId, hookB);
     }
 
+    //*********************************************************************//
+    // --- setPoolFor ---------------------------------------------------- //
+    //*********************************************************************//
+
+    function test_setPoolFor_forwardsToResolvedHook() public {
+        // Set hookA as default.
+        vm.prank(owner);
+        registry.setDefaultHook(hookA);
+
+        // Build the expected calldata for the simplified setPoolFor overload.
+        bytes memory expectedCalldata = abi.encodeWithSignature(
+            "setPoolFor(uint256,uint24,int24,uint256,address)",
+            projectId,
+            uint24(10_000),
+            int24(60),
+            uint256(2 days),
+            address(0xEEEe)
+        );
+
+        // Mock and expect the call on hookA.
+        vm.mockCall(address(hookA), expectedCalldata, abi.encode());
+        vm.expectCall(address(hookA), expectedCalldata);
+
+        registry.setPoolFor({
+            projectId: projectId, fee: 10_000, tickSpacing: 60, twapWindow: 2 days, terminalToken: address(0xEEEe)
+        });
+    }
+
+    function test_setPoolFor_usesProjectSpecificHook() public {
+        // Allow and set hookB for this project.
+        vm.prank(owner);
+        registry.allowHook(hookB);
+        vm.prank(projectOwner);
+        registry.setHookFor(projectId, hookB);
+
+        // Set a different default (hookA) to prove the project hook is used.
+        vm.prank(owner);
+        registry.setDefaultHook(hookA);
+
+        // Build the expected calldata.
+        bytes memory expectedCalldata = abi.encodeWithSignature(
+            "setPoolFor(uint256,uint24,int24,uint256,address)",
+            projectId,
+            uint24(3000),
+            int24(10),
+            uint256(1 days),
+            address(0xEEEe)
+        );
+
+        // Mock and expect the call goes to hookB, NOT hookA.
+        vm.mockCall(address(hookB), expectedCalldata, abi.encode());
+        vm.expectCall(address(hookB), expectedCalldata);
+
+        registry.setPoolFor({
+            projectId: projectId, fee: 3000, tickSpacing: 10, twapWindow: 1 days, terminalToken: address(0xEEEe)
+        });
+    }
+
+    function test_setPoolFor_revertsIfUnauthorized() public {
+        // Set hookA as default.
+        vm.prank(owner);
+        registry.setDefaultHook(hookA);
+
+        // Mock permissions to return false — caller has no SET_BUYBACK_POOL permission.
+        vm.mockCall(
+            address(permissions), abi.encodeWithSelector(IJBPermissions.hasPermission.selector), abi.encode(false)
+        );
+
+        vm.prank(dude);
+        vm.expectRevert();
+        registry.setPoolFor({
+            projectId: projectId, fee: 10_000, tickSpacing: 60, twapWindow: 2 days, terminalToken: address(0xEEEe)
+        });
+    }
+
+    function test_setPoolFor_succeedsForProjectOwner() public {
+        // Set hookA as default.
+        vm.prank(owner);
+        registry.setDefaultHook(hookA);
+
+        // Build expected calldata.
+        bytes memory expectedCalldata = abi.encodeWithSignature(
+            "setPoolFor(uint256,uint24,int24,uint256,address)",
+            projectId,
+            uint24(10_000),
+            int24(60),
+            uint256(2 days),
+            address(0xEEEe)
+        );
+
+        // Mock the forwarded call on hookA.
+        vm.mockCall(address(hookA), expectedCalldata, abi.encode());
+        vm.expectCall(address(hookA), expectedCalldata);
+
+        // Project owner should be able to call setPoolFor.
+        vm.prank(projectOwner);
+        registry.setPoolFor({
+            projectId: projectId, fee: 10_000, tickSpacing: 60, twapWindow: 2 days, terminalToken: address(0xEEEe)
+        });
+    }
+
+    function test_setPoolFor_succeedsForPermissionedOperator() public {
+        // Set hookA as default.
+        vm.prank(owner);
+        registry.setDefaultHook(hookA);
+
+        // Build expected calldata.
+        bytes memory expectedCalldata = abi.encodeWithSignature(
+            "setPoolFor(uint256,uint24,int24,uint256,address)",
+            projectId,
+            uint24(10_000),
+            int24(60),
+            uint256(2 days),
+            address(0xEEEe)
+        );
+
+        // Mock the forwarded call on hookA.
+        vm.mockCall(address(hookA), expectedCalldata, abi.encode());
+        vm.expectCall(address(hookA), expectedCalldata);
+
+        // Dude (not project owner) has permission via mock — should succeed.
+        vm.prank(dude);
+        registry.setPoolFor({
+            projectId: projectId, fee: 10_000, tickSpacing: 60, twapWindow: 2 days, terminalToken: address(0xEEEe)
+        });
+    }
+
     //*********************************************************************//
     // --- Helpers ------------------------------------------------------- //
     //*********************************************************************//

package/test/V4BuybackHook.t.sol

@@ -82,11 +82,13 @@ contract ForTest_V4BuybackHook is JBBuybackHook {
         IJBPrices prices,
         IJBProjects projects,
         IJBTokens tokens,
-        IWETH9 weth,
+        IWETH9 wrappedNativeToken,
         IPoolManager poolManager,
         address trustedForwarder
     )
-        JBBuybackHook(directory, permissions, prices, projects, tokens, weth, poolManager, trustedForwarder)
+        JBBuybackHook(
+            directory, permissions, prices, projects, tokens, wrappedNativeToken, poolManager, trustedForwarder
+        )
     {}
 
     /// @notice Directly initialize pool state for testing without going through setPoolFor permission checks.
@@ -179,7 +181,7 @@ contract V4BuybackHookTest is Test {
             prices: prices,
             projects: projects,
             tokens: tokens,
-            weth: IWETH9(address(mockWeth)),
+            wrappedNativeToken: IWETH9(address(mockWeth)),
             poolManager: IPoolManager(address(mockPM)),
             trustedForwarder: address(0)
         });

package/test/fork/V4ForkTest.t.sol

@@ -152,11 +152,13 @@ contract ForTest_ForkBuybackHook is JBBuybackHook {
         IJBPrices prices,
         IJBProjects projects,
         IJBTokens tokens,
-        IWETH9 weth,
+        IWETH9 wrappedNativeToken,
         IPoolManager poolManager,
         address trustedForwarder
     )
-        JBBuybackHook(directory, permissions, prices, projects, tokens, weth, poolManager, trustedForwarder)
+        JBBuybackHook(
+            directory, permissions, prices, projects, tokens, wrappedNativeToken, poolManager, trustedForwarder
+        )
     {}
 }
 
@@ -253,7 +255,7 @@ contract V4ForkTest is Test {
             prices: prices,
             projects: projects,
             tokens: tokens,
-            weth: weth,
+            wrappedNativeToken: weth,
             poolManager: poolManager,
             trustedForwarder: address(0)
         });

package/test/fork/V4SandwichForkTest.t.sol

@@ -227,11 +227,13 @@ contract ForTest_SandwichBuybackHook is JBBuybackHook {
         IJBPrices prices,
         IJBProjects projects,
         IJBTokens tokens,
-        IWETH9 weth,
+        IWETH9 wrappedNativeToken,
         IPoolManager poolManager,
         address trustedForwarder
     )
-        JBBuybackHook(directory, permissions, prices, projects, tokens, weth, poolManager, trustedForwarder)
+        JBBuybackHook(
+            directory, permissions, prices, projects, tokens, wrappedNativeToken, poolManager, trustedForwarder
+        )
     {}
 }
 
@@ -321,7 +323,7 @@ contract V4SandwichForkTest is Test {
             prices: prices,
             projects: projects,
             tokens: tokens,
-            weth: weth,
+            wrappedNativeToken: weth,
             poolManager: poolManager,
             trustedForwarder: address(0)
         });

package/test/regression/L44_BalanceDeltaLeftover.t.sol

@@ -85,11 +85,13 @@ contract L44_ForTest_BuybackHook is JBBuybackHook {
         IJBPrices prices,
         IJBProjects projects,
         IJBTokens tokens,
-        IWETH9 weth,
+        IWETH9 wrappedNativeToken,
         IPoolManager poolManager,
         address trustedForwarder
     )
-        JBBuybackHook(directory, permissions, prices, projects, tokens, weth, poolManager, trustedForwarder)
+        JBBuybackHook(
+            directory, permissions, prices, projects, tokens, wrappedNativeToken, poolManager, trustedForwarder
+        )
     {}
 
     function ForTest_initPool(
@@ -158,7 +160,7 @@ contract L44_BalanceDeltaLeftover is Test {
             prices: prices,
             projects: projects,
             tokens: tokens,
-            weth: IWETH9(address(mockWeth)),
+            wrappedNativeToken: IWETH9(address(mockWeth)),
             poolManager: IPoolManager(address(mockPM)),
             trustedForwarder: address(0)
         });

package/test/regression/L45_OldWindowEvent.t.sol

@@ -72,7 +72,7 @@ contract L45_OldWindowEvent is Test {
             prices: prices,
             projects: projects,
             tokens: tokens,
-            weth: IWETH9(address(wethToken)),
+            wrappedNativeToken: IWETH9(address(wethToken)),
             poolManager: IPoolManager(address(mockPM)),
             trustedForwarder: address(0)
         });

package/test/regression/M34_SwapFailureMintFallback.t.sol

@@ -76,11 +76,13 @@ contract M34_ForTest_BuybackHook is JBBuybackHook {
         IJBPrices prices,
         IJBProjects projects,
         IJBTokens tokens,
-        IWETH9 weth,
+        IWETH9 wrappedNativeToken,
         IPoolManager poolManager,
         address trustedForwarder
     )
-        JBBuybackHook(directory, permissions, prices, projects, tokens, weth, poolManager, trustedForwarder)
+        JBBuybackHook(
+            directory, permissions, prices, projects, tokens, wrappedNativeToken, poolManager, trustedForwarder
+        )
     {}
 
     function ForTest_initPool(
@@ -147,7 +149,7 @@ contract M34_SwapFailureMintFallback is Test {
             prices: prices,
             projects: projects,
             tokens: tokens,
-            weth: IWETH9(address(mockWeth)),
+            wrappedNativeToken: IWETH9(address(mockWeth)),
             poolManager: IPoolManager(address(mockPM)),
             trustedForwarder: address(0)
         });