@rev-net/core-v6 0.0.9 → 0.0.10

package/test/TestSplitWeightFork.t.sol

@@ -41,7 +41,6 @@ import {REVCroptopAllowedPost} from "../src/structs/REVCroptopAllowedPost.sol";
 import {JBBuybackHook} from "@bananapus/buyback-hook-v6/src/JBBuybackHook.sol";
 import {JBBuybackHookRegistry} from "@bananapus/buyback-hook-v6/src/JBBuybackHookRegistry.sol";
 import {IJBBuybackHook} from "@bananapus/buyback-hook-v6/src/interfaces/IJBBuybackHook.sol";
-import {IWETH9} from "@bananapus/buyback-hook-v6/src/interfaces/external/IWETH9.sol";
 import {IGeomeanOracle} from "@bananapus/buyback-hook-v6/src/interfaces/IGeomeanOracle.sol";
 
 // Uniswap V4
@@ -52,16 +51,21 @@ import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
 import {PoolId, PoolIdLibrary} from "@uniswap/v4-core/src/types/PoolId.sol";
 import {Currency, CurrencyLibrary} from "@uniswap/v4-core/src/types/Currency.sol";
 import {BalanceDelta} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
-import {ModifyLiquidityParams} from "@uniswap/v4-core/src/types/PoolOperation.sol";
+import {ModifyLiquidityParams, SwapParams} from "@uniswap/v4-core/src/types/PoolOperation.sol";
 import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";
 import {StateLibrary} from "@uniswap/v4-core/src/libraries/StateLibrary.sol";
 
 import {IERC20} from "@openzeppelin/contracts/interfaces/IERC20.sol";
 
-/// @notice Helper that adds liquidity to a V4 pool via the unlock/callback pattern.
+/// @notice Helper that adds liquidity to and swaps on a V4 pool via the unlock/callback pattern.
 contract LiquidityHelper is IUnlockCallback {
     IPoolManager public immutable poolManager;
 
+    enum Action {
+        ADD_LIQUIDITY,
+        SWAP
+    }
+
     struct AddLiqParams {
         PoolKey key;
         int24 tickLower;
@@ -69,6 +73,13 @@ contract LiquidityHelper is IUnlockCallback {
         int256 liquidityDelta;
     }
 
+    struct DoSwapParams {
+        PoolKey key;
+        bool zeroForOne;
+        int256 amountSpecified;
+        uint160 sqrtPriceLimitX96;
+    }
+
     constructor(IPoolManager _poolManager) {
         poolManager = _poolManager;
     }
@@ -82,13 +93,38 @@ contract LiquidityHelper is IUnlockCallback {
         external
         payable
     {
-        bytes memory data = abi.encode(AddLiqParams(key, tickLower, tickUpper, liquidityDelta));
+        bytes memory data =
+            abi.encode(Action.ADD_LIQUIDITY, abi.encode(AddLiqParams(key, tickLower, tickUpper, liquidityDelta)));
+        poolManager.unlock(data);
+    }
+
+    function swap(
+        PoolKey calldata key,
+        bool zeroForOne,
+        int256 amountSpecified,
+        uint160 sqrtPriceLimitX96
+    )
+        external
+        payable
+    {
+        bytes memory data =
+            abi.encode(Action.SWAP, abi.encode(DoSwapParams(key, zeroForOne, amountSpecified, sqrtPriceLimitX96)));
         poolManager.unlock(data);
     }
 
     function unlockCallback(bytes calldata data) external override returns (bytes memory) {
         require(msg.sender == address(poolManager), "only PM");
 
+        (Action action, bytes memory inner) = abi.decode(data, (Action, bytes));
+
+        if (action == Action.ADD_LIQUIDITY) {
+            return _handleAddLiquidity(inner);
+        } else {
+            return _handleSwap(inner);
+        }
+    }
+
+    function _handleAddLiquidity(bytes memory data) internal returns (bytes memory) {
         AddLiqParams memory params = abi.decode(data, (AddLiqParams));
 
         (BalanceDelta callerDelta,) = poolManager.modifyLiquidity(
@@ -110,6 +146,28 @@ contract LiquidityHelper is IUnlockCallback {
         return abi.encode(callerDelta);
     }
 
+    function _handleSwap(bytes memory data) internal returns (bytes memory) {
+        DoSwapParams memory params = abi.decode(data, (DoSwapParams));
+
+        BalanceDelta delta = poolManager.swap(
+            params.key, SwapParams(params.zeroForOne, params.amountSpecified, params.sqrtPriceLimitX96), ""
+        );
+
+        // Settle (pay) what we owe, take what we're owed.
+        if (delta.amount0() < 0) {
+            _settleIfNegative(params.key.currency0, delta.amount0());
+        } else {
+            _takeIfPositive(params.key.currency0, delta.amount0());
+        }
+        if (delta.amount1() < 0) {
+            _settleIfNegative(params.key.currency1, delta.amount1());
+        } else {
+            _takeIfPositive(params.key.currency1, delta.amount1());
+        }
+
+        return abi.encode(delta);
+    }
+
     function _settleIfNegative(Currency currency, int128 delta) internal {
         if (delta >= 0) return;
         uint256 amount = uint256(uint128(-delta));
@@ -148,11 +206,10 @@ contract TestSplitWeightFork is TestBaseWorkflow {
     // ─────────────────────────
 
     address constant POOL_MANAGER_ADDR = 0x000000000004444c5dc75cB358380D2e3dE08A90;
-    address constant WETH_ADDR = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
 
-    /// @notice Full-range tick bounds for tickSpacing = 60.
-    int24 constant TICK_LOWER = -887_220;
-    int24 constant TICK_UPPER = 887_220;
+    /// @notice Full-range tick bounds for tickSpacing = 200.
+    int24 constant TICK_LOWER = -887_200;
+    int24 constant TICK_UPPER = 887_200;
 
     // ───────────────────────── State
     // ─────────────────────────
@@ -168,7 +225,6 @@ contract TestSplitWeightFork is TestBaseWorkflow {
     IJBSuckerRegistry SUCKER_REGISTRY;
     CTPublisher PUBLISHER;
     IPoolManager poolManager;
-    IWETH9 weth;
     LiquidityHelper liqHelper;
 
     uint256 FEE_PROJECT_ID;
@@ -186,13 +242,8 @@ contract TestSplitWeightFork is TestBaseWorkflow {
     // ─────────────────────────
 
     function setUp() public override {
-        // Fork mainnet first — we need the real V4 PoolManager.
-        string memory rpcUrl = vm.envOr("RPC_ETHEREUM_MAINNET", string(""));
-        if (bytes(rpcUrl).length == 0) {
-            vm.skip(true);
-            return;
-        }
-        vm.createSelectFork(rpcUrl);
+        // Fork mainnet at a stable block — deterministic and post-V4 deployment.
+        vm.createSelectFork("ethereum", 21_700_000);
 
         // Verify V4 PoolManager is deployed.
         require(POOL_MANAGER_ADDR.code.length > 0, "PoolManager not deployed at expected address");
@@ -201,7 +252,6 @@ contract TestSplitWeightFork is TestBaseWorkflow {
         super.setUp();
 
         poolManager = IPoolManager(POOL_MANAGER_ADDR);
-        weth = IWETH9(WETH_ADDR);
         liqHelper = new LiquidityHelper(poolManager);
 
         FEE_PROJECT_ID = jbProjects().createFor(multisig());
@@ -221,8 +271,8 @@ contract TestSplitWeightFork is TestBaseWorkflow {
             jbPrices(),
             jbProjects(),
             jbTokens(),
-            weth,
             poolManager,
+            IHooks(address(0)), // oracleHook
             address(0) // trustedForwarder
         );
 
@@ -262,12 +312,6 @@ contract TestSplitWeightFork is TestBaseWorkflow {
         vm.deal(PAYER, 100 ether);
     }
 
-    modifier onlyFork() {
-        string memory rpcUrl = vm.envOr("RPC_ETHEREUM_MAINNET", string(""));
-        if (bytes(rpcUrl).length == 0) return;
-        _;
-    }
-
     // ───────────────────────── Helpers
     // ─────────────────────────
 
@@ -401,68 +445,44 @@ contract TestSplitWeightFork is TestBaseWorkflow {
         });
     }
 
-    /// @notice Set up a V4 pool for the revnet's project token / WETH pair and register it with the buyback hook.
+    /// @notice Set up a V4 pool for the revnet's project token / native ETH pair and register it with the buyback hook.
     function _setupPool(uint256 revnetId, uint256 liquidityTokenAmount) internal returns (PoolKey memory key) {
         // Get the project token.
         address projectToken = address(jbTokens().tokenOf(revnetId));
         require(projectToken != address(0), "project token not deployed");
 
-        // Build sorted pool key.
-        address token0;
-        address token1;
-        if (projectToken < WETH_ADDR) {
-            token0 = projectToken;
-            token1 = WETH_ADDR;
-        } else {
-            token0 = WETH_ADDR;
-            token1 = projectToken;
-        }
-
+        // Native ETH is represented as address(0) in V4 pool keys.
+        // address(0) is always less than any deployed token address.
         key = PoolKey({
-            currency0: Currency.wrap(token0),
-            currency1: Currency.wrap(token1),
+            currency0: Currency.wrap(address(0)),
+            currency1: Currency.wrap(projectToken),
             fee: REV_DEPLOYER.DEFAULT_BUYBACK_POOL_FEE(),
             tickSpacing: REV_DEPLOYER.DEFAULT_BUYBACK_TICK_SPACING(),
             hooks: IHooks(address(0))
         });
 
-        // Initialize pool at price = 1.0 (tick 0).
-        uint160 sqrtPrice = TickMath.getSqrtPriceAtTick(0);
-        poolManager.initialize(key, sqrtPrice);
+        // Pool is already initialized at 1:1 price by REVDeployer during deployment.
+        // Just add liquidity and mock the oracle.
 
         // Fund LiquidityHelper with project tokens via JBTokens.mintFor (not deal).
         // deal() skips ERC20Votes checkpoints, causing underflow when tokens are burned.
         vm.prank(address(jbController()));
         jbTokens().mintFor(address(liqHelper), revnetId, liquidityTokenAmount);
+        // Fund with ETH for the native currency side.
         vm.deal(address(liqHelper), liquidityTokenAmount);
-        vm.prank(address(liqHelper));
-        IWETH9(WETH_ADDR).deposit{value: liquidityTokenAmount}();
 
-        // Approve PoolManager to spend tokens from LiquidityHelper.
+        // Approve PoolManager to spend project tokens from LiquidityHelper.
         vm.startPrank(address(liqHelper));
         IERC20(projectToken).approve(address(poolManager), type(uint256).max);
-        IERC20(WETH_ADDR).approve(address(poolManager), type(uint256).max);
         vm.stopPrank();
 
         // Add full-range liquidity.
         int256 liquidityDelta = int256(liquidityTokenAmount / 2);
         vm.prank(address(liqHelper));
-        liqHelper.addLiquidity(key, TICK_LOWER, TICK_UPPER, liquidityDelta);
+        liqHelper.addLiquidity{value: liquidityTokenAmount}(key, TICK_LOWER, TICK_UPPER, liquidityDelta);
 
         // Mock the oracle at address(0) for hookless pools.
-        // The buyback hook calls IGeomeanOracle(address(key.hooks)).observe() for TWAP.
-        // Since hooks = address(0), we need code there + a mock response.
-        // tick=0 means 1:1 price → TWAP says pool rate is ~1 token/WETH → minting wins.
         _mockOracle(liquidityDelta, 0, uint32(REV_DEPLOYER.DEFAULT_BUYBACK_TWAP_WINDOW()));
-
-        // Cache immutables before prank (vm.prank only applies to the next call).
-        uint256 twapWindow = REV_DEPLOYER.DEFAULT_BUYBACK_TWAP_WINDOW();
-
-        // Register pool with buyback hook via split operator (multisig has SET_BUYBACK_POOL permission).
-        vm.prank(multisig());
-        BUYBACK_HOOK.setPoolFor({
-            projectId: revnetId, poolKey: key, twapWindow: twapWindow, terminalToken: JBConstants.NATIVE_TOKEN
-        });
     }
 
     /// @notice Mock the IGeomeanOracle at address(0) for hookless pools.
@@ -478,11 +498,11 @@ contract TestSplitWeightFork is TestBaseWorkflow {
         // arithmeticMeanTick = (tickCumulatives[1] - tickCumulatives[0]) / twapWindow = tick
         tickCumulatives[1] = int56(tick) * int56(int32(twapWindow));
 
-        uint160[] memory secondsPerLiquidityCumulativeX128s = new uint160[](2);
+        uint136[] memory secondsPerLiquidityCumulativeX128s = new uint136[](2);
         secondsPerLiquidityCumulativeX128s[0] = 0;
         uint256 liq = uint256(liquidity > 0 ? liquidity : -liquidity);
         if (liq == 0) liq = 1;
-        secondsPerLiquidityCumulativeX128s[1] = uint160((uint256(twapWindow) << 128) / liq);
+        secondsPerLiquidityCumulativeX128s[1] = uint136((uint256(twapWindow) << 128) / liq);
 
         vm.mockCall(
             address(0),
@@ -523,7 +543,7 @@ contract TestSplitWeightFork is TestBaseWorkflow {
     }
 
     /// @notice Build payment metadata with only 721 tier selection (no quote → TWAP/spot fallback).
-    function _buildPayMetadataNoQuote(address hookMetadataTarget) internal view returns (bytes memory) {
+    function _buildPayMetadataNoQuote(address hookMetadataTarget) internal pure returns (bytes memory) {
         uint16[] memory tierIds = new uint16[](1);
         tierIds[0] = 1;
         bytes memory tierData = abi.encode(true, tierIds);
@@ -543,122 +563,64 @@ contract TestSplitWeightFork is TestBaseWorkflow {
     /// @notice SWAP PATH: Pool offers good rate → buyback hook swaps on AMM instead of minting.
     /// With 30% tier split, the buyback should swap with 0.7 ETH worth.
     /// Terminal mints 0 tokens (weight=0), buyback hook mints via controller after swap.
-    function test_fork_swapPath_splitWithBuyback() public onlyFork {
+    function test_fork_swapPath_splitWithBuyback() public {
         (uint256 revnetId, IJB721TiersHook hook) = _deployRevnetWith721();
 
-        // Set up pool with deep liquidity at 1:1 price (pool offers ~1 token per WETH).
-        // The issuance rate is 1000 tokens/ETH, so the pool rate (~1 token/WETH) is much worse.
-        // Wait — at 1:1 pool price, 1 WETH gets ~1 token. Minting gets 1000 tokens.
-        // So minting is better → buyback will NOT swap.
-        // To make swap win, we need the pool to offer MORE tokens per WETH than minting.
-        // Minting rate = 1000 tokens/ETH (before split reduction, the buyback sees reduced weight).
-        //
-        // After REVDeployer scales weight: weight = 1000e18 * 0.7e18 / 1e18 = 700e18
-        // The buyback hook receives weight=700e18 and amount=0.7 ETH.
-        // tokenCountWithoutHook = mulDiv(0.7e18, 700e18, 1e18) = 490 tokens.
-        //
-        // Wait, that's wrong. Let me re-trace:
-        // REVDeployer.beforePayRecordedWith:
-        //   1. 721 hook returns splitAmount=0.3 ETH → projectAmount = 0.7 ETH
-        //   2. buybackHookContext.amount.value = 0.7 ETH, weight = context.weight = 1000e18
-        //   3. Buyback hook sees: amountToSwapWith = 0.7 ETH, weight = 1000e18
-        //      tokenCountWithoutHook = mulDiv(0.7e18, 1000e18, 1e18) = 700 tokens
-        //   4. If pool offers > 700 tokens for 0.7 WETH → swap wins
-        //   5. If pool offers < 700 tokens → mint wins
-        //
-        // At 1:1 pool price, 0.7 WETH gets ~0.7 tokens (after fees). That's way less than 700.
-        // We need a pool priced so projectToken is CHEAP — e.g., 1 WETH = 2000 tokens.
-        //
-        // Let's create a pool at a tick where projectToken is very cheap.
-        // tick = -69_000 gives approximately 1 WETH = 1000 tokens. We want more than 700 for 0.7 WETH.
-        // Actually, let's just seed the pool with lots of project tokens and little WETH.
-        // This naturally makes project tokens cheaper.
-
-        // Instead of tick manipulation, let's just use a pool at tick 0 (1:1) but seed asymmetrically:
-        // Lots of project tokens, little WETH → effective price favors the buyer.
-        // Actually V4 pool price is set at initialization (sqrtPriceX96), seeding doesn't change the tick.
-        //
-        // Let's initialize at a tick where 1 WETH = many project tokens.
-        // For swap to win: pool must give > 700 tokens for 0.7 WETH.
-        // Rate needed: > 1000 tokens/WETH.
-        // Use tick = -69082 which gives ~1:1000 ratio (1 WETH ≈ 1000 tokens).
-        // With 0.3% fee and slippage, it might give ~997, which is still > 700. Swap wins.
+        // We need to initialize the pool and get the price to favor buying project tokens: > 1000 tokens/ETH.
+        // Strategy: initialize pool, add liquidity, then swap project tokens for ETH to move the tick.
 
         address projectToken = address(jbTokens().tokenOf(revnetId));
         require(projectToken != address(0), "project token not deployed");
 
-        bool projectTokenIs0 = projectToken < WETH_ADDR;
-
-        // Build sorted pool key.
-        address token0 = projectTokenIs0 ? projectToken : WETH_ADDR;
-        address token1 = projectTokenIs0 ? WETH_ADDR : projectToken;
-
+        // Native ETH is address(0), always less than any deployed token.
         PoolKey memory key = PoolKey({
-            currency0: Currency.wrap(token0),
-            currency1: Currency.wrap(token1),
+            currency0: Currency.wrap(address(0)),
+            currency1: Currency.wrap(projectToken),
             fee: REV_DEPLOYER.DEFAULT_BUYBACK_POOL_FEE(),
             tickSpacing: REV_DEPLOYER.DEFAULT_BUYBACK_TICK_SPACING(),
             hooks: IHooks(address(0))
         });
 
-        // Set initial tick so that 1 WETH = ~2000 project tokens.
-        // If projectToken is token0: price = token1/token0 = WETH/projectToken.
-        //   We want projectToken cheap → WETH/projectToken high → tick positive.
-        //   tick ~= 76_000 → price ~= 2000.
-        // If WETH is token0: price = token1/token0 = projectToken/WETH.
-        //   We want projectToken/WETH high → tick positive.
-        //   tick ~= 76_000 → price ~= 2000.
-        // Either way: positive tick ≈ 2000 of token1 per token0.
-        //
-        // But we want "1 WETH = 2000 projectTokens".
-        // If projectToken is token0: price = WETH per projectToken = 1/2000 → negative tick.
-        //   tick ≈ -76_000.
-        // If WETH is token0: price = projectToken per WETH = 2000 → positive tick.
-        //   tick ≈ 76_000.
-        int24 initTick;
-        if (projectTokenIs0) {
-            // price = WETH/projectToken = 0.0005 → tick ≈ -76_000
-            initTick = -76_020; // Rounded to tickSpacing=60
-        } else {
-            // price = projectToken/WETH = 2000 → tick ≈ 76_000
-            initTick = 76_020;
-        }
-
-        uint160 sqrtPrice = TickMath.getSqrtPriceAtTick(initTick);
-        poolManager.initialize(key, sqrtPrice);
+        // Pool is already initialized at 1:1 price by REVDeployer during deployment.
 
         // Seed liquidity. We need both tokens.
         // IMPORTANT: Use JBTokens.mintFor (not deal) so ERC20Votes checkpoints are updated.
-        // deal() only sets balanceOf/totalSupply but skips Votes checkpoints, causing burn underflow.
-        uint256 projectLiq = 10_000_000e18; // lots of project tokens
-        uint256 wethLiq = 5000e18; // some WETH
+        uint256 projectLiq = 10_000_000e18;
+        uint256 ethLiq = 5000e18;
 
         vm.prank(address(jbController()));
         jbTokens().mintFor(address(liqHelper), revnetId, projectLiq);
-        vm.deal(address(liqHelper), wethLiq);
-        vm.prank(address(liqHelper));
-        IWETH9(WETH_ADDR).deposit{value: wethLiq}();
+        vm.deal(address(liqHelper), ethLiq);
 
         vm.startPrank(address(liqHelper));
         IERC20(projectToken).approve(address(poolManager), type(uint256).max);
-        IERC20(WETH_ADDR).approve(address(poolManager), type(uint256).max);
         vm.stopPrank();
 
-        // Add full-range liquidity.
-        int256 liquidityDelta = int256(wethLiq / 4); // Use fraction for liquidity units
+        // Add full-range liquidity at tick 0 (1:1 price).
+        int256 liquidityDelta = int256(ethLiq / 4);
         vm.prank(address(liqHelper));
-        liqHelper.addLiquidity(key, TICK_LOWER, TICK_UPPER, liquidityDelta);
+        liqHelper.addLiquidity{value: ethLiq}(key, TICK_LOWER, TICK_UPPER, liquidityDelta);
 
-        // Mock the oracle at address(0) to report the actual pool price (initTick).
-        // This makes the TWAP quote reflect ~2000 tokens/WETH, so the swap path wins.
-        _mockOracle(liquidityDelta, initTick, uint32(REV_DEPLOYER.DEFAULT_BUYBACK_TWAP_WINDOW()));
+        // Swap a large amount of project tokens for ETH to move the price.
+        // This makes project tokens cheaper (more tokens per ETH) so the swap path wins.
+        uint256 swapAmount = 5_000_000e18;
+        vm.prank(address(jbController()));
+        jbTokens().mintFor(address(liqHelper), revnetId, swapAmount);
 
-        // Register pool with buyback hook.
-        uint256 twapWindow = REV_DEPLOYER.DEFAULT_BUYBACK_TWAP_WINDOW();
-        vm.prank(multisig());
-        BUYBACK_HOOK.setPoolFor({
-            projectId: revnetId, poolKey: key, twapWindow: twapWindow, terminalToken: JBConstants.NATIVE_TOKEN
-        });
+        // currency0 is native ETH (address(0)), currency1 is projectToken.
+        // To sell projectToken for ETH (making project tokens cheaper), swap 1->0 (zeroForOne = false).
+        // zeroForOne=false pushes sqrtPrice up (more projectTokens per ETH).
+        bool zeroForOne = false;
+        uint160 sqrtPriceLimit = TickMath.getSqrtPriceAtTick(76_000);
+
+        vm.prank(address(liqHelper));
+        liqHelper.swap(key, zeroForOne, -int256(swapAmount), sqrtPriceLimit);
+
+        // Read the post-swap tick for the oracle mock.
+        (, int24 postSwapTick,,) = poolManager.getSlot0(key.toId());
+
+        // Mock the TWAP oracle to report the post-swap tick (so buyback hook sees the real price).
+        _mockOracle(liquidityDelta, postSwapTick, uint32(REV_DEPLOYER.DEFAULT_BUYBACK_TWAP_WINDOW()));
 
         // Build metadata: mint tier 1 + quote for swap.
         // The quote tells buyback to swap with the full amount, expecting at least 1 token out.
@@ -669,9 +631,6 @@ contract TestSplitWeightFork is TestBaseWorkflow {
             minimumSwapAmountOut: 1 // Accept any amount from swap
         });
 
-        // Record payer balance before.
-        uint256 payerBalBefore = jbTokens().totalBalanceOf(PAYER, revnetId);
-
         // Pay 1 ETH through the terminal.
         vm.prank(PAYER);
         uint256 terminalTokensReturned = jbMultiTerminal().pay{value: 1 ether}({
@@ -701,11 +660,11 @@ contract TestSplitWeightFork is TestBaseWorkflow {
     /// @notice MINT PATH: Pool offers bad rate → buyback decides minting is better.
     /// With 30% tier split, REVDeployer scales weight from 1000e18 to 700e18.
     /// Terminal mints 700 tokens.
-    function test_fork_mintPath_splitWithBuyback() public onlyFork {
+    function test_fork_mintPath_splitWithBuyback() public {
         (uint256 revnetId, IJB721TiersHook hook) = _deployRevnetWith721();
 
         // Set up pool with 1:1 price. At this price:
-        //   0.7 WETH → ~0.7 tokens from pool (after fees).
+        //   0.7 ETH → ~0.7 tokens from pool (after fees).
         //   Direct minting: 700 tokens.
         //   Minting wins by a huge margin → buyback returns context.weight unchanged.
         _setupPool(revnetId, 10_000 ether);
@@ -713,7 +672,7 @@ contract TestSplitWeightFork is TestBaseWorkflow {
         // Build metadata: mint tier 1 + quote for "swap" with 0.7 ETH, but expect many tokens (forces mint path).
         // When minimumSwapAmountOut > actual pool output, the buyback hook falls back to minting.
         // Actually the buyback hook uses max(payerQuote, twapQuote). If we set minimumSwapAmountOut=0,
-        // it'll use the TWAP/spot quote. At 1:1 pool price, spot says ~0.7 tokens for 0.7 WETH.
+        // it'll use the TWAP/spot quote. At 1:1 pool price, spot says ~0.7 tokens for 0.7 ETH.
         // tokenCountWithoutHook = 700 tokens. 700 > ~0.7 → mint wins.
         // We don't even need quote metadata — the spot fallback handles it.
         address metadataTarget = hook.METADATA_ID_TARGET();
@@ -742,7 +701,7 @@ contract TestSplitWeightFork is TestBaseWorkflow {
     }
 
     /// @notice MINT PATH without splits: baseline confirming 1000 tokens for 1 ETH.
-    function test_fork_mintPath_noSplits_fullTokens() public onlyFork {
+    function test_fork_mintPath_noSplits_fullTokens() public {
         (uint256 revnetId,) = _deployRevnetWith721();
         _setupPool(revnetId, 10_000 ether);
 
@@ -764,7 +723,7 @@ contract TestSplitWeightFork is TestBaseWorkflow {
     }
 
     /// @notice Invariant: tokens / projectAmount rate is identical with and without splits.
-    function test_fork_invariant_tokenPerEthConsistent() public onlyFork {
+    function test_fork_invariant_tokenPerEthConsistent() public {
         // --- Revnet 1: with 721 splits (30%) ---
         (uint256 revnetId1, IJB721TiersHook hook1) = _deployRevnetWith721();
         _setupPool(revnetId1, 10_000 ether);

package/test/{TestPR29_SwapTerminalPermission.t.sol → TestSwapTerminalPermission.t.sol}

@@ -30,7 +30,7 @@ import {IJBAddressRegistry} from "@bananapus/address-registry-v6/src/interfaces/
 
 /// @notice Tests for default operator permissions including SET_ROUTER_TERMINAL.
 /// Verifies that all default split operator permissions are granted correctly.
-contract TestPR29_SwapTerminalPermission is TestBaseWorkflow {
+contract TestSwapTerminalPermission is TestBaseWorkflow {
     bytes32 REV_DEPLOYER_SALT = "REVDeployer";
 
     REVDeployer REV_DEPLOYER;

package/test/{TestPR21_Uint112Overflow.t.sol → TestUint112Overflow.t.sol}

@@ -31,9 +31,9 @@ import {JB721TiersHookStore} from "@bananapus/721-hook-v6/src/JB721TiersHookStor
 import {JBAddressRegistry} from "@bananapus/address-registry-v6/src/JBAddressRegistry.sol";
 import {IJBAddressRegistry} from "@bananapus/address-registry-v6/src/interfaces/IJBAddressRegistry.sol";
 
-/// @title TestPR21_Uint112Overflow
+/// @title TestUint112Overflow
 /// @notice Tests for uint112 truncation fix in REVLoans._adjust()
-contract TestPR21_Uint112Overflow is TestBaseWorkflow {
+contract TestUint112Overflow is TestBaseWorkflow {
     bytes32 REV_DEPLOYER_SALT = "REVDeployer";
     bytes32 ERC20_SALT = "REV_TOKEN";
 
@@ -233,7 +233,7 @@ contract TestPR21_Uint112Overflow is TestBaseWorkflow {
     }
 
     /// @notice Verify that uint112.max exactly does NOT revert (boundary test).
-    function test_boundaryValue_exactlyUint112Max() public {
+    function test_boundaryValue_exactlyUint112Max() public pure {
         // uint112.max is the boundary — the check is `>`, not `>=`
         // So exactly uint112.max should NOT revert
         uint256 maxVal = type(uint112).max;
@@ -243,7 +243,7 @@ contract TestPR21_Uint112Overflow is TestBaseWorkflow {
 
     /// @notice Verify the overflow check exists: values > uint112.max are rejected.
     /// @dev We verify this by checking the error selector exists on the contract.
-    function test_overflowRevert_errorExists() public view {
+    function test_overflowRevert_errorExists() public pure {
         // The fix adds REVLoans_OverflowAlert error. Verify the error exists
         // by encoding it. If this compiles, the error exists.
         bytes4 selector = REVLoans.REVLoans_OverflowAlert.selector;

package/test/{TestPR16_ZeroRepayment.t.sol → TestZeroRepayment.t.sol}

@@ -32,7 +32,7 @@ import {JBAddressRegistry} from "@bananapus/address-registry-v6/src/JBAddressReg
 import {IJBAddressRegistry} from "@bananapus/address-registry-v6/src/interfaces/IJBAddressRegistry.sol";
 
 /// @notice Tests for PR #16: zero repayment prevention.
-contract TestPR16_ZeroRepayment is TestBaseWorkflow {
+contract TestZeroRepayment is TestBaseWorkflow {
     bytes32 REV_DEPLOYER_SALT = "REVDeployer";
 
     REVDeployer REV_DEPLOYER;
@@ -212,8 +212,6 @@ contract TestPR16_ZeroRepayment is TestBaseWorkflow {
         (uint256 loanId,,) = _setupLoan(USER, 10e18, 25);
         require(loanId != 0, "Loan setup failed");
 
-        REVLoan memory loan = LOANS_CONTRACT.loanOf(loanId);
-
         // After borrowing, fees reduced surplus. We need to restore it so newBorrowAmount >= loan.amount.
         // Donate enough surplus to compensate for all fees extracted during borrowing.
         // A large donation ensures newBorrowAmount > loan.amount, hitting
@@ -243,7 +241,7 @@ contract TestPR16_ZeroRepayment is TestBaseWorkflow {
     /// @notice Repaying full borrow amount should succeed (returning all collateral).
     function test_repayNonZeroAmount_succeeds() public {
         // Setup: borrow against 10 ETH
-        (uint256 loanId,, uint256 borrowAmount) = _setupLoan(USER, 10e18, 25);
+        (uint256 loanId,,) = _setupLoan(USER, 10e18, 25);
         require(loanId != 0, "Loan setup failed");
 
         REVLoan memory loan = LOANS_CONTRACT.loanOf(loanId);
@@ -271,7 +269,7 @@ contract TestPR16_ZeroRepayment is TestBaseWorkflow {
     /// @notice Repaying some collateral (non-zero) should succeed.
     function test_repayNonZeroCollateral_succeeds() public {
         // Setup: borrow against 10 ETH
-        (uint256 loanId,, uint256 borrowAmount) = _setupLoan(USER, 10e18, 25);
+        (uint256 loanId,,) = _setupLoan(USER, 10e18, 25);
         require(loanId != 0, "Loan setup failed");
 
         REVLoan memory loan = LOANS_CONTRACT.loanOf(loanId);
@@ -283,7 +281,7 @@ contract TestPR16_ZeroRepayment is TestBaseWorkflow {
         JBSingleAllowance memory allowance;
 
         vm.prank(USER);
-        (uint256 paidOffLoanId, REVLoan memory paidOffLoan) = LOANS_CONTRACT.repayLoan{value: loan.amount}(
+        (, REVLoan memory paidOffLoan) = LOANS_CONTRACT.repayLoan{value: loan.amount}(
             loanId,
             loan.amount, // maxRepayBorrowAmount — generous cap
             collateralToReturn,