@rev-net/core-v6 0.0.7 → 0.0.9

package/test/fork/TestCashOutFork.t.sol

@@ -0,0 +1,245 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.26;
+
+import "./ForkTestBase.sol";
+import {JBCashOuts} from "@bananapus/core-v6/src/libraries/JBCashOuts.sol";
+
+/// @notice Fork tests for revnet cash-out scenarios with real Uniswap V4 buyback hook.
+///
+/// Covers: fee deduction, high tax rate, sucker exemption, surplus after tier splits, and delay enforcement.
+///
+/// Run with: FOUNDRY_PROFILE=fork forge test --match-contract TestCashOutFork -vvv
+contract TestCashOutFork is ForkTestBase {
+    uint256 revnetId;
+
+    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);
+
+        // Set up pool at 1:1 (mint path wins).
+        _setupPool(revnetId, 10_000 ether);
+
+        // Pay 10 ETH to create surplus and tokens.
+        _payRevnet(revnetId, PAYER, 10 ether);
+
+        // Warp past the 30-day cash-out delay.
+        vm.warp(block.timestamp + REV_DEPLOYER.CASH_OUT_DELAY() + 1);
+    }
+
+    /// @notice Cash out tokens and verify fee deduction, token burn, and bonding curve reclaim.
+    function test_fork_cashOut_normalWithFee() public onlyFork {
+        uint256 payerTokens = jbTokens().totalBalanceOf(PAYER, revnetId);
+        uint256 cashOutCount = payerTokens / 2; // Cash out half.
+
+        // Record state before.
+        uint256 payerEthBefore = PAYER.balance;
+        uint256 feeTerminalBefore = _terminalBalance(FEE_PROJECT_ID, JBConstants.NATIVE_TOKEN);
+        uint256 totalSupplyBefore = jbTokens().totalSupplyOf(revnetId);
+
+        // Cash out.
+        vm.prank(PAYER);
+        uint256 reclaimedAmount = jbMultiTerminal()
+            .cashOutTokensOf({
+                holder: PAYER,
+                projectId: revnetId,
+                cashOutCount: cashOutCount,
+                tokenToReclaim: JBConstants.NATIVE_TOKEN,
+                minTokensReclaimed: 0,
+                beneficiary: payable(PAYER),
+                metadata: ""
+            });
+
+        // Payer received ETH.
+        assertGt(PAYER.balance, payerEthBefore, "payer should receive ETH");
+        assertEq(PAYER.balance - payerEthBefore, reclaimedAmount, "reclaimed amount should match balance change");
+
+        // Fee project terminal balance increased (2.5% fee on the cashout portion processed by the hook).
+        uint256 feeTerminalAfter = _terminalBalance(FEE_PROJECT_ID, JBConstants.NATIVE_TOKEN);
+        assertGt(feeTerminalAfter, feeTerminalBefore, "fee project should receive fee");
+
+        // Token supply decreased.
+        uint256 totalSupplyAfter = jbTokens().totalSupplyOf(revnetId);
+        assertEq(totalSupplyAfter, totalSupplyBefore - cashOutCount, "total supply should decrease by cashOutCount");
+
+        // Reclaim is less than pro-rata share due to 50% tax rate.
+        uint256 surplus = _terminalBalance(revnetId, JBConstants.NATIVE_TOKEN) + reclaimedAmount
+            + (feeTerminalAfter - feeTerminalBefore);
+        // Pro-rata share = surplus * cashOutCount / totalSupply
+        // With 50% tax, reclaim should be roughly 75% of pro-rata (from bonding curve formula).
+        uint256 proRataShare = (surplus * cashOutCount) / totalSupplyBefore;
+        assertLt(reclaimedAmount, proRataShare, "reclaim should be less than pro-rata due to tax");
+    }
+
+    /// @notice High tax rate (90%) produces small reclaim relative to pro-rata.
+    function test_fork_cashOut_highTaxRate() public onlyFork {
+        // Deploy a separate revnet with 90% tax rate.
+        uint256 highTaxRevnet = _deployRevnet(9000);
+        _setupPool(highTaxRevnet, 10_000 ether);
+        _payRevnet(highTaxRevnet, PAYER, 10 ether);
+        vm.warp(block.timestamp + REV_DEPLOYER.CASH_OUT_DELAY() + 1);
+
+        uint256 payerTokens = jbTokens().totalBalanceOf(PAYER, highTaxRevnet);
+        uint256 cashOutCount = payerTokens / 2;
+
+        vm.prank(PAYER);
+        uint256 reclaimedAmount = jbMultiTerminal()
+            .cashOutTokensOf({
+                holder: PAYER,
+                projectId: highTaxRevnet,
+                cashOutCount: cashOutCount,
+                tokenToReclaim: JBConstants.NATIVE_TOKEN,
+                minTokensReclaimed: 0,
+                beneficiary: payable(PAYER),
+                metadata: ""
+            });
+
+        // With 90% tax rate, reclaim should be very small relative to surplus.
+        uint256 terminalBalance = _terminalBalance(highTaxRevnet, JBConstants.NATIVE_TOKEN);
+        uint256 totalSurplus = terminalBalance + reclaimedAmount;
+        uint256 proRataShare = (totalSurplus * cashOutCount) / payerTokens;
+
+        // At 90% tax rate with 50% of supply, reclaim ~= proRata * (10% + 90% * 0.5) = proRata * 55%.
+        // But also minus 2.5% fee. Should be well under 60% of pro-rata.
+        assertLt(reclaimedAmount, (proRataShare * 60) / 100, "high tax: reclaim should be very small");
+    }
+
+    /// @notice Sucker addresses get full pro-rata reclaim with 0% tax and no fee.
+    function test_fork_cashOut_suckerExempt() public onlyFork {
+        address sucker = makeAddr("sucker");
+        vm.deal(sucker, 100 ether);
+
+        // Pay as sucker to get tokens.
+        _payRevnet(revnetId, sucker, 5 ether);
+
+        uint256 suckerTokens = jbTokens().totalBalanceOf(sucker, revnetId);
+        uint256 totalSupply = jbTokens().totalSupplyOf(revnetId);
+        uint256 surplus = _terminalBalance(revnetId, JBConstants.NATIVE_TOKEN);
+
+        // Mock sucker registry to report this address as a sucker.
+        vm.mockCall(
+            address(SUCKER_REGISTRY),
+            abi.encodeWithSelector(IJBSuckerRegistry.isSuckerOf.selector, revnetId, sucker),
+            abi.encode(true)
+        );
+
+        uint256 feeTerminalBefore = _terminalBalance(FEE_PROJECT_ID, JBConstants.NATIVE_TOKEN);
+
+        vm.prank(sucker);
+        uint256 reclaimedAmount = jbMultiTerminal()
+            .cashOutTokensOf({
+                holder: sucker,
+                projectId: revnetId,
+                cashOutCount: suckerTokens,
+                tokenToReclaim: JBConstants.NATIVE_TOKEN,
+                minTokensReclaimed: 0,
+                beneficiary: payable(sucker),
+                metadata: ""
+            });
+
+        // Full pro-rata reclaim (0% tax).
+        uint256 expectedReclaim = (surplus * suckerTokens) / totalSupply;
+        assertEq(reclaimedAmount, expectedReclaim, "sucker should get full pro-rata reclaim");
+
+        // No fee charged.
+        uint256 feeTerminalAfter = _terminalBalance(FEE_PROJECT_ID, JBConstants.NATIVE_TOKEN);
+        assertEq(feeTerminalAfter, feeTerminalBefore, "no fee should be charged for sucker");
+    }
+
+    /// @notice After a payment with 30% tier split, surplus accounting reflects actual terminal balance.
+    function test_fork_cashOut_afterTierSplitPayment() public onlyFork {
+        // Deploy revnet with 721 hook.
+        (uint256 splitRevnetId, IJB721TiersHook hook) = _deployRevnetWith721(5000);
+        _setupPool(splitRevnetId, 10_000 ether);
+
+        // Pay 1 ETH with tier metadata (triggers 30% split).
+        address metadataTarget = hook.METADATA_ID_TARGET();
+        bytes memory metadata = _buildPayMetadataNoQuote(metadataTarget);
+
+        vm.prank(PAYER);
+        jbMultiTerminal().pay{value: 1 ether}({
+            projectId: splitRevnetId,
+            token: JBConstants.NATIVE_TOKEN,
+            amount: 1 ether,
+            beneficiary: PAYER,
+            minReturnedTokens: 0,
+            memo: "",
+            metadata: metadata
+        });
+
+        // Warp past delay.
+        vm.warp(block.timestamp + REV_DEPLOYER.CASH_OUT_DELAY() + 1);
+
+        uint256 payerTokens = jbTokens().totalBalanceOf(PAYER, splitRevnetId);
+        uint256 terminalBalance = _terminalBalance(splitRevnetId, JBConstants.NATIVE_TOKEN);
+
+        // Terminal balance should be ~1 ETH (0.7 ETH project share + 0.3 ETH returned via addToBalance from 721
+        // hook).
+        assertGt(terminalBalance, 0, "terminal should have balance");
+
+        // Cash out should succeed using actual terminal balance as surplus.
+        if (payerTokens > 0) {
+            vm.prank(PAYER);
+            uint256 reclaimedAmount = jbMultiTerminal()
+                .cashOutTokensOf({
+                    holder: PAYER,
+                    projectId: splitRevnetId,
+                    cashOutCount: payerTokens,
+                    tokenToReclaim: JBConstants.NATIVE_TOKEN,
+                    minTokensReclaimed: 0,
+                    beneficiary: payable(PAYER),
+                    metadata: ""
+                });
+
+            assertGt(reclaimedAmount, 0, "should reclaim some ETH after tier split payment");
+        }
+    }
+
+    /// @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);
+        _setupPool(delayRevnet, 10_000 ether);
+        _payRevnet(delayRevnet, PAYER, 1 ether);
+
+        uint256 payerTokens = jbTokens().totalBalanceOf(PAYER, delayRevnet);
+
+        // Try to cash out immediately (before delay expires) -> should revert.
+        vm.prank(PAYER);
+        vm.expectRevert();
+        jbMultiTerminal()
+            .cashOutTokensOf({
+                holder: PAYER,
+                projectId: delayRevnet,
+                cashOutCount: payerTokens,
+                tokenToReclaim: JBConstants.NATIVE_TOKEN,
+                minTokensReclaimed: 0,
+                beneficiary: payable(PAYER),
+                metadata: ""
+            });
+
+        // Warp past delay.
+        vm.warp(block.timestamp + REV_DEPLOYER.CASH_OUT_DELAY() + 1);
+
+        // Now it should succeed.
+        vm.prank(PAYER);
+        uint256 reclaimedAmount = jbMultiTerminal()
+            .cashOutTokensOf({
+                holder: PAYER,
+                projectId: delayRevnet,
+                cashOutCount: payerTokens,
+                tokenToReclaim: JBConstants.NATIVE_TOKEN,
+                minTokensReclaimed: 0,
+                beneficiary: payable(PAYER),
+                metadata: ""
+            });
+
+        assertGt(reclaimedAmount, 0, "should succeed after delay expires");
+    }
+}

package/test/fork/TestLoanBorrowFork.t.sol

@@ -0,0 +1,163 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.26;
+
+import "./ForkTestBase.sol";
+import {JBFees} from "@bananapus/core-v6/src/libraries/JBFees.sol";
+
+/// @notice Fork tests for REVLoans.borrowFrom() with real Uniswap V4 buyback hook.
+///
+/// Covers: basic borrow, fee distribution, and borrow after tier splits.
+///
+/// Run with: FOUNDRY_PROFILE=fork forge test --match-contract TestLoanBorrowFork -vvv
+contract TestLoanBorrowFork is ForkTestBase {
+    uint256 revnetId;
+
+    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);
+
+        // Set up pool at 1:1 (mint path wins).
+        _setupPool(revnetId, 10_000 ether);
+
+        // Pay to create surplus. PAYER gets tokens and BORROWER gets tokens.
+        _payRevnet(revnetId, PAYER, 10 ether);
+        _payRevnet(revnetId, BORROWER, 5 ether);
+    }
+
+    /// @notice Basic borrow: collateralize all borrower tokens, verify loan state.
+    function test_fork_borrow_basic() public onlyFork {
+        uint256 borrowerTokens = jbTokens().totalBalanceOf(BORROWER, revnetId);
+
+        uint256 borrowable = LOANS_CONTRACT.borrowableAmountFrom(
+            revnetId, borrowerTokens, 18, uint32(uint160(JBConstants.NATIVE_TOKEN))
+        );
+        assertGt(borrowable, 0, "should have borrowable amount");
+
+        uint256 totalCollateralBefore = LOANS_CONTRACT.totalCollateralOf(revnetId);
+        uint256 totalBorrowedBefore =
+            LOANS_CONTRACT.totalBorrowedFrom(revnetId, jbMultiTerminal(), JBConstants.NATIVE_TOKEN);
+
+        uint256 borrowerEthBefore = BORROWER.balance;
+
+        // Create the loan.
+        (uint256 loanId, REVLoan memory loan) =
+            _createLoan(revnetId, BORROWER, borrowerTokens, LOANS_CONTRACT.MIN_PREPAID_FEE_PERCENT());
+
+        // Verify loan state.
+        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 received ETH (net of fees).
+        assertGt(BORROWER.balance, borrowerEthBefore, "borrower should receive ETH");
+
+        // Tracking updated.
+        assertEq(
+            LOANS_CONTRACT.totalCollateralOf(revnetId),
+            totalCollateralBefore + borrowerTokens,
+            "totalCollateralOf should increase"
+        );
+        assertGt(
+            LOANS_CONTRACT.totalBorrowedFrom(revnetId, jbMultiTerminal(), JBConstants.NATIVE_TOKEN),
+            totalBorrowedBefore,
+            "totalBorrowedFrom should increase"
+        );
+
+        // Loan NFT owned by borrower.
+        assertEq(_loanOwnerOf(loanId), BORROWER, "loan NFT should be owned by borrower");
+    }
+
+    /// @notice Verify fee distribution: source fee (2.5%) + REV fee (1%) deducted correctly.
+    function test_fork_borrow_feeDistribution() public onlyFork {
+        uint256 borrowerTokens = jbTokens().totalBalanceOf(BORROWER, revnetId);
+        uint256 prepaidFeePercent = LOANS_CONTRACT.MIN_PREPAID_FEE_PERCENT(); // 25 = 2.5%
+
+        uint256 borrowable = LOANS_CONTRACT.borrowableAmountFrom(
+            revnetId, borrowerTokens, 18, uint32(uint160(JBConstants.NATIVE_TOKEN))
+        );
+
+        // Record balances before.
+        uint256 borrowerEthBefore = BORROWER.balance;
+        uint256 revnetTerminalBefore = _terminalBalance(revnetId, JBConstants.NATIVE_TOKEN);
+
+        _grantBurnPermission(BORROWER, revnetId);
+
+        REVLoanSource memory source = _nativeLoanSource();
+        vm.prank(BORROWER);
+        LOANS_CONTRACT.borrowFrom({
+            revnetId: revnetId,
+            source: source,
+            minBorrowAmount: 0,
+            collateralCount: borrowerTokens,
+            beneficiary: payable(BORROWER),
+            prepaidFeePercent: prepaidFeePercent
+        });
+
+        uint256 borrowerReceived = BORROWER.balance - borrowerEthBefore;
+
+        // Calculate expected fees.
+        // The allowance fee is taken by the terminal's useAllowanceOf (2.5% JB protocol fee).
+        uint256 allowanceFee = JBFees.feeAmountFrom({amountBeforeFee: borrowable, feePercent: jbMultiTerminal().FEE()});
+        // REV fee (1%).
+        uint256 revFee =
+            JBFees.feeAmountFrom({amountBeforeFee: borrowable, feePercent: LOANS_CONTRACT.REV_PREPAID_FEE_PERCENT()});
+        // Source fee (prepaid).
+        uint256 sourceFee = JBFees.feeAmountFrom({amountBeforeFee: borrowable, feePercent: prepaidFeePercent});
+
+        uint256 totalFees = allowanceFee + revFee + sourceFee;
+
+        // Borrower should receive borrowable - totalFees.
+        assertApproxEqAbs(borrowerReceived, borrowable - totalFees, 10, "borrower net should match expected");
+
+        // Loans contract should not hold any ETH.
+        assertEq(address(LOANS_CONTRACT).balance, 0, "loans contract should not hold ETH");
+    }
+
+    /// @notice Borrow after a payment with 30% tier splits.
+    function test_fork_borrow_afterTierSplits() public onlyFork {
+        // Deploy revnet with 721 hook.
+        (uint256 splitRevnetId, IJB721TiersHook hook) = _deployRevnetWith721(5000);
+        _setupPool(splitRevnetId, 10_000 ether);
+
+        // Pay with tier metadata (30% split).
+        address metadataTarget = hook.METADATA_ID_TARGET();
+        bytes memory metadata = _buildPayMetadataNoQuote(metadataTarget);
+
+        vm.prank(BORROWER);
+        uint256 borrowerTokens = jbMultiTerminal().pay{value: 5 ether}({
+            projectId: splitRevnetId,
+            token: JBConstants.NATIVE_TOKEN,
+            amount: 5 ether,
+            beneficiary: BORROWER,
+            minReturnedTokens: 0,
+            memo: "",
+            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");
+
+        // Surplus should reflect actual terminal balance.
+        uint256 surplus = _terminalBalance(splitRevnetId, JBConstants.NATIVE_TOKEN);
+        assertGt(surplus, 0, "should have surplus");
+
+        // Borrowable amount should be based on actual surplus, not full payment.
+        uint256 borrowable = LOANS_CONTRACT.borrowableAmountFrom(
+            splitRevnetId, borrowerTokens, 18, uint32(uint160(JBConstants.NATIVE_TOKEN))
+        );
+
+        if (borrowable > 0) {
+            (uint256 loanId,) =
+                _createLoan(splitRevnetId, BORROWER, borrowerTokens, LOANS_CONTRACT.MIN_PREPAID_FEE_PERCENT());
+            assertGt(loanId, 0, "loan should be created");
+        }
+    }
+}

package/test/fork/TestLoanLiquidationFork.t.sol

@@ -0,0 +1,129 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.26;
+
+import "./ForkTestBase.sol";
+
+/// @notice Fork tests for REVLoans.liquidateExpiredLoansFrom() with real Uniswap V4 buyback hook.
+///
+/// Covers: expired liquidation, non-expired skipping, and gap handling.
+///
+/// Run with: FOUNDRY_PROFILE=fork forge test --match-contract TestLoanLiquidationFork -vvv
+contract TestLoanLiquidationFork is ForkTestBase {
+    uint256 revnetId;
+
+    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, 10 ether);
+    }
+
+    /// @notice Liquidate an expired loan: NFT burned, collateral permanently lost.
+    function test_fork_liquidate_expired() public onlyFork {
+        uint256 borrowerTokens = jbTokens().totalBalanceOf(BORROWER, revnetId);
+        (uint256 loanId,) = _createLoan(revnetId, BORROWER, borrowerTokens, LOANS_CONTRACT.MIN_PREPAID_FEE_PERCENT());
+
+        uint256 totalCollateralBefore = LOANS_CONTRACT.totalCollateralOf(revnetId);
+        uint256 totalBorrowedBefore =
+            LOANS_CONTRACT.totalBorrowedFrom(revnetId, jbMultiTerminal(), JBConstants.NATIVE_TOKEN);
+
+        // Warp past 10 years + 1 second.
+        vm.warp(block.timestamp + LOANS_CONTRACT.LOAN_LIQUIDATION_DURATION() + 1);
+
+        // The loan number is 1 (first loan for this revnet).
+        LOANS_CONTRACT.liquidateExpiredLoansFrom(revnetId, 1, 1);
+
+        // Loan NFT burned.
+        vm.expectRevert();
+        _loanOwnerOf(loanId);
+
+        // Collateral permanently lost (decreased from tracking).
+        assertEq(
+            LOANS_CONTRACT.totalCollateralOf(revnetId),
+            totalCollateralBefore - borrowerTokens,
+            "totalCollateralOf should decrease"
+        );
+
+        // Borrowed amount decreased.
+        assertLt(
+            LOANS_CONTRACT.totalBorrowedFrom(revnetId, jbMultiTerminal(), JBConstants.NATIVE_TOKEN),
+            totalBorrowedBefore,
+            "totalBorrowedFrom should decrease"
+        );
+
+        // No tokens re-minted to borrower.
+        assertEq(jbTokens().totalBalanceOf(BORROWER, revnetId), 0, "no tokens should be re-minted");
+    }
+
+    /// @notice Non-expired loan is skipped during liquidation.
+    function test_fork_liquidate_notExpiredSkipped() public onlyFork {
+        uint256 borrowerTokens = jbTokens().totalBalanceOf(BORROWER, revnetId);
+        (uint256 loanId,) = _createLoan(revnetId, BORROWER, borrowerTokens, LOANS_CONTRACT.MIN_PREPAID_FEE_PERCENT());
+
+        // Don't warp — loan is fresh.
+        LOANS_CONTRACT.liquidateExpiredLoansFrom(revnetId, 1, 1);
+
+        // Loan should still exist.
+        assertEq(_loanOwnerOf(loanId), BORROWER, "loan should still exist");
+    }
+
+    /// @notice Multiple loans with gaps: create 3, repay #2, warp, liquidate range.
+    function test_fork_liquidate_withGaps() public onlyFork {
+        // Create 3 loans from different borrowers.
+        address borrower2 = makeAddr("borrower2");
+        address borrower3 = makeAddr("borrower3");
+        vm.deal(borrower2, 100 ether);
+        vm.deal(borrower3, 100 ether);
+
+        // Give each borrower tokens.
+        _payRevnet(revnetId, borrower2, 3 ether);
+        _payRevnet(revnetId, borrower3, 3 ether);
+
+        uint256 borrowerTokens = jbTokens().totalBalanceOf(BORROWER, revnetId);
+        uint256 b2Tokens = jbTokens().totalBalanceOf(borrower2, revnetId);
+        uint256 b3Tokens = jbTokens().totalBalanceOf(borrower3, revnetId);
+
+        // Create 3 loans.
+        (uint256 loanId1,) = _createLoan(revnetId, BORROWER, borrowerTokens, LOANS_CONTRACT.MIN_PREPAID_FEE_PERCENT());
+        (uint256 loanId2, REVLoan memory loan2) =
+            _createLoan(revnetId, borrower2, b2Tokens, LOANS_CONTRACT.MIN_PREPAID_FEE_PERCENT());
+        (uint256 loanId3,) = _createLoan(revnetId, borrower3, b3Tokens, LOANS_CONTRACT.MIN_PREPAID_FEE_PERCENT());
+
+        // Repay loan #2 to create a gap.
+        vm.deal(borrower2, 100 ether);
+        JBSingleAllowance memory allowance;
+        vm.prank(borrower2);
+        LOANS_CONTRACT.repayLoan{value: loan2.amount * 2}({
+            loanId: loanId2,
+            maxRepayBorrowAmount: loan2.amount * 2,
+            collateralCountToReturn: loan2.collateral,
+            beneficiary: payable(borrower2),
+            allowance: allowance
+        });
+
+        // Warp past 10 years.
+        vm.warp(block.timestamp + LOANS_CONTRACT.LOAN_LIQUIDATION_DURATION() + 1);
+
+        // Liquidate the full range (loans 1-3).
+        LOANS_CONTRACT.liquidateExpiredLoansFrom(revnetId, 1, 3);
+
+        // Loans #1 and #3 should be liquidated. #2 was already repaid (skipped).
+        vm.expectRevert();
+        _loanOwnerOf(loanId1);
+
+        vm.expectRevert();
+        _loanOwnerOf(loanId3);
+
+        // Borrower 2 got their collateral back from repayment.
+        assertGt(jbTokens().totalBalanceOf(borrower2, revnetId), 0, "borrower2 should have tokens from repayment");
+    }
+}

package/test/fork/TestLoanReallocateFork.t.sol

@@ -0,0 +1,103 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.26;
+
+import "./ForkTestBase.sol";
+
+/// @notice Fork tests for REVLoans.reallocateCollateralFromLoan() with real Uniswap V4 buyback hook.
+///
+/// Covers: basic reallocation and source mismatch revert.
+///
+/// Run with: FOUNDRY_PROFILE=fork forge test --match-contract TestLoanReallocateFork -vvv
+contract TestLoanReallocateFork is ForkTestBase {
+    uint256 revnetId;
+
+    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, 10 ether);
+    }
+
+    /// @notice Reallocate half collateral to a new loan: original reduced, new loan created.
+    function test_fork_reallocate_basic() public onlyFork {
+        uint256 borrowerTokens = jbTokens().totalBalanceOf(BORROWER, revnetId);
+        (uint256 loanId, REVLoan memory loan) =
+            _createLoan(revnetId, BORROWER, borrowerTokens, LOANS_CONTRACT.MIN_PREPAID_FEE_PERCENT());
+
+        uint256 halfCollateral = loan.collateral / 2;
+        uint256 totalCollateralBefore = LOANS_CONTRACT.totalCollateralOf(revnetId);
+
+        REVLoanSource memory source = _nativeLoanSource();
+
+        // Grant burn permission again for the new loan's collateral.
+        _grantBurnPermission(BORROWER, revnetId);
+
+        vm.prank(BORROWER);
+        (uint256 reallocatedLoanId, uint256 newLoanId, REVLoan memory reallocatedLoan, REVLoan memory newLoan) = LOANS_CONTRACT.reallocateCollateralFromLoan({
+            loanId: loanId,
+            collateralCountToTransfer: halfCollateral,
+            source: source,
+            minBorrowAmount: 0,
+            collateralCountToAdd: 0,
+            beneficiary: payable(BORROWER),
+            prepaidFeePercent: LOANS_CONTRACT.MIN_PREPAID_FEE_PERCENT()
+        });
+
+        // Original loan reduced.
+        assertEq(
+            reallocatedLoan.collateral,
+            loan.collateral - halfCollateral,
+            "reallocated loan should have reduced collateral"
+        );
+
+        // New loan has the transferred collateral.
+        assertEq(newLoan.collateral, halfCollateral, "new loan should have transferred collateral");
+
+        // Original loan burned, reallocated loan created.
+        vm.expectRevert();
+        _loanOwnerOf(loanId);
+
+        assertEq(_loanOwnerOf(reallocatedLoanId), BORROWER, "reallocated loan owned by borrower");
+        assertEq(_loanOwnerOf(newLoanId), BORROWER, "new loan owned by borrower");
+
+        // Total collateral should remain approximately the same (moved, not destroyed).
+        // It increases by halfCollateral because the new loan's borrowFrom also adds collateral.
+        // But reallocateCollateralFromLoan transfers collateral from the existing loan (not burning new tokens),
+        // so totalCollateralOf should stay the same (the half was already in the system).
+        assertEq(
+            LOANS_CONTRACT.totalCollateralOf(revnetId), totalCollateralBefore, "total collateral should be unchanged"
+        );
+    }
+
+    /// @notice Reallocate with a different source terminal should revert.
+    function test_fork_reallocate_sourceMismatchReverts() public onlyFork {
+        uint256 borrowerTokens = jbTokens().totalBalanceOf(BORROWER, revnetId);
+        (uint256 loanId, REVLoan memory loan) =
+            _createLoan(revnetId, BORROWER, borrowerTokens, LOANS_CONTRACT.MIN_PREPAID_FEE_PERCENT());
+
+        // Create a source with a different terminal address.
+        REVLoanSource memory badSource =
+            REVLoanSource({token: JBConstants.NATIVE_TOKEN, terminal: IJBPayoutTerminal(address(0xdead))});
+
+        vm.prank(BORROWER);
+        vm.expectRevert();
+        LOANS_CONTRACT.reallocateCollateralFromLoan({
+            loanId: loanId,
+            collateralCountToTransfer: loan.collateral / 2,
+            source: badSource,
+            minBorrowAmount: 0,
+            collateralCountToAdd: 0,
+            beneficiary: payable(BORROWER),
+            prepaidFeePercent: LOANS_CONTRACT.MIN_PREPAID_FEE_PERCENT()
+        });
+    }
+}