@rev-net/core-v6 0.0.9 → 0.0.11

package/test/fork/ForkTestBase.sol

@@ -42,7 +42,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
@@ -53,7 +52,7 @@ 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";
 
@@ -63,6 +62,11 @@ import {IERC20} from "@openzeppelin/contracts/interfaces/IERC20.sol";
 contract LiquidityHelper is IUnlockCallback {
     IPoolManager public immutable poolManager;
 
+    enum Action {
+        ADD_LIQUIDITY,
+        SWAP
+    }
+
     struct AddLiqParams {
         PoolKey key;
         int24 tickLower;
@@ -70,6 +74,13 @@ contract LiquidityHelper is IUnlockCallback {
         int256 liquidityDelta;
     }
 
+    struct DoSwapParams {
+        PoolKey key;
+        bool zeroForOne;
+        int256 amountSpecified;
+        uint160 sqrtPriceLimitX96;
+    }
+
     constructor(IPoolManager _poolManager) {
         poolManager = _poolManager;
     }
@@ -83,13 +94,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(
@@ -111,6 +147,27 @@ 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), ""
+        );
+
+        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));
@@ -146,11 +203,10 @@ abstract contract ForkTestBase 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;
+    int24 constant TICK_LOWER = -887_200;
+    int24 constant TICK_UPPER = 887_200;
 
     // ───────────────────────── State
     // ─────────────────────────
@@ -166,7 +222,6 @@ abstract contract ForkTestBase is TestBaseWorkflow {
     IJBSuckerRegistry SUCKER_REGISTRY;
     CTPublisher PUBLISHER;
     IPoolManager poolManager;
-    IWETH9 weth;
     LiquidityHelper liqHelper;
 
     uint256 FEE_PROJECT_ID;
@@ -185,13 +240,8 @@ abstract contract ForkTestBase is TestBaseWorkflow {
     // ─────────────────────────
 
     function setUp() public virtual 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");
@@ -200,7 +250,6 @@ abstract contract ForkTestBase is TestBaseWorkflow {
         super.setUp();
 
         poolManager = IPoolManager(POOL_MANAGER_ADDR);
-        weth = IWETH9(WETH_ADDR);
         liqHelper = new LiquidityHelper(poolManager);
 
         FEE_PROJECT_ID = jbProjects().createFor(multisig());
@@ -220,8 +269,8 @@ abstract contract ForkTestBase is TestBaseWorkflow {
             jbPrices(),
             jbProjects(),
             jbTokens(),
-            weth,
             poolManager,
+            IHooks(address(0)), // oracleHook
             address(0) // trustedForwarder
         );
 
@@ -262,12 +311,6 @@ abstract contract ForkTestBase is TestBaseWorkflow {
         vm.deal(BORROWER, 100 ether);
     }
 
-    modifier onlyFork() {
-        string memory rpcUrl = vm.envOr("RPC_ETHEREUM_MAINNET", string(""));
-        if (bytes(rpcUrl).length == 0) return;
-        _;
-    }
-
     // ───────────────────────── Config Helpers
     // ─────────────────────────
 
@@ -403,6 +446,8 @@ abstract contract ForkTestBase is TestBaseWorkflow {
     function _deployRevnetWith721(uint16 cashOutTaxRate) internal returns (uint256 revnetId, IJB721TiersHook hook) {
         (REVConfig memory cfg, JBTerminalConfig[] memory tc, REVSuckerDeploymentConfig memory sdc) =
             _buildMinimalConfig(cashOutTaxRate);
+        // Use a different salt to avoid CREATE2 collision with _deployRevnet's ERC-20.
+        cfg.description.salt = "FORK_721_SALT";
         REVDeploy721TiersHookConfig memory hookConfig = _build721Config();
 
         (revnetId, hook) = REV_DEPLOYER.deployWith721sFor({
@@ -418,55 +463,42 @@ abstract contract ForkTestBase is TestBaseWorkflow {
     // ───────────────────────── Pool Helpers
     // ─────────────────────────
 
-    /// @notice Set up a V4 pool for the revnet's project token / WETH pair at 1:1 price.
+    /// @notice Set up a V4 pool for the revnet's project token / native ETH pair at 1:1 price.
     function _setupPool(uint256 revnetId, uint256 liquidityTokenAmount) internal returns (PoolKey memory key) {
         address projectToken = address(jbTokens().tokenOf(revnetId));
         require(projectToken != address(0), "project token not deployed");
 
-        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))
         });
 
-        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.
+
+        // At 1:1 price, full-range liquidity needs equal amounts of both tokens.
+        uint256 projectTokenAmount = liquidityTokenAmount;
 
         // Fund LiquidityHelper with project tokens via JBTokens.mintFor (not deal).
         vm.prank(address(jbController()));
-        jbTokens().mintFor(address(liqHelper), revnetId, liquidityTokenAmount);
+        jbTokens().mintFor(address(liqHelper), revnetId, projectTokenAmount);
+        // Fund with ETH for the native currency side.
         vm.deal(address(liqHelper), liquidityTokenAmount);
-        vm.prank(address(liqHelper));
-        IWETH9(WETH_ADDR).deposit{value: liquidityTokenAmount}();
 
         vm.startPrank(address(liqHelper));
         IERC20(projectToken).approve(address(poolManager), type(uint256).max);
-        IERC20(WETH_ADDR).approve(address(poolManager), type(uint256).max);
         vm.stopPrank();
 
         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);
 
         _mockOracle(liquidityDelta, 0, uint32(REV_DEPLOYER.DEFAULT_BUYBACK_TWAP_WINDOW()));
-
-        uint256 twapWindow = REV_DEPLOYER.DEFAULT_BUYBACK_TWAP_WINDOW();
-        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.
@@ -477,11 +509,11 @@ abstract contract ForkTestBase is TestBaseWorkflow {
         tickCumulatives[0] = 0;
         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),
@@ -547,7 +579,7 @@ abstract contract ForkTestBase 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);

package/test/fork/TestCashOutFork.t.sol

@@ -15,10 +15,6 @@ contract TestCashOutFork is ForkTestBase {
     function setUp() public override {
         super.setUp();
 
-        // Skip if no fork available.
-        string memory rpcUrl = vm.envOr("RPC_ETHEREUM_MAINNET", string(""));
-        if (bytes(rpcUrl).length == 0) return;
-
         // Deploy fee project + revnet with 50% cashOutTaxRate.
         _deployFeeProject(5000);
         revnetId = _deployRevnet(5000);
@@ -34,7 +30,7 @@ contract TestCashOutFork is ForkTestBase {
     }
 
     /// @notice Cash out tokens and verify fee deduction, token burn, and bonding curve reclaim.
-    function test_fork_cashOut_normalWithFee() public onlyFork {
+    function test_fork_cashOut_normalWithFee() public {
         uint256 payerTokens = jbTokens().totalBalanceOf(PAYER, revnetId);
         uint256 cashOutCount = payerTokens / 2; // Cash out half.
 
@@ -78,7 +74,7 @@ contract TestCashOutFork is ForkTestBase {
     }
 
     /// @notice High tax rate (90%) produces small reclaim relative to pro-rata.
-    function test_fork_cashOut_highTaxRate() public onlyFork {
+    function test_fork_cashOut_highTaxRate() public {
         // Deploy a separate revnet with 90% tax rate.
         uint256 highTaxRevnet = _deployRevnet(9000);
         _setupPool(highTaxRevnet, 10_000 ether);
@@ -111,7 +107,7 @@ contract TestCashOutFork is ForkTestBase {
     }
 
     /// @notice Sucker addresses get full pro-rata reclaim with 0% tax and no fee.
-    function test_fork_cashOut_suckerExempt() public onlyFork {
+    function test_fork_cashOut_suckerExempt() public {
         address sucker = makeAddr("sucker");
         vm.deal(sucker, 100 ether);
 
@@ -153,7 +149,7 @@ contract TestCashOutFork is ForkTestBase {
     }
 
     /// @notice After a payment with 30% tier split, surplus accounting reflects actual terminal balance.
-    function test_fork_cashOut_afterTierSplitPayment() public onlyFork {
+    function test_fork_cashOut_afterTierSplitPayment() public {
         // Deploy revnet with 721 hook.
         (uint256 splitRevnetId, IJB721TiersHook hook) = _deployRevnetWith721(5000);
         _setupPool(splitRevnetId, 10_000 ether);
@@ -202,9 +198,14 @@ contract TestCashOutFork is ForkTestBase {
     }
 
     /// @notice Cash out before delay expires should revert.
-    function test_fork_cashOut_delayEnforcement() public onlyFork {
-        // Deploy a fresh revnet (delay starts from deploy time).
-        uint256 delayRevnet = _deployRevnet(5000);
+    function test_fork_cashOut_delayEnforcement() public {
+        // Deploy a revnet whose first stage started in the past → triggers cash-out delay.
+        (REVConfig memory cfg, JBTerminalConfig[] memory tc, REVSuckerDeploymentConfig memory sdc) =
+            _buildMinimalConfig(5000);
+        cfg.stageConfigurations[0].startsAtOrAfter = uint40(block.timestamp - 1);
+        uint256 delayRevnet = REV_DEPLOYER.deployFor({
+            revnetId: 0, configuration: cfg, terminalConfigurations: tc, suckerDeploymentConfiguration: sdc
+        });
         _setupPool(delayRevnet, 10_000 ether);
         _payRevnet(delayRevnet, PAYER, 1 ether);
 

package/test/fork/TestLoanBorrowFork.t.sol

@@ -15,9 +15,6 @@ contract TestLoanBorrowFork is ForkTestBase {
     function setUp() public override {
         super.setUp();
 
-        string memory rpcUrl = vm.envOr("RPC_ETHEREUM_MAINNET", string(""));
-        if (bytes(rpcUrl).length == 0) return;
-
         // Deploy fee project + revnet with 50% cashOutTaxRate.
         _deployFeeProject(5000);
         revnetId = _deployRevnet(5000);
@@ -31,7 +28,7 @@ contract TestLoanBorrowFork is ForkTestBase {
     }
 
     /// @notice Basic borrow: collateralize all borrower tokens, verify loan state.
-    function test_fork_borrow_basic() public onlyFork {
+    function test_fork_borrow_basic() public {
         uint256 borrowerTokens = jbTokens().totalBalanceOf(BORROWER, revnetId);
 
         uint256 borrowable = LOANS_CONTRACT.borrowableAmountFrom(
@@ -53,8 +50,11 @@ contract TestLoanBorrowFork is ForkTestBase {
         assertEq(loan.collateral, borrowerTokens, "loan collateral should match");
         assertEq(loan.createdAt, block.timestamp, "loan createdAt should be now");
 
-        // Borrower tokens should be burned (collateral deposited).
-        assertEq(jbTokens().totalBalanceOf(BORROWER, revnetId), 0, "borrower tokens should be burned");
+        // Borrower's original tokens are burned as collateral, but the source fee payment back to the revnet mints
+        // some tokens to the borrower.
+        uint256 feeTokens = jbTokens().totalBalanceOf(BORROWER, revnetId);
+        assertGt(feeTokens, 0, "borrower should have tokens from source fee payment");
+        assertLt(feeTokens, borrowerTokens, "fee tokens should be less than original collateral");
 
         // Borrower received ETH (net of fees).
         assertGt(BORROWER.balance, borrowerEthBefore, "borrower should receive ETH");
@@ -76,7 +76,7 @@ contract TestLoanBorrowFork is ForkTestBase {
     }
 
     /// @notice Verify fee distribution: source fee (2.5%) + REV fee (1%) deducted correctly.
-    function test_fork_borrow_feeDistribution() public onlyFork {
+    function test_fork_borrow_feeDistribution() public {
         uint256 borrowerTokens = jbTokens().totalBalanceOf(BORROWER, revnetId);
         uint256 prepaidFeePercent = LOANS_CONTRACT.MIN_PREPAID_FEE_PERCENT(); // 25 = 2.5%
 
@@ -86,8 +86,6 @@ contract TestLoanBorrowFork is ForkTestBase {
 
         // Record balances before.
         uint256 borrowerEthBefore = BORROWER.balance;
-        uint256 revnetTerminalBefore = _terminalBalance(revnetId, JBConstants.NATIVE_TOKEN);
-
         _grantBurnPermission(BORROWER, revnetId);
 
         REVLoanSource memory source = _nativeLoanSource();
@@ -122,7 +120,7 @@ contract TestLoanBorrowFork is ForkTestBase {
     }
 
     /// @notice Borrow after a payment with 30% tier splits.
-    function test_fork_borrow_afterTierSplits() public onlyFork {
+    function test_fork_borrow_afterTierSplits() public {
         // Deploy revnet with 721 hook.
         (uint256 splitRevnetId, IJB721TiersHook hook) = _deployRevnetWith721(5000);
         _setupPool(splitRevnetId, 10_000 ether);
@@ -142,8 +140,8 @@ contract TestLoanBorrowFork is ForkTestBase {
             metadata: metadata
         });
 
-        // With 30% split and 1000 tokens/ETH issuance, borrower gets 700 tokens/ETH * 5 = 3500 tokens.
-        assertEq(borrowerTokens, 3500e18, "should get 3500 tokens after 30% split");
+        // Tier 1 costs 1 ETH with 30% split → 0.3 ETH to splits, 4.7 ETH minted at 1000 tokens/ETH = 4700 tokens.
+        assertEq(borrowerTokens, 4700e18, "should get 4700 tokens after tier split");
 
         // Surplus should reflect actual terminal balance.
         uint256 surplus = _terminalBalance(splitRevnetId, JBConstants.NATIVE_TOKEN);