@rev-net/core-v6 0.0.7 → 0.0.9

package/test/fork/TestLoanRepayFork.t.sol

@@ -0,0 +1,184 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.26;
+
+import "./ForkTestBase.sol";
+
+/// @notice Fork tests for REVLoans.repayLoan() with real Uniswap V4 buyback hook.
+///
+/// Covers: full repay, partial repay, source fee after prepaid, no-fee within prepaid, expired revert.
+///
+/// Run with: FOUNDRY_PROFILE=fork forge test --match-contract TestLoanRepayFork -vvv
+contract TestLoanRepayFork is ForkTestBase {
+    uint256 revnetId;
+    uint256 loanId;
+    REVLoan loan;
+    uint256 borrowerTokens;
+
+    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.
+        _deployFeeProject(5000);
+        revnetId = _deployRevnet(5000);
+        _setupPool(revnetId, 10_000 ether);
+
+        // Pay to create surplus.
+        _payRevnet(revnetId, PAYER, 10 ether);
+        _payRevnet(revnetId, BORROWER, 5 ether);
+
+        borrowerTokens = jbTokens().totalBalanceOf(BORROWER, revnetId);
+
+        // Create a loan with min prepaid fee.
+        (loanId, loan) = _createLoan(revnetId, BORROWER, borrowerTokens, LOANS_CONTRACT.MIN_PREPAID_FEE_PERCENT());
+    }
+
+    /// @notice Full repay: return all collateral, burn loan NFT.
+    function test_fork_repay_full() public onlyFork {
+        uint256 totalCollateralBefore = LOANS_CONTRACT.totalCollateralOf(revnetId);
+        uint256 totalBorrowedBefore =
+            LOANS_CONTRACT.totalBorrowedFrom(revnetId, jbMultiTerminal(), JBConstants.NATIVE_TOKEN);
+
+        // Fund borrower to repay (they need more ETH than they got from the loan due to fees).
+        vm.deal(BORROWER, 100 ether);
+
+        JBSingleAllowance memory allowance;
+
+        vm.prank(BORROWER);
+        LOANS_CONTRACT.repayLoan{value: loan.amount * 2}({
+            loanId: loanId,
+            maxRepayBorrowAmount: loan.amount * 2,
+            collateralCountToReturn: loan.collateral,
+            beneficiary: payable(BORROWER),
+            allowance: allowance
+        });
+
+        // Collateral re-minted to borrower.
+        assertEq(
+            jbTokens().totalBalanceOf(BORROWER, revnetId), borrowerTokens, "collateral should be returned to borrower"
+        );
+
+        // Loan NFT burned.
+        vm.expectRevert();
+        _loanOwnerOf(loanId);
+
+        // Tracking decreased.
+        assertEq(
+            LOANS_CONTRACT.totalCollateralOf(revnetId),
+            totalCollateralBefore - loan.collateral,
+            "totalCollateralOf should decrease"
+        );
+        assertLt(
+            LOANS_CONTRACT.totalBorrowedFrom(revnetId, jbMultiTerminal(), JBConstants.NATIVE_TOKEN),
+            totalBorrowedBefore,
+            "totalBorrowedFrom should decrease"
+        );
+    }
+
+    /// @notice Partial repay: return half the collateral, old loan burned, new loan minted.
+    function test_fork_repay_partial() public onlyFork {
+        uint256 halfCollateral = loan.collateral / 2;
+
+        vm.deal(BORROWER, 100 ether);
+
+        JBSingleAllowance memory allowance;
+
+        vm.prank(BORROWER);
+        (uint256 newLoanId, REVLoan memory newLoan) = LOANS_CONTRACT.repayLoan{value: loan.amount * 2}({
+            loanId: loanId,
+            maxRepayBorrowAmount: loan.amount * 2,
+            collateralCountToReturn: halfCollateral,
+            beneficiary: payable(BORROWER),
+            allowance: allowance
+        });
+
+        // Some collateral re-minted.
+        uint256 returnedTokens = jbTokens().totalBalanceOf(BORROWER, revnetId);
+        assertEq(returnedTokens, halfCollateral, "half collateral should be returned");
+
+        // Old loan burned.
+        vm.expectRevert();
+        _loanOwnerOf(loanId);
+
+        // New loan created with reduced collateral.
+        assertGt(newLoanId, 0, "new loan should be created");
+        assertEq(newLoan.collateral, loan.collateral - halfCollateral, "new loan collateral should be reduced");
+        assertLt(newLoan.amount, loan.amount, "new loan amount should be less");
+
+        // New loan NFT owned by borrower.
+        assertEq(_loanOwnerOf(newLoanId), BORROWER, "new loan NFT should be owned by borrower");
+    }
+
+    /// @notice After prepaid duration, source fee is charged on repayment.
+    function test_fork_repay_withSourceFee() public onlyFork {
+        // Warp past the prepaid duration but before 10 years.
+        vm.warp(block.timestamp + loan.prepaidDuration + 1 days);
+
+        vm.deal(BORROWER, 100 ether);
+
+        // Record ETH spent for repayment.
+        uint256 borrowerEthBefore = BORROWER.balance;
+
+        JBSingleAllowance memory allowance;
+
+        vm.prank(BORROWER);
+        LOANS_CONTRACT.repayLoan{value: loan.amount * 3}({
+            loanId: loanId,
+            maxRepayBorrowAmount: loan.amount * 3,
+            collateralCountToReturn: loan.collateral,
+            beneficiary: payable(BORROWER),
+            allowance: allowance
+        });
+
+        uint256 ethSpent = borrowerEthBefore - BORROWER.balance;
+
+        // Total cost should be more than the loan principal (due to source fee).
+        assertGt(ethSpent, loan.amount, "repay cost should exceed loan amount due to source fee");
+    }
+
+    /// @notice Repay immediately (within prepaid duration) -> no source fee.
+    function test_fork_repay_withinPrepaidNofee() public onlyFork {
+        // Don't warp — we're within prepaid duration.
+        vm.deal(BORROWER, 100 ether);
+
+        uint256 borrowerEthBefore = BORROWER.balance;
+
+        JBSingleAllowance memory allowance;
+
+        vm.prank(BORROWER);
+        LOANS_CONTRACT.repayLoan{value: loan.amount * 2}({
+            loanId: loanId,
+            maxRepayBorrowAmount: loan.amount * 2,
+            collateralCountToReturn: loan.collateral,
+            beneficiary: payable(BORROWER),
+            allowance: allowance
+        });
+
+        uint256 ethSpent = borrowerEthBefore - BORROWER.balance;
+
+        // Within prepaid period, cost should be exactly the loan amount (no additional source fee).
+        assertEq(ethSpent, loan.amount, "repay within prepaid should cost exactly loan amount");
+    }
+
+    /// @notice Repay after 10 years should revert (loan expired).
+    function test_fork_repay_expiredReverts() public onlyFork {
+        // Warp past the 10-year liquidation duration.
+        vm.warp(block.timestamp + LOANS_CONTRACT.LOAN_LIQUIDATION_DURATION());
+
+        vm.deal(BORROWER, 100 ether);
+
+        JBSingleAllowance memory allowance;
+
+        vm.prank(BORROWER);
+        vm.expectRevert();
+        LOANS_CONTRACT.repayLoan{value: loan.amount * 3}({
+            loanId: loanId,
+            maxRepayBorrowAmount: loan.amount * 3,
+            collateralCountToReturn: loan.collateral,
+            beneficiary: payable(BORROWER),
+            allowance: allowance
+        });
+    }
+}

package/test/fork/TestSplitWeightFork.t.sol

@@ -0,0 +1,186 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.26;
+
+import "./ForkTestBase.sol";
+
+/// @notice Fork tests verifying that revnet 721 tier splits + real Uniswap V4 buyback hook produce correct token
+/// issuance in both the swap path (AMM buyback) and the mint path (direct minting).
+///
+/// Requires: RPC_ETHEREUM_MAINNET env var for mainnet fork (real PoolManager).
+///
+/// Run with: FOUNDRY_PROFILE=fork forge test --match-contract TestSplitWeightFork -vvv --skip "script/*"
+contract TestSplitWeightFork is ForkTestBase {
+    // ───────────────────────── Tests
+    // ─────────────────────────
+
+    /// @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 {
+        _deployFeeProject(5000);
+        (uint256 revnetId, IJB721TiersHook hook) = _deployRevnetWith721(5000);
+
+        address projectToken = address(jbTokens().tokenOf(revnetId));
+        require(projectToken != address(0), "project token not deployed");
+
+        bool projectTokenIs0 = projectToken < WETH_ADDR;
+
+        address token0 = projectTokenIs0 ? projectToken : WETH_ADDR;
+        address token1 = projectTokenIs0 ? WETH_ADDR : projectToken;
+
+        PoolKey memory key = PoolKey({
+            currency0: Currency.wrap(token0),
+            currency1: Currency.wrap(token1),
+            fee: REV_DEPLOYER.DEFAULT_BUYBACK_POOL_FEE(),
+            tickSpacing: REV_DEPLOYER.DEFAULT_BUYBACK_TICK_SPACING(),
+            hooks: IHooks(address(0))
+        });
+
+        int24 initTick;
+        if (projectTokenIs0) {
+            initTick = -76_020;
+        } else {
+            initTick = 76_020;
+        }
+
+        uint160 sqrtPrice = TickMath.getSqrtPriceAtTick(initTick);
+        poolManager.initialize(key, sqrtPrice);
+
+        uint256 projectLiq = 10_000_000e18;
+        uint256 wethLiq = 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.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(wethLiq / 4);
+        vm.prank(address(liqHelper));
+        liqHelper.addLiquidity(key, TICK_LOWER, TICK_UPPER, liquidityDelta);
+
+        _mockOracle(liquidityDelta, initTick, 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
+        });
+
+        address metadataTarget = hook.METADATA_ID_TARGET();
+        bytes memory metadata = _buildPayMetadataWithQuote({
+            hookMetadataTarget: metadataTarget, amountToSwapWith: 0.7 ether, minimumSwapAmountOut: 1
+        });
+
+        vm.prank(PAYER);
+        uint256 terminalTokensReturned = jbMultiTerminal().pay{value: 1 ether}({
+            projectId: revnetId,
+            token: JBConstants.NATIVE_TOKEN,
+            amount: 1 ether,
+            beneficiary: PAYER,
+            minReturnedTokens: 0,
+            memo: "Fork: swap path with splits",
+            metadata: metadata
+        });
+
+        assertGt(terminalTokensReturned, 700e18, "swap path: should get more tokens than minting (pool rate better)");
+    }
+
+    /// @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 {
+        _deployFeeProject(5000);
+        (uint256 revnetId, IJB721TiersHook hook) = _deployRevnetWith721(5000);
+        _setupPool(revnetId, 10_000 ether);
+
+        address metadataTarget = hook.METADATA_ID_TARGET();
+        bytes memory metadata = _buildPayMetadataNoQuote(metadataTarget);
+
+        vm.prank(PAYER);
+        uint256 tokensReceived = jbMultiTerminal().pay{value: 1 ether}({
+            projectId: revnetId,
+            token: JBConstants.NATIVE_TOKEN,
+            amount: 1 ether,
+            beneficiary: PAYER,
+            minReturnedTokens: 0,
+            memo: "Fork: mint path with splits",
+            metadata: metadata
+        });
+
+        uint256 expectedTokens = 700e18;
+        assertEq(tokensReceived, expectedTokens, "mint path: should receive 700 tokens (weight scaled for 30% split)");
+    }
+
+    /// @notice MINT PATH without splits: baseline confirming 1000 tokens for 1 ETH.
+    function test_fork_mintPath_noSplits_fullTokens() public onlyFork {
+        _deployFeeProject(5000);
+        (uint256 revnetId,) = _deployRevnetWith721(5000);
+        _setupPool(revnetId, 10_000 ether);
+
+        vm.prank(PAYER);
+        uint256 tokensReceived = jbMultiTerminal().pay{value: 1 ether}({
+            projectId: revnetId,
+            token: JBConstants.NATIVE_TOKEN,
+            amount: 1 ether,
+            beneficiary: PAYER,
+            minReturnedTokens: 0,
+            memo: "Fork: no split baseline",
+            metadata: ""
+        });
+
+        uint256 expectedTokens = 1000e18;
+        assertEq(tokensReceived, expectedTokens, "no splits: should receive 1000 tokens");
+    }
+
+    /// @notice Invariant: tokens / projectAmount rate is identical with and without splits.
+    function test_fork_invariant_tokenPerEthConsistent() public onlyFork {
+        _deployFeeProject(5000);
+
+        // --- Revnet 1: with 721 splits (30%) ---
+        (uint256 revnetId1, IJB721TiersHook hook1) = _deployRevnetWith721(5000);
+        _setupPool(revnetId1, 10_000 ether);
+
+        address metadataTarget1 = hook1.METADATA_ID_TARGET();
+        bytes memory metadata1 = _buildPayMetadataNoQuote(metadataTarget1);
+
+        vm.prank(PAYER);
+        uint256 tokens1 = jbMultiTerminal().pay{value: 1 ether}({
+            projectId: revnetId1,
+            token: JBConstants.NATIVE_TOKEN,
+            amount: 1 ether,
+            beneficiary: PAYER,
+            minReturnedTokens: 0,
+            memo: "invariant: with splits",
+            metadata: metadata1
+        });
+
+        // --- Revnet 2: no splits (plain payment, no tier metadata) ---
+        uint256 revnetId2 = _deployRevnet(5000);
+        _setupPool(revnetId2, 10_000 ether);
+
+        vm.prank(PAYER);
+        uint256 tokens2 = jbMultiTerminal().pay{value: 1 ether}({
+            projectId: revnetId2,
+            token: JBConstants.NATIVE_TOKEN,
+            amount: 1 ether,
+            beneficiary: PAYER,
+            minReturnedTokens: 0,
+            memo: "invariant: no splits",
+            metadata: ""
+        });
+
+        uint256 projectAmount1 = 0.7 ether;
+        uint256 projectAmount2 = 1 ether;
+
+        uint256 rate1 = (tokens1 * 1e18) / projectAmount1;
+        uint256 rate2 = (tokens2 * 1e18) / projectAmount2;
+
+        assertEq(rate1, rate2, "token-per-ETH rate should be identical with and without splits");
+    }
+}

package/test/mock/MockBuybackDataHook.sol

@@ -4,14 +4,15 @@ pragma solidity 0.8.26;
 import {IJBRulesetDataHook} from "@bananapus/core-v6/src/interfaces/IJBRulesetDataHook.sol";
 import {IJBPayHook} from "@bananapus/core-v6/src/interfaces/IJBPayHook.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 {JBBeforePayRecordedContext} from "@bananapus/core-v6/src/structs/JBBeforePayRecordedContext.sol";
 import {JBBeforeCashOutRecordedContext} from "@bananapus/core-v6/src/structs/JBBeforeCashOutRecordedContext.sol";
 import {JBPayHookSpecification} from "@bananapus/core-v6/src/structs/JBPayHookSpecification.sol";
 import {JBCashOutHookSpecification} from "@bananapus/core-v6/src/structs/JBCashOutHookSpecification.sol";
 import {JBAfterPayRecordedContext} from "@bananapus/core-v6/src/structs/JBAfterPayRecordedContext.sol";
 import {JBRuleset} from "@bananapus/core-v6/src/structs/JBRuleset.sol";
-import {IUniswapV3Pool} from "@uniswap/v3-core/contracts/interfaces/IUniswapV3Pool.sol";
 import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
 
 /// @notice A minimal mock buyback data hook for tests. Returns the default weight and a no-op pay hook specification.
 contract MockBuybackDataHook is IJBRulesetDataHook, IJBPayHook {
@@ -49,11 +50,17 @@ contract MockBuybackDataHook is IJBRulesetDataHook, IJBPayHook {
 
     function afterPayRecordedWith(JBAfterPayRecordedContext calldata) external payable override {}
 
-    /// @notice No-op pool configuration for tests.
-    function setPoolFor(uint256, uint24, uint256, address) external pure returns (IUniswapV3Pool) {
-        return IUniswapV3Pool(address(0));
+    /// @notice Returns a dummy wrapped native token address for tests.
+    function WRAPPED_NATIVE_TOKEN() external pure returns (IWETH9) {
+        return IWETH9(address(1));
     }
 
+    /// @notice No-op pool configuration for tests (PoolKey overload).
+    function setPoolFor(uint256, PoolKey calldata, uint256, address) external pure {}
+
+    /// @notice No-op pool configuration for tests (simplified overload).
+    function setPoolFor(uint256, uint24, int24, uint256, address) external pure {}
+
     function supportsInterface(bytes4 interfaceId) external pure override returns (bool) {
         return interfaceId == type(IJBRulesetDataHook).interfaceId || interfaceId == type(IJBPayHook).interfaceId
             || interfaceId == type(IERC165).interfaceId;

package/test/mock/MockBuybackDataHookMintPath.sol

@@ -3,14 +3,15 @@ pragma solidity 0.8.26;
 
 import {IJBRulesetDataHook} from "@bananapus/core-v6/src/interfaces/IJBRulesetDataHook.sol";
 import {IJBPayHook} from "@bananapus/core-v6/src/interfaces/IJBPayHook.sol";
+import {IWETH9} from "@bananapus/buyback-hook-v6/src/interfaces/external/IWETH9.sol";
 import {JBBeforePayRecordedContext} from "@bananapus/core-v6/src/structs/JBBeforePayRecordedContext.sol";
 import {JBBeforeCashOutRecordedContext} from "@bananapus/core-v6/src/structs/JBBeforeCashOutRecordedContext.sol";
 import {JBPayHookSpecification} from "@bananapus/core-v6/src/structs/JBPayHookSpecification.sol";
 import {JBCashOutHookSpecification} from "@bananapus/core-v6/src/structs/JBCashOutHookSpecification.sol";
 import {JBAfterPayRecordedContext} from "@bananapus/core-v6/src/structs/JBAfterPayRecordedContext.sol";
 import {JBRuleset} from "@bananapus/core-v6/src/structs/JBRuleset.sol";
-import {IUniswapV3Pool} from "@uniswap/v3-core/contracts/interfaces/IUniswapV3Pool.sol";
 import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
 
 /// @notice Mock buyback hook that simulates the "mint path" — returns EMPTY hookSpecifications.
 /// This is what the real JBBuybackHook does when direct minting is cheaper than swapping
@@ -50,10 +51,17 @@ contract MockBuybackDataHookMintPath is IJBRulesetDataHook, IJBPayHook {
 
     function afterPayRecordedWith(JBAfterPayRecordedContext calldata) external payable override {}
 
-    function setPoolFor(uint256, uint24, uint256, address) external pure returns (IUniswapV3Pool) {
-        return IUniswapV3Pool(address(0));
+    /// @notice Returns a dummy wrapped native token address for tests.
+    function WRAPPED_NATIVE_TOKEN() external pure returns (IWETH9) {
+        return IWETH9(address(1));
     }
 
+    /// @notice No-op pool configuration for tests (PoolKey overload).
+    function setPoolFor(uint256, PoolKey calldata, uint256, address) external pure {}
+
+    /// @notice No-op pool configuration for tests (simplified overload).
+    function setPoolFor(uint256, uint24, int24, uint256, address) external pure {}
+
     function supportsInterface(bytes4 interfaceId) external pure override returns (bool) {
         return interfaceId == type(IJBRulesetDataHook).interfaceId || interfaceId == type(IJBPayHook).interfaceId
             || interfaceId == type(IERC165).interfaceId;

package/test/regression/TestI20_CumulativeLoanCounter.t.sol

@@ -31,11 +31,11 @@ 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";
 
-/// @notice Regression test for I-20: totalLoansBorrowedFor is a cumulative counter, not an active loan count.
+/// @notice totalLoansBorrowedFor is a cumulative counter, not an active loan count.
 /// @dev The rename from numberOfLoansFor to totalLoansBorrowedFor clarifies that the counter only increments
 /// and never decrements. Repaying or liquidating a loan does NOT reduce the counter. This test verifies that
 /// the counter remains at its high-water mark after loans are fully repaid and after loans are liquidated.
-contract TestI20_CumulativeLoanCounter is TestBaseWorkflow, JBTest {
+contract TestI20_CumulativeLoanCounter is TestBaseWorkflow {
     bytes32 REV_DEPLOYER_SALT = "REVDeployer";
 
     REVDeployer REV_DEPLOYER;
@@ -62,7 +62,8 @@ contract TestI20_CumulativeLoanCounter is TestBaseWorkflow, JBTest {
         FEE_PROJECT_ID = jbProjects().createFor(multisig());
         SUCKER_REGISTRY = new JBSuckerRegistry(jbDirectory(), jbPermissions(), multisig(), address(0));
         HOOK_STORE = new JB721TiersHookStore();
-        EXAMPLE_HOOK = new JB721TiersHook(jbDirectory(), jbPermissions(), jbRulesets(), HOOK_STORE, multisig());
+        EXAMPLE_HOOK =
+            new JB721TiersHook(jbDirectory(), jbPermissions(), jbRulesets(), HOOK_STORE, jbSplits(), multisig());
         ADDRESS_REGISTRY = new JBAddressRegistry();
         HOOK_DEPLOYER = new JB721TiersHookDeployer(EXAMPLE_HOOK, HOOK_STORE, ADDRESS_REGISTRY, multisig());
         PUBLISHER = new CTPublisher(jbDirectory(), jbPermissions(), FEE_PROJECT_ID, multisig());
@@ -87,7 +88,7 @@ contract TestI20_CumulativeLoanCounter is TestBaseWorkflow, JBTest {
             FEE_PROJECT_ID,
             HOOK_DEPLOYER,
             PUBLISHER,
-            IJBRulesetDataHook(address(MOCK_BUYBACK)),
+            IJBBuybackHookRegistry(address(MOCK_BUYBACK)),
             address(LOANS_CONTRACT),
             TRUSTED_FORWARDER
         );
@@ -200,7 +201,7 @@ contract TestI20_CumulativeLoanCounter is TestBaseWorkflow, JBTest {
 
     /// @notice Verifies totalLoansBorrowedFor never decrements after loan repayment.
     /// @dev Creates 3 loans, fully repays 2, then verifies the counter stays at 3 (not 1).
-    /// This confirms the I-20 rename correctly reflects cumulative semantics.
+    /// This confirms that the rename correctly reflects cumulative semantics.
     function test_I20_counterNeverDecrementsAfterRepayment() public {
         // Counter starts at 0
         assertEq(LOANS_CONTRACT.totalLoansBorrowedFor(REVNET_ID), 0, "Counter should start at 0");

package/test/regression/TestL27_LiquidateGapHandling.t.sol

@@ -32,11 +32,11 @@ import {JBAddressRegistry} from "@bananapus/address-registry-v6/src/JBAddressReg
 import {IJBAddressRegistry} from "@bananapus/address-registry-v6/src/interfaces/IJBAddressRegistry.sol";
 import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
 
-/// @notice Regression test for L-27: liquidateExpiredLoansFrom halts on deleted loan gaps.
+/// @notice liquidateExpiredLoansFrom halts on deleted loan gaps.
 /// @dev Before the fix, the function used `break` when encountering a deleted loan (createdAt == 0),
 /// which stopped the entire iteration. Expired loans after the gap were never liquidated.
 /// After the fix, `continue` is used instead, so the loop skips gaps and keeps processing.
-contract TestL27_LiquidateGapHandling is TestBaseWorkflow, JBTest {
+contract TestL27_LiquidateGapHandling is TestBaseWorkflow {
     bytes32 REV_DEPLOYER_SALT = "REVDeployer";
 
     REVDeployer REV_DEPLOYER;
@@ -64,7 +64,8 @@ contract TestL27_LiquidateGapHandling is TestBaseWorkflow, JBTest {
         FEE_PROJECT_ID = jbProjects().createFor(multisig());
         SUCKER_REGISTRY = new JBSuckerRegistry(jbDirectory(), jbPermissions(), multisig(), address(0));
         HOOK_STORE = new JB721TiersHookStore();
-        EXAMPLE_HOOK = new JB721TiersHook(jbDirectory(), jbPermissions(), jbRulesets(), HOOK_STORE, multisig());
+        EXAMPLE_HOOK =
+            new JB721TiersHook(jbDirectory(), jbPermissions(), jbRulesets(), HOOK_STORE, jbSplits(), multisig());
         ADDRESS_REGISTRY = new JBAddressRegistry();
         HOOK_DEPLOYER = new JB721TiersHookDeployer(EXAMPLE_HOOK, HOOK_STORE, ADDRESS_REGISTRY, multisig());
         PUBLISHER = new CTPublisher(jbDirectory(), jbPermissions(), FEE_PROJECT_ID, multisig());
@@ -88,7 +89,7 @@ contract TestL27_LiquidateGapHandling is TestBaseWorkflow, JBTest {
             FEE_PROJECT_ID,
             HOOK_DEPLOYER,
             PUBLISHER,
-            IJBRulesetDataHook(address(MOCK_BUYBACK)),
+            IJBBuybackHookRegistry(address(MOCK_BUYBACK)),
             address(LOANS_CONTRACT),
             TRUSTED_FORWARDER
         );
@@ -201,7 +202,7 @@ contract TestL27_LiquidateGapHandling is TestBaseWorkflow, JBTest {
         (loanId,) = LOANS_CONTRACT.borrowFrom(REVNET_ID, source, 0, tokenCount, payable(user), 25);
     }
 
-    /// @notice Regression test for L-27: liquidation should continue past deleted loan gaps.
+    /// @notice Liquidation should continue past deleted loan gaps.
     /// @dev Steps:
     ///   1. Create 3 loans (loan numbers 1, 2, 3)
     ///   2. Fully repay loan 2, which deletes it (createdAt == 0), creating a gap
@@ -268,7 +269,7 @@ contract TestL27_LiquidateGapHandling is TestBaseWorkflow, JBTest {
         REVLoan memory liquidatedLoan1 = LOANS_CONTRACT.loanOf(loanId1);
         assertEq(liquidatedLoan1.createdAt, 0, "Loan 1 should be liquidated (data deleted)");
 
-        // Loan 3 should ALSO be liquidated -- this is the critical assertion for L-27.
+        // Loan 3 should ALSO be liquidated -- this is the critical assertion.
         // Before the fix, this would fail because the `break` at loan 2's gap stopped iteration.
         REVLoan memory liquidatedLoan3 = LOANS_CONTRACT.loanOf(loanId3);
         assertEq(liquidatedLoan3.createdAt, 0, "Loan 3 should be liquidated despite gap at loan 2");

package/SECURITY.md

@@ -1,68 +0,0 @@
-# Security Considerations
-
-## [INTEROP-6] Cross-Chain Accounting Mismatch: NATIVE_TOKEN on Non-ETH Chains
-
-**Severity:** Medium
-**Status:** Acknowledged — by design, not fixable without oracle dependencies
-
-### Description
-
-When a revnet expands to a chain where the native token is not ETH (e.g., Celo where native = CELO), using `JBConstants.NATIVE_TOKEN` as the terminal accounting context and sucker token mapping creates a semantic mismatch. The protocol treats CELO payments as ETH-equivalent.
-
-### What the Matching Hash Covers
-
-The hash computed in `REVDeployer._makeRulesetConfigurations()` ensures both sides of a cross-chain deployment agree on:
-- `baseCurrency`, `loans`, `name`, `ticker`, `salt`
-- Per stage: timing, splits, issuance, cash-out tax
-- Per auto-issuance: chainId, beneficiary, count
-
-### What the Matching Hash Does NOT Cover
-
-- Terminal configurations (which tokens are accepted)
-- Accounting contexts (token address, decimals, currency)
-- Sucker token mappings (localToken → remoteToken)
-
-Two deployments can produce identical hashes while one accepts ETH-native and the other accepts CELO-native. The hash is a safety check for economic parameter alignment, not a guarantee of asset compatibility.
-
-### Impact on Revnets
-
-1. **Issuance mispricing** — A revnet with `baseCurrency = ETH` that accepts `NATIVE_TOKEN` on Celo prices CELO payments as ETH (1:1 without a price feed), massively overvaluing them.
-2. **Surplus fragmentation** — Cash-out bonding curve on each chain only sees that chain's surplus. Token holders must bridge to the chain with more surplus for fair cash-out values.
-3. **Cash-out arbitrage** — Different effective valuations across chains let arbitrageurs buy tokens cheaply on one chain and cash out on another.
-
-### Recommended Configuration for Non-ETH Chains
-
-When deploying a revnet to Celo or other non-ETH-native chains:
-
-```solidity
-// DO: Use WETH ERC20 as accounting context
-accountingContextsToAccept[0] = JBAccountingContext({
-    token: WETH_ADDRESS,  // e.g., 0xD221812... on Celo
-    decimals: 18,
-    currency: ETH_CURRENCY
-});
-
-// DO: Map WETH → WETH in sucker token mappings
-tokenMappings[0] = JBTokenMapping({
-    localToken: WETH_ADDRESS,
-    remoteToken: WETH_ADDRESS,
-    minGas: 200_000,
-    minBridgeAmount: 0.01 ether
-});
-
-// DON'T: Use NATIVE_TOKEN on non-ETH chains
-// This maps CELO → ETH which are different assets
-tokenMappings[0] = JBTokenMapping({
-    localToken: JBConstants.NATIVE_TOKEN,   // = CELO on Celo
-    remoteToken: JBConstants.NATIVE_TOKEN,  // = ETH on Ethereum
-    ...
-});
-```
-
-### Safe Chains
-
-OP Stack L2s where native token IS ETH: Ethereum, Optimism, Base, Arbitrum.
-
-### Affected Chains
-
-Any chain where native token ≠ ETH: Celo (CELO), Polygon (MATIC), Avalanche (AVAX), BNB Chain (BNB).