@rev-net/core-v6 0.0.1

package/test/REVLoansSourced.t.sol

@@ -0,0 +1,1732 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import "forge-std/Test.sol";
+import /* {*} from */ "@bananapus/core-v6/test/helpers/TestBaseWorkflow.sol";
+import /* {*} from "@bananapus/721-hook-v6/src/JB721TiersHookDeployer.sol";
+import /* {*} from */ "./../src/REVDeployer.sol";
+import "@croptop/core-v6/src/CTPublisher.sol";
+import {MockBuybackDataHook} from "./mock/MockBuybackDataHook.sol";
+
+import "@bananapus/core-v6/script/helpers/CoreDeploymentLib.sol";
+import "@bananapus/721-hook-v6/script/helpers/Hook721DeploymentLib.sol";
+import "@bananapus/suckers-v6/script/helpers/SuckerDeploymentLib.sol";
+import "@croptop/core-v6/script/helpers/CroptopDeploymentLib.sol";
+import "@bananapus/swap-terminal-v6/script/helpers/SwapTerminalDeploymentLib.sol";
+
+import {JBConstants} from "@bananapus/core-v6/src/libraries/JBConstants.sol";
+import {JBAccountingContext} from "@bananapus/core-v6/src/structs/JBAccountingContext.sol";
+import {MockPriceFeed} from "@bananapus/core-v6/test/mock/MockPriceFeed.sol";
+import {MockERC20} from "@bananapus/core-v6/test/mock/MockERC20.sol";
+import {REVLoans} from "../src/REVLoans.sol";
+import {REVLoan} from "../src/structs/REVLoan.sol";
+import {REVStageConfig, REVAutoIssuance} from "../src/structs/REVStageConfig.sol";
+import {REVLoanSource} from "../src/structs/REVLoanSource.sol";
+import {REVDescription} from "../src/structs/REVDescription.sol";
+import {IREVLoans} from "./../src/interfaces/IREVLoans.sol";
+import {JBSuckerDeployerConfig} from "@bananapus/suckers-v6/src/structs/JBSuckerDeployerConfig.sol";
+import {JBSuckerRegistry} from "@bananapus/suckers-v6/src/JBSuckerRegistry.sol";
+import {JB721TiersHookDeployer} from "@bananapus/721-hook-v6/src/JB721TiersHookDeployer.sol";
+import {JB721TiersHook} from "@bananapus/721-hook-v6/src/JB721TiersHook.sol";
+import {JB721TiersHookStore} from "@bananapus/721-hook-v6/src/JB721TiersHookStore.sol";
+import {JBAddressRegistry} from "@bananapus/address-registry-v6/src/JBAddressRegistry.sol";
+import {IJBAddressRegistry} from "@bananapus/address-registry-v6/src/interfaces/IJBAddressRegistry.sol";
+
+struct FeeProjectConfig {
+    REVConfig configuration;
+    JBTerminalConfig[] terminalConfigurations;
+    REVSuckerDeploymentConfig suckerDeploymentConfiguration;
+}
+
+contract REVLoansSourcedTests is TestBaseWorkflow, JBTest {
+    /// @notice the salts that are used to deploy the contracts.
+    bytes32 REV_DEPLOYER_SALT = "REVDeployer";
+    bytes32 ERC20_SALT = "REV_TOKEN";
+
+    REVDeployer REV_DEPLOYER;
+    JB721TiersHook EXAMPLE_HOOK;
+
+    /// @notice Deploys tiered ERC-721 hooks for revnets.
+    IJB721TiersHookDeployer HOOK_DEPLOYER;
+    IJB721TiersHookStore HOOK_STORE;
+    IJBAddressRegistry ADDRESS_REGISTRY;
+
+    IREVLoans LOANS_CONTRACT;
+
+    MockERC20 TOKEN;
+
+    /// @notice Deploys and tracks suckers for revnets.
+    IJBSuckerRegistry SUCKER_REGISTRY;
+
+    CTPublisher PUBLISHER;
+    MockBuybackDataHook MOCK_BUYBACK;
+
+    uint256 FEE_PROJECT_ID;
+    uint256 REVNET_ID;
+
+    address USER = makeAddr("user");
+
+    /// @notice The address that is allowed to forward calls.
+    address private constant TRUSTED_FORWARDER = 0xB2b5841DBeF766d4b521221732F9B618fCf34A87;
+
+    function getFeeProjectConfig() internal view returns (FeeProjectConfig memory) {
+        // Define constants
+        string memory name = "Revnet";
+        string memory symbol = "$REV";
+        string memory projectUri = "ipfs://QmNRHT91HcDgMcenebYX7rJigt77cgNcosvuhX21wkF3tx";
+        uint8 decimals = 18;
+        uint256 decimalMultiplier = 10 ** decimals;
+
+        // The tokens that the project accepts and stores.
+        JBAccountingContext[] memory accountingContextsToAccept = new JBAccountingContext[](2);
+
+        // Accept the chain's native currency through the multi terminal.
+        accountingContextsToAccept[0] = JBAccountingContext({
+            token: JBConstants.NATIVE_TOKEN, decimals: 18, currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
+        });
+
+        // For the tests we need to allow these payments, otherwise other revnets can't pay a fee.
+        // IRL, this would be handled by a swap terminal.
+        accountingContextsToAccept[1] =
+            JBAccountingContext({token: address(TOKEN), decimals: 6, currency: uint32(uint160(address(TOKEN)))});
+
+        // The terminals that the project will accept funds through.
+        JBTerminalConfig[] memory terminalConfigurations = new JBTerminalConfig[](1);
+        terminalConfigurations[0] =
+            JBTerminalConfig({terminal: jbMultiTerminal(), accountingContextsToAccept: accountingContextsToAccept});
+
+        // The project's revnet stage configurations.
+        REVStageConfig[] memory stageConfigurations = new REVStageConfig[](3);
+
+        JBSplit[] memory splits = new JBSplit[](1);
+        splits[0].beneficiary = payable(multisig());
+        splits[0].percent = 10_000;
+
+        {
+            REVAutoIssuance[] memory issuanceConfs = new REVAutoIssuance[](1);
+            issuanceConfs[0] = REVAutoIssuance({
+                chainId: uint32(block.chainid), count: uint104(70_000 * decimalMultiplier), beneficiary: multisig()
+            });
+
+            stageConfigurations[0] = REVStageConfig({
+                startsAtOrAfter: uint40(block.timestamp),
+                autoIssuances: issuanceConfs,
+                splitPercent: 2000, // 20%
+                splits: splits,
+                initialIssuance: uint112(1000 * decimalMultiplier),
+                issuanceCutFrequency: 90 days,
+                issuanceCutPercent: JBConstants.MAX_WEIGHT_CUT_PERCENT / 2,
+                cashOutTaxRate: 6000, // 0.6
+                extraMetadata: 0
+            });
+        }
+
+        stageConfigurations[1] = REVStageConfig({
+            startsAtOrAfter: uint40(stageConfigurations[0].startsAtOrAfter + 720 days),
+            autoIssuances: new REVAutoIssuance[](0),
+            splitPercent: 2000, // 20%
+            initialIssuance: 0, // inherit from previous cycle.
+            splits: splits,
+            issuanceCutFrequency: 180 days,
+            issuanceCutPercent: JBConstants.MAX_WEIGHT_CUT_PERCENT / 2,
+            cashOutTaxRate: 1000, // 0.1
+            extraMetadata: 0
+        });
+
+        stageConfigurations[2] = REVStageConfig({
+            startsAtOrAfter: uint40(stageConfigurations[1].startsAtOrAfter + (20 * 365 days)),
+            autoIssuances: new REVAutoIssuance[](0),
+            splitPercent: 0,
+            initialIssuance: 1,
+            splits: splits,
+            issuanceCutFrequency: 0,
+            issuanceCutPercent: 0,
+            cashOutTaxRate: 6000, // 0.6
+            extraMetadata: 0
+        });
+
+        // The project's revnet configuration
+        REVConfig memory revnetConfiguration = REVConfig({
+            description: REVDescription(name, symbol, projectUri, ERC20_SALT),
+            baseCurrency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+            splitOperator: multisig(),
+            stageConfigurations: stageConfigurations
+        });
+
+        return FeeProjectConfig({
+            configuration: revnetConfiguration,
+            terminalConfigurations: terminalConfigurations,
+            suckerDeploymentConfiguration: REVSuckerDeploymentConfig({
+                deployerConfigurations: new JBSuckerDeployerConfig[](0), salt: keccak256(abi.encodePacked("REV"))
+            })
+        });
+    }
+
+    function getSecondProjectConfig() internal view returns (FeeProjectConfig memory) {
+        // Define constants
+        string memory name = "NANA";
+        string memory symbol = "$NANA";
+        string memory projectUri = "ipfs://QmNRHT91HcDgMcenebYX7rJigt77cgNxosvuhX21wkF3tx";
+        uint8 decimals = 18;
+        uint256 decimalMultiplier = 10 ** decimals;
+
+        // The tokens that the project accepts and stores.
+        JBAccountingContext[] memory accountingContextsToAccept = new JBAccountingContext[](2);
+
+        // Accept the chain's native currency through the multi terminal.
+        accountingContextsToAccept[0] = JBAccountingContext({
+            token: JBConstants.NATIVE_TOKEN, decimals: 18, currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
+        });
+
+        accountingContextsToAccept[1] =
+            JBAccountingContext({token: address(TOKEN), decimals: 6, currency: uint32(uint160(address(TOKEN)))});
+
+        // The terminals that the project will accept funds through.
+        JBTerminalConfig[] memory terminalConfigurations = new JBTerminalConfig[](1);
+        terminalConfigurations[0] =
+            JBTerminalConfig({terminal: jbMultiTerminal(), accountingContextsToAccept: accountingContextsToAccept});
+
+        JBSplit[] memory splits = new JBSplit[](1);
+        splits[0].beneficiary = payable(multisig());
+        splits[0].percent = 10_000;
+
+        // The project's revnet stage configurations.
+        REVStageConfig[] memory stageConfigurations = new REVStageConfig[](3);
+
+        {
+            REVAutoIssuance[] memory issuanceConfs = new REVAutoIssuance[](1);
+            issuanceConfs[0] = REVAutoIssuance({
+                chainId: uint32(block.chainid), count: uint104(70_000 * decimalMultiplier), beneficiary: multisig()
+            });
+
+            stageConfigurations[0] = REVStageConfig({
+                startsAtOrAfter: uint40(block.timestamp),
+                autoIssuances: issuanceConfs,
+                splitPercent: 2000, // 20%
+                splits: splits,
+                initialIssuance: uint112(1000 * decimalMultiplier),
+                issuanceCutFrequency: 90 days,
+                issuanceCutPercent: JBConstants.MAX_WEIGHT_CUT_PERCENT / 2,
+                cashOutTaxRate: 0,
+                extraMetadata: 0
+            });
+        }
+
+        stageConfigurations[1] = REVStageConfig({
+            startsAtOrAfter: uint40(stageConfigurations[0].startsAtOrAfter + 720 days),
+            autoIssuances: new REVAutoIssuance[](0),
+            splitPercent: 2000, // 20%
+            splits: splits,
+            initialIssuance: 0, // inherit from previous cycle.
+            issuanceCutFrequency: 180 days,
+            issuanceCutPercent: JBConstants.MAX_WEIGHT_CUT_PERCENT / 2,
+            cashOutTaxRate: 0,
+            extraMetadata: 0
+        });
+
+        stageConfigurations[2] = REVStageConfig({
+            startsAtOrAfter: uint40(stageConfigurations[1].startsAtOrAfter + (20 * 365 days)),
+            autoIssuances: new REVAutoIssuance[](0),
+            splitPercent: 0,
+            splits: splits,
+            initialIssuance: 1, // this is a special number that is as close to max price as we can get.
+            issuanceCutFrequency: 0,
+            issuanceCutPercent: 0,
+            cashOutTaxRate: 0,
+            extraMetadata: 0
+        });
+
+        // The project's revnet configuration
+        REVConfig memory revnetConfiguration = REVConfig({
+            description: REVDescription(name, symbol, projectUri, "NANA_TOKEN"),
+            baseCurrency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+            splitOperator: multisig(),
+            stageConfigurations: stageConfigurations
+        });
+
+        return FeeProjectConfig({
+            configuration: revnetConfiguration,
+            terminalConfigurations: terminalConfigurations,
+            suckerDeploymentConfiguration: REVSuckerDeploymentConfig({
+                deployerConfigurations: new JBSuckerDeployerConfig[](0), salt: keccak256(abi.encodePacked("NANA"))
+            })
+        });
+    }
+
+    function setUp() public override {
+        super.setUp();
+
+        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());
+
+        ADDRESS_REGISTRY = new JBAddressRegistry();
+
+        HOOK_DEPLOYER = new JB721TiersHookDeployer(EXAMPLE_HOOK, HOOK_STORE, ADDRESS_REGISTRY, multisig());
+
+        PUBLISHER = new CTPublisher(jbDirectory(), jbPermissions(), FEE_PROJECT_ID, multisig());
+        MOCK_BUYBACK = new MockBuybackDataHook();
+
+        TOKEN = new MockERC20("1/2 ETH", "1/2");
+
+        // Configure a price feed for ETH/TOKEN.
+        // The token is worth 50% of the price of ETH.
+        MockPriceFeed priceFeed = new MockPriceFeed(1e21, 6);
+        vm.label(address(priceFeed), "Token:Eth/PriceFeed");
+
+        // Configure the price feed for the pair.
+        vm.prank(multisig());
+        jbPrices()
+            .addPriceFeedFor(0, uint32(uint160(address(TOKEN))), uint32(uint160(JBConstants.NATIVE_TOKEN)), priceFeed);
+
+        LOANS_CONTRACT = new REVLoans({
+            controller: jbController(),
+            projects: jbProjects(),
+            revId: FEE_PROJECT_ID,
+            owner: address(this),
+            permit2: permit2(),
+            trustedForwarder: TRUSTED_FORWARDER
+        });
+
+        REV_DEPLOYER = new REVDeployer{salt: REV_DEPLOYER_SALT}(
+            jbController(),
+            SUCKER_REGISTRY,
+            FEE_PROJECT_ID,
+            HOOK_DEPLOYER,
+            PUBLISHER,
+            IJBRulesetDataHook(address(MOCK_BUYBACK)),
+            address(LOANS_CONTRACT),
+            TRUSTED_FORWARDER
+        );
+
+        // Approve the basic deployer to configure the project.
+        vm.prank(address(multisig()));
+        jbProjects().approve(address(REV_DEPLOYER), FEE_PROJECT_ID);
+
+        // Build the config.
+        FeeProjectConfig memory feeProjectConfig = getFeeProjectConfig();
+
+        vm.prank(address(multisig()));
+        // Configure the project.
+        REV_DEPLOYER.deployFor({
+            revnetId: FEE_PROJECT_ID, // Zero to deploy a new revnet
+            configuration: feeProjectConfig.configuration,
+            terminalConfigurations: feeProjectConfig.terminalConfigurations,
+            suckerDeploymentConfiguration: feeProjectConfig.suckerDeploymentConfiguration
+        });
+
+        // Configure second revnet
+        FeeProjectConfig memory fee2Config = getSecondProjectConfig();
+
+        // Configure the project.
+        REVNET_ID = REV_DEPLOYER.deployFor({
+            revnetId: 0, // Zero to deploy a new revnet
+            configuration: fee2Config.configuration,
+            terminalConfigurations: fee2Config.terminalConfigurations,
+            suckerDeploymentConfiguration: fee2Config.suckerDeploymentConfiguration
+        });
+
+        // Give Eth for the user experience
+        vm.deal(USER, 100e18);
+    }
+
+    function test_Borrow_Duration(uint256 payableAmount) public {
+        vm.assume(payableAmount > 0 && payableAmount <= type(uint112).max);
+
+        // Upfront fee plus another month (25 min + 4)
+        uint256 prepaidFee = 29;
+
+        // Calculate the duration based upon the prepaidFee.
+        uint32 duration = uint32(mulDiv(3650 days, prepaidFee, LOANS_CONTRACT.MAX_PREPAID_FEE_PERCENT()));
+
+        // Calculate the duration with a minimum prepaidFee.
+        uint32 minDuration = uint32(mulDiv(3650 days, 25, LOANS_CONTRACT.MAX_PREPAID_FEE_PERCENT()));
+
+        // Deal the user some tokens.
+        deal(address(TOKEN), USER, payableAmount);
+
+        // Approve the terminal to spend the tokens.
+        vm.prank(USER);
+        TOKEN.approve(address(jbMultiTerminal()), payableAmount);
+
+        vm.prank(USER);
+        uint256 tokens = jbMultiTerminal().pay(REVNET_ID, address(TOKEN), payableAmount, USER, 0, "", "");
+
+        uint256 loanable = LOANS_CONTRACT.borrowableAmountFrom(REVNET_ID, tokens, 6, uint32(uint160(address(TOKEN))));
+        // If there is no loanable amount, we can't continue.
+        vm.assume(loanable > 0);
+
+        // User must give the loans contract permission, similar to an "approve" call, we're just spoofing to save time.
+        mockExpect(
+            address(jbPermissions()),
+            abi.encodeCall(IJBPermissions.hasPermission, (address(LOANS_CONTRACT), USER, 2, 11, true, true)),
+            abi.encode(true)
+        );
+
+        REVLoanSource memory sauce = REVLoanSource({token: address(TOKEN), terminal: jbMultiTerminal()});
+
+        vm.prank(USER);
+        (uint256 newLoanId,) = LOANS_CONTRACT.borrowFrom(REVNET_ID, sauce, loanable, tokens, payable(USER), prepaidFee);
+
+        REVLoan memory loan = LOANS_CONTRACT.loanOf(newLoanId);
+        assertEq(loan.amount, loanable);
+        assertEq(loan.collateral, tokens);
+        assertEq(loan.createdAt, block.timestamp);
+        assertEq(loan.prepaidFeePercent, prepaidFee);
+        assertEq(loan.prepaidDuration, duration);
+        assertEq(loan.source.token, address(TOKEN));
+        assertEq(address(loan.source.terminal), address(jbMultiTerminal()));
+
+        // If we remove the minimum prepaid duration, we can see that we're still +- a day.
+        assertApproxEqAbs(loan.prepaidDuration - minDuration, 30 days, 1 days);
+
+        // Looks like its +- 2 days approx with this config.
+        // This is 6 months (25 as prepaidFee + 4 as a month extra prepaid).
+        assertApproxEqAbs(loan.prepaidDuration, 210 days, 2 days);
+    }
+
+    function test_Borrow_Duration_Max(uint256 payableAmount) public {
+        vm.assume(payableAmount > 0 && payableAmount <= type(uint112).max);
+
+        // Upfront fee plus another month
+        uint256 prepaidFee = 500;
+
+        // Calculate the duration based upon the prepaidFee.
+        uint32 duration = uint32(mulDiv(3650 days, prepaidFee, LOANS_CONTRACT.MAX_PREPAID_FEE_PERCENT()));
+
+        // Deal the user some tokens.
+        deal(address(TOKEN), USER, payableAmount);
+
+        // Approve the terminal to spend the tokens.
+        vm.prank(USER);
+        TOKEN.approve(address(jbMultiTerminal()), payableAmount);
+
+        vm.prank(USER);
+        uint256 tokens = jbMultiTerminal().pay(REVNET_ID, address(TOKEN), payableAmount, USER, 0, "", "");
+
+        uint256 loanable = LOANS_CONTRACT.borrowableAmountFrom(REVNET_ID, tokens, 6, uint32(uint160(address(TOKEN))));
+        // If there is no loanable amount, we can't continue.
+        vm.assume(loanable > 0);
+
+        // User must give the loans contract permission, similar to an "approve" call, we're just spoofing to save time.
+        mockExpect(
+            address(jbPermissions()),
+            abi.encodeCall(IJBPermissions.hasPermission, (address(LOANS_CONTRACT), USER, 2, 11, true, true)),
+            abi.encode(true)
+        );
+
+        REVLoanSource memory sauce = REVLoanSource({token: address(TOKEN), terminal: jbMultiTerminal()});
+
+        vm.prank(USER);
+        (uint256 newLoanId,) = LOANS_CONTRACT.borrowFrom(REVNET_ID, sauce, loanable, tokens, payable(USER), prepaidFee);
+
+        REVLoan memory loan = LOANS_CONTRACT.loanOf(newLoanId);
+        assertEq(loan.amount, loanable);
+        assertEq(loan.collateral, tokens);
+        assertEq(loan.createdAt, block.timestamp);
+        assertEq(loan.prepaidFeePercent, prepaidFee);
+        assertEq(loan.prepaidDuration, duration);
+        assertEq(loan.source.token, address(TOKEN));
+        assertEq(address(loan.source.terminal), address(jbMultiTerminal()));
+
+        // Max duration is correct at ten years.
+        assertEq(loan.prepaidDuration, 3650 days);
+    }
+
+    function test_Borrow_Duration_WorstCase_Repay(uint256 payableAmount) public {
+        // Seems like something in our test logic/math is incorrect.
+        _borrowAndRepay(LOANS_CONTRACT.MAX_PREPAID_FEE_PERCENT() - 1, payableAmount, 999);
+    }
+
+    function test_Borrow_Duration_MinPrepaid_MaxDuration_Repay(uint256 payableAmount) public {
+        // We prepay the minimum fee.
+        _borrowAndRepay(LOANS_CONTRACT.MIN_PREPAID_FEE_PERCENT(), payableAmount, 1000);
+    }
+
+    function test_Borrow_Duration_MaxPrepaid_MaxDuration_Repay(uint256 payableAmount) public {
+        // All fees are paid upfront, so there is no additional fee.
+        _borrowAndRepay(LOANS_CONTRACT.MAX_PREPAID_FEE_PERCENT(), payableAmount, 0);
+    }
+
+    function _borrowAndRepay(uint256 prepaidFee, uint256 payableAmount, uint16 expectedFeePercent) internal {
+        vm.assume(payableAmount > 1 gwei && payableAmount <= type(uint96).max);
+        vm.startPrank(USER);
+
+        // Deal the user some tokens.
+        deal(address(TOKEN), USER, payableAmount * 3);
+
+        // Approve the terminal to spend the tokens.
+        TOKEN.approve(address(jbMultiTerminal()), payableAmount);
+
+        uint256 tokens = jbMultiTerminal().pay(REVNET_ID, address(TOKEN), payableAmount, USER, 0, "", "");
+        uint256 loanable = LOANS_CONTRACT.borrowableAmountFrom(REVNET_ID, tokens, 6, uint32(uint160(address(TOKEN))));
+
+        // If there is no loanable amount, we can't continue.
+        vm.assume(loanable > 0);
+
+        // User must give the loans contract permission, similar to an "approve" call, we're just spoofing to save time.
+        mockExpect(
+            address(jbPermissions()),
+            abi.encodeCall(IJBPermissions.hasPermission, (address(LOANS_CONTRACT), USER, 2, 11, true, true)),
+            abi.encode(true)
+        );
+
+        REVLoanSource memory source = REVLoanSource({token: address(TOKEN), terminal: jbMultiTerminal()});
+
+        // Get the balance before we receive the loan.
+        uint256 balanceBeforeLoan = TOKEN.balanceOf(USER);
+
+        // Create the new loan.
+        (uint256 newLoanId,) = LOANS_CONTRACT.borrowFrom(REVNET_ID, source, loanable, tokens, payable(USER), prepaidFee);
+        REVLoan memory loan = LOANS_CONTRACT.loanOf(newLoanId);
+
+        // Check what amount we actually received.
+        uint256 receivedFromLoan = TOKEN.balanceOf(USER) - balanceBeforeLoan;
+
+        // Check that we prepaid the expected percentage.
+        {
+            uint256 otherFees = LOANS_CONTRACT.REV_PREPAID_FEE_PERCENT() + 25; // 25 is jb protocol fee.
+            assertApproxEqAbs(loanable * (1000 - otherFees - prepaidFee) / 1000, receivedFromLoan, 10);
+        }
+
+        // Forward time to right before the loan reaches liquidation.
+        // Use 3650 days - 1 because liquidation triggers at >= LOAN_LIQUIDATION_DURATION.
+        vm.warp(block.timestamp + 3650 days - 1);
+
+        // Repay the loan.
+        uint256 balanceBefore = TOKEN.balanceOf(USER);
+        {
+            JBSingleAllowance memory allowance;
+            TOKEN.approve(address(LOANS_CONTRACT), type(uint256).max);
+            LOANS_CONTRACT.repayLoan(newLoanId, loan.amount * 2, loan.collateral, payable(USER), allowance);
+        }
+
+        // Track what amount we end up paying.
+        uint256 amountPaid = balanceBefore - TOKEN.balanceOf(USER);
+
+        // We expect the fee to be 100% for the min prepaid with the max duration.
+        uint256 expectedFee = (loan.amount * (1000 - prepaidFee) / 1000) * expectedFeePercent / 1000;
+
+        // The fee may deviate 1%.
+        assertApproxEqRel(amountPaid, loan.amount + expectedFee, 0.001 ether);
+
+        vm.stopPrank();
+    }
+
+    function test_Pay_ERC20_Borrow_With_Loan_Source(uint256 payableAmount, uint32 prepaidFee) public {
+        payableAmount = bound(payableAmount, 1e6, type(uint112).max);
+        vm.assume(
+            LOANS_CONTRACT.MIN_PREPAID_FEE_PERCENT() <= prepaidFee
+                && prepaidFee <= LOANS_CONTRACT.MAX_PREPAID_FEE_PERCENT()
+        );
+
+        // Calculate the duration based upon the prepaidFee.
+        uint32 duration = uint32(mulDiv(3650 days, prepaidFee, LOANS_CONTRACT.MAX_PREPAID_FEE_PERCENT()));
+
+        // Deal the user some tokens.
+        deal(address(TOKEN), USER, payableAmount);
+
+        // Approve the terminal to spend the tokens.
+        vm.prank(USER);
+        TOKEN.approve(address(jbMultiTerminal()), payableAmount);
+
+        vm.prank(USER);
+        uint256 tokens = jbMultiTerminal().pay(REVNET_ID, address(TOKEN), payableAmount, USER, 0, "", "");
+
+        uint256 loanable = LOANS_CONTRACT.borrowableAmountFrom(REVNET_ID, tokens, 6, uint32(uint160(address(TOKEN))));
+        // If there is no loanable amount, we can't continue.
+        vm.assume(loanable > 0);
+
+        // User must give the loans contract permission, similar to an "approve" call, we're just spoofing to save time.
+        mockExpect(
+            address(jbPermissions()),
+            abi.encodeCall(IJBPermissions.hasPermission, (address(LOANS_CONTRACT), USER, 2, 11, true, true)),
+            abi.encode(true)
+        );
+
+        REVLoanSource memory sauce = REVLoanSource({token: address(TOKEN), terminal: jbMultiTerminal()});
+
+        vm.prank(USER);
+        (uint256 newLoanId,) = LOANS_CONTRACT.borrowFrom(REVNET_ID, sauce, loanable, tokens, payable(USER), prepaidFee);
+
+        REVLoan memory loan = LOANS_CONTRACT.loanOf(newLoanId);
+        assertEq(loan.amount, loanable);
+        assertEq(loan.collateral, tokens);
+        assertEq(loan.createdAt, block.timestamp);
+        assertEq(loan.prepaidFeePercent, prepaidFee);
+        assertEq(loan.prepaidDuration, duration);
+        assertEq(loan.source.token, address(TOKEN));
+        assertEq(address(loan.source.terminal), address(jbMultiTerminal()));
+
+        // Ensure loans contract isn't hodling
+        assertEq(TOKEN.balanceOf(address(LOANS_CONTRACT)), 0);
+
+        // The fees to be paid to NANA.
+        uint256 allowance_fees = JBFees.feeAmountFrom({amountBeforeFee: loanable, feePercent: jbMultiTerminal().FEE()});
+        // The fees to be paid to REV.
+        uint256 rev_fees =
+            JBFees.feeAmountFrom({amountBeforeFee: loanable, feePercent: LOANS_CONTRACT.REV_PREPAID_FEE_PERCENT()});
+        // The fees to be paid to the Project we are taking a loan from.
+        uint256 source_fees = JBFees.feeAmountFrom({amountBeforeFee: loanable, feePercent: prepaidFee});
+        uint256 fees = allowance_fees + rev_fees + source_fees;
+
+        // Ensure we actually received the token from the borrow
+        // Subtract the fee for REV and for the source revnet.
+        assertEq(TOKEN.balanceOf(address(USER)), loanable - fees);
+    }
+
+    function test_Cashout(
+        bool useNative,
+        uint104 autoIssuance,
+        uint256 totalSupplyExcludingAutoMint,
+        uint256 nativeSurplus,
+        uint256 tokensToCashout,
+        uint16 cashOutTaxRate
+    )
+        public
+    {
+        // Since we don't actually mint the autoIssuance tokens, we don't have to worry about it exceeding the
+        // `SafeSupply`.
+        vm.assume(cashOutTaxRate <= JBConstants.MAX_FEE);
+        vm.assume(totalSupplyExcludingAutoMint > 0 && totalSupplyExcludingAutoMint <= type(uint208).max);
+        vm.assume(nativeSurplus <= type(uint104).max);
+        vm.assume(totalSupplyExcludingAutoMint > tokensToCashout);
+
+        address token = useNative ? JBConstants.NATIVE_TOKEN : address(TOKEN);
+
+        // Deploy a new REVNET, that has multiple stages where the fee decrease.
+        // This lets people refinance their loans to get a better rate.
+        uint256 revnetProjectId;
+        {
+            FeeProjectConfig memory projectConfig = getSecondProjectConfig();
+            REVAutoIssuance[] memory issuanceConfs;
+            issuanceConfs = new REVAutoIssuance[](1);
+            issuanceConfs[0] = REVAutoIssuance({
+                chainId: uint32(block.chainid), count: uint104(autoIssuance), beneficiary: multisig()
+            });
+
+            JBSplit[] memory splits = new JBSplit[](1);
+            splits[0].beneficiary = payable(multisig());
+            splits[0].percent = 10_000;
+
+            REVStageConfig[] memory stageConfigurations = new REVStageConfig[](1);
+            stageConfigurations[0] = REVStageConfig({
+                startsAtOrAfter: uint40(block.timestamp),
+                autoIssuances: issuanceConfs,
+                splitPercent: 2000, // 20%
+                splits: splits,
+                initialIssuance: 1000e18,
+                issuanceCutFrequency: 90 days,
+                issuanceCutPercent: JBConstants.MAX_WEIGHT_CUT_PERCENT / 2,
+                cashOutTaxRate: cashOutTaxRate, // 20%
+                extraMetadata: 0
+            });
+
+            // Replace the configuration.
+            projectConfig.configuration.stageConfigurations = stageConfigurations;
+            projectConfig.configuration.description.salt = "FeeChange";
+
+            revnetProjectId = REV_DEPLOYER.deployFor({
+                revnetId: 0, // Zero to deploy a new revnet
+                configuration: projectConfig.configuration,
+                terminalConfigurations: projectConfig.terminalConfigurations,
+                suckerDeploymentConfiguration: projectConfig.suckerDeploymentConfiguration
+            });
+        }
+
+        // Add the surplus into the project.
+        if (useNative) {
+            vm.deal(USER, nativeSurplus);
+        } else {
+            deal(address(TOKEN), USER, nativeSurplus);
+
+            // Give allowance to spend our tokens.
+            vm.prank(USER);
+            TOKEN.approve(address(jbMultiTerminal()), nativeSurplus);
+        }
+
+        vm.prank(USER);
+        jbMultiTerminal().addToBalanceOf{value: useNative ? nativeSurplus : 0}(
+            revnetProjectId, token, nativeSurplus, false, string(""), bytes("")
+        );
+
+        // Mint the entire supply excluding automint to the user.
+        vm.prank(address(jbController()));
+        jbTokens().mintFor(USER, revnetProjectId, totalSupplyExcludingAutoMint);
+
+        // Check what a borrow would result in more.
+        uint256 loanable = LOANS_CONTRACT.borrowableAmountFrom(
+            revnetProjectId, tokensToCashout, useNative ? 18 : 6, uint32(uint160(token))
+        );
+
+        uint256 fullReclaimableSurplus = jbMultiTerminal().STORE()
+            .currentReclaimableSurplusOf({
+                projectId: revnetProjectId,
+                cashOutCount: tokensToCashout,
+                totalSupply: totalSupplyExcludingAutoMint,
+                surplus: nativeSurplus
+            });
+
+        assertGe(fullReclaimableSurplus, loanable);
+
+        uint256 feeTokenCount =
+            cashOutTaxRate == 0 ? 0 : mulDiv(tokensToCashout, jbMultiTerminal().FEE(), JBConstants.MAX_FEE);
+
+        uint256 reclaimableSurplus = jbMultiTerminal().STORE()
+            .currentReclaimableSurplusOf({
+                projectId: revnetProjectId,
+                cashOutCount: tokensToCashout - feeTokenCount,
+                totalSupply: totalSupplyExcludingAutoMint,
+                surplus: nativeSurplus
+            });
+
+        // In the `revFee` calculation we decrease the `nativeSurplus` by the `reclaimableSurplus`
+        // but due to a `stack too deep` we can't do that there, so we decrease it here.
+        // This is not the correct value for this variable, however in `revFee` is the last time we use this variable.
+        nativeSurplus -= reclaimableSurplus;
+
+        uint256 revFee = jbMultiTerminal().STORE()
+            .currentReclaimableSurplusOf({
+                projectId: revnetProjectId,
+                cashOutCount: feeTokenCount,
+                totalSupply: totalSupplyExcludingAutoMint - (tokensToCashout - feeTokenCount),
+                surplus: nativeSurplus
+            });
+
+        assertGe(fullReclaimableSurplus, mulDiv((reclaimableSurplus + revFee), 995, 1000)); // small marging for curve
+        // rounding.
+
+        uint256 balanceBefore = _balanceOf(token, USER);
+
+        // Ensure that the hook was called.
+        vm.expectCall(address(REV_DEPLOYER), abi.encode(REVDeployer.beforeCashOutRecordedWith.selector));
+
+        // It only adds itself as a `after` cashoutHook if there is a cashout tax rate.
+        if (cashOutTaxRate > 0) {
+            vm.expectCall(address(REV_DEPLOYER), abi.encode(REVDeployer.afterCashOutRecordedWith.selector));
+        }
+
+        // Perform a cashout.
+        vm.prank(USER);
+        jbMultiTerminal().cashOutTokensOf(USER, revnetProjectId, tokensToCashout, token, 0, payable(USER), bytes(""));
+
+        // Make sure the contracts do not accidentally hold any tokens.
+        assertEq(_balanceOf(token, address(REV_DEPLOYER)), 0);
+        assertEq(_balanceOf(token, address(LOANS_CONTRACT)), 0);
+
+        // make sure the user has received tokens.
+        assertGe(_balanceOf(token, USER), balanceBefore);
+
+        uint256 balance = _balanceOf(token, USER) - balanceBefore;
+        uint256 nanaFee = cashOutTaxRate == 0
+            ? 0
+            : JBFees.feeAmountResultingIn({amountAfterFee: balance, feePercent: jbMultiTerminal().FEE()});
+
+        assertApproxEqAbs(balance, reclaimableSurplus - nanaFee, 1);
+
+        assertGe(reclaimableSurplus + revFee, mulDiv(loanable, 97, 100)); // small marging for curve rounding.
+    }
+
+    function test_Pay_Borrow_With_Loan_Source() public {
+        vm.prank(USER);
+        uint256 tokens = jbMultiTerminal().pay{value: 1e18}(REVNET_ID, JBConstants.NATIVE_TOKEN, 1e18, USER, 0, "", "");
+
+        uint256 loanable =
+            LOANS_CONTRACT.borrowableAmountFrom(REVNET_ID, tokens, 18, uint32(uint160(JBConstants.NATIVE_TOKEN)));
+        assertGt(loanable, 0);
+
+        // User must give the loans contract permission, similar to an "approve" call, we're just spoofing to save time.
+        mockExpect(
+            address(jbPermissions()),
+            abi.encodeCall(IJBPermissions.hasPermission, (address(LOANS_CONTRACT), USER, 2, 11, true, true)),
+            abi.encode(true)
+        );
+
+        REVLoanSource memory sauce = REVLoanSource({token: JBConstants.NATIVE_TOKEN, terminal: jbMultiTerminal()});
+
+        // Check the balance of the user before the borrow.
+        uint256 balanceBefore = USER.balance;
+
+        vm.prank(USER);
+        (uint256 newLoanId,) = LOANS_CONTRACT.borrowFrom(REVNET_ID, sauce, loanable, tokens, payable(USER), 500);
+
+        REVLoan memory loan = LOANS_CONTRACT.loanOf(newLoanId);
+        assertEq(loan.amount, loanable);
+        assertEq(loan.collateral, tokens);
+        assertEq(loan.createdAt, block.timestamp);
+        assertEq(loan.prepaidFeePercent, 500);
+        assertEq(loan.prepaidDuration, mulDiv(500, 3650 days, 500));
+        assertEq(loan.source.token, JBConstants.NATIVE_TOKEN);
+        assertEq(address(loan.source.terminal), address(jbMultiTerminal()));
+
+        // Ensure loans contract isn't hodling
+        assertEq(address(LOANS_CONTRACT).balance, 0);
+
+        // Ensure we actually received ETH from the borrow
+        assertGt(USER.balance - balanceBefore, 0);
+    }
+
+    function testFuzz_Pay_Borrow_PayOff_With_Loan_Source(
+        uint256 percentOfCollateralToRemove,
+        uint256 prepaidFeePercent,
+        uint256 daysToWarp
+    )
+        public
+    {
+        ///
+        percentOfCollateralToRemove = bound(percentOfCollateralToRemove, 0, 10_000);
+        prepaidFeePercent = bound(prepaidFeePercent, 25, 500);
+        daysToWarp = bound(daysToWarp, 0, 3649);
+
+        daysToWarp = daysToWarp * 1 days;
+
+        vm.prank(USER);
+        uint256 tokens = jbMultiTerminal().pay{value: 1e18}(REVNET_ID, JBConstants.NATIVE_TOKEN, 1e18, USER, 0, "", "");
+
+        uint256 loanable =
+            LOANS_CONTRACT.borrowableAmountFrom(REVNET_ID, tokens, 18, uint32(uint160(JBConstants.NATIVE_TOKEN)));
+
+        assertGt(loanable, 0);
+
+        // User must give the loans contract permission, similar to an "approve" call, we're just spoofing to save time.
+        mockExpect(
+            address(jbPermissions()),
+            abi.encodeCall(IJBPermissions.hasPermission, (address(LOANS_CONTRACT), USER, 2, 11, true, true)),
+            abi.encode(true)
+        );
+
+        uint256 newLoanId;
+
+        {
+            REVLoanSource memory sauce = REVLoanSource({token: JBConstants.NATIVE_TOKEN, terminal: jbMultiTerminal()});
+
+            vm.prank(USER);
+            (newLoanId,) =
+                LOANS_CONTRACT.borrowFrom(REVNET_ID, sauce, loanable, tokens, payable(USER), prepaidFeePercent);
+        }
+
+        REVLoan memory loan = LOANS_CONTRACT.loanOf(newLoanId);
+
+        assertEq(loan.amount, loanable);
+        assertEq(loan.collateral, tokens);
+        assertEq(loan.createdAt, block.timestamp);
+        assertEq(loan.prepaidFeePercent, prepaidFeePercent);
+        assertEq(loan.prepaidDuration, mulDiv(prepaidFeePercent, 3650 days, 500));
+        assertEq(loan.source.token, JBConstants.NATIVE_TOKEN);
+        assertEq(address(loan.source.terminal), address(jbMultiTerminal()));
+
+        // warp forward
+        vm.warp(block.timestamp + daysToWarp);
+
+        uint256 collateralReturned = mulDiv(loan.collateral, percentOfCollateralToRemove, 10_000);
+
+        uint256 newCollateral = loan.collateral - collateralReturned;
+        uint256 borrowableFromNewCollateral = LOANS_CONTRACT.borrowableAmountFrom(
+            REVNET_ID, newCollateral, 18, uint32(uint160(JBConstants.NATIVE_TOKEN))
+        );
+
+        uint256 amountDiff = borrowableFromNewCollateral > loan.amount ? 0 : loan.amount - borrowableFromNewCollateral;
+
+        // Skip fuzz runs where both repay amount and collateral return are zero (M-27 fix rejects these).
+        vm.assume(amountDiff > 0 || collateralReturned > 0);
+
+        uint256 maxAmountPaidDown = loan.amount;
+
+        // Calculate the fee.
+        {
+            // Keep a reference to the time since the loan was created.
+            uint256 timeSinceLoanCreated = block.timestamp - loan.createdAt;
+
+            // If the loan period has passed the prepaid time frame, take a fee.
+            if (timeSinceLoanCreated > loan.prepaidDuration) {
+                // Calculate the prepaid fee for the amount being paid back.
+                uint256 prepaidAmount =
+                    JBFees.feeAmountFrom({amountBeforeFee: amountDiff, feePercent: loan.prepaidFeePercent});
+
+                // Calculate the fee as a linear proportion given the amount of time that has passed.
+                // sourceFeeAmount = mulDiv(amount, timeSinceLoanCreated, LOAN_LIQUIDATION_DURATION) - prepaidAmount;
+                maxAmountPaidDown += JBFees.feeAmountFrom({
+                    amountBeforeFee: amountDiff - prepaidAmount,
+                    feePercent: mulDiv(timeSinceLoanCreated, JBConstants.MAX_FEE, 3650 days)
+                });
+            }
+        }
+
+        // ensure we have the balance
+        vm.deal(USER, maxAmountPaidDown);
+
+        // empty allowance data
+        JBSingleAllowance memory allowance;
+
+        if (borrowableFromNewCollateral > loan.amount) {
+            vm.expectRevert(
+                abi.encodeWithSelector(
+                    REVLoans.REVLoans_NewBorrowAmountGreaterThanLoanAmount.selector,
+                    borrowableFromNewCollateral,
+                    loan.amount
+                )
+            );
+        }
+
+        // call to pay-down the loan
+        vm.prank(USER);
+        (, REVLoan memory reducedLoan) = LOANS_CONTRACT.repayLoan{value: maxAmountPaidDown}(
+            newLoanId, maxAmountPaidDown, collateralReturned, payable(USER), allowance
+        );
+
+        if (borrowableFromNewCollateral > loan.amount) {
+            // End of the test, its not possible to `repay` a loan with such a small amount that the loan value goes up.
+            // The `collateralReturned` should be increased so the value of the loan goes down.
+            return;
+        }
+
+        assertApproxEqAbs(reducedLoan.amount, loan.amount - amountDiff, 1);
+        assertEq(reducedLoan.collateral, loan.collateral - collateralReturned);
+        assertEq(reducedLoan.createdAt, block.timestamp - daysToWarp);
+        assertEq(reducedLoan.prepaidFeePercent, prepaidFeePercent);
+        assertEq(reducedLoan.prepaidDuration, mulDiv(prepaidFeePercent, 3650 days, 500));
+        assertEq(reducedLoan.source.token, JBConstants.NATIVE_TOKEN);
+        assertEq(address(reducedLoan.source.terminal), address(jbMultiTerminal()));
+    }
+
+    function test_Refinance_Excess_Collateral() public {
+        // peform the auto issuance.
+        REV_DEPLOYER.autoIssueFor(REVNET_ID, block.timestamp, multisig());
+
+        vm.prank(USER);
+        uint256 tokens = jbMultiTerminal().pay{value: 1e18}(REVNET_ID, JBConstants.NATIVE_TOKEN, 1e18, USER, 0, "", "");
+
+        uint256 loanable =
+            LOANS_CONTRACT.borrowableAmountFrom(REVNET_ID, tokens, 18, uint32(uint160(JBConstants.NATIVE_TOKEN)));
+        assertGt(loanable, 0);
+
+        mockExpect(
+            address(jbPermissions()),
+            abi.encodeCall(IJBPermissions.hasPermission, (address(LOANS_CONTRACT), USER, 2, 11, true, true)),
+            abi.encode(true)
+        );
+
+        REVLoanSource memory sauce = REVLoanSource({token: JBConstants.NATIVE_TOKEN, terminal: jbMultiTerminal()});
+
+        vm.prank(USER);
+        (uint256 newLoanId,) = LOANS_CONTRACT.borrowFrom(REVNET_ID, sauce, loanable, tokens, payable(USER), 500);
+
+        REVLoan memory loan = LOANS_CONTRACT.loanOf(newLoanId);
+
+        // Ensure loans contract isn't hodling
+        assertEq(address(LOANS_CONTRACT).balance, 0);
+
+        // Ensure we actually received ETH from the borrow
+        assertGt(USER.balance, 100e18 - 1e18);
+
+        // get the updated loanableFrom the same amount as earlier
+        uint256 loanableSecondStage = LOANS_CONTRACT.borrowableAmountFrom(
+            REVNET_ID, loan.collateral, 18, uint32(uint160(JBConstants.NATIVE_TOKEN))
+        );
+
+        // loanable amount is slightly higher due to fee payment increasing the supply/assets ratio.
+        assertGt(loanableSecondStage, loanable);
+
+        // we should not have to add collateral
+        uint256 collateralToAdd = 0;
+
+        // this should be a 0.5% gain to be reallocated
+        uint256 collateralToTransfer = mulDiv(loan.collateral, 50, 10_000);
+
+        // get the new amount to borrow
+        uint256 newAmount = LOANS_CONTRACT.borrowableAmountFrom(
+            REVNET_ID, collateralToTransfer, 18, uint32(uint160(JBConstants.NATIVE_TOKEN))
+        );
+
+        uint256 userBalanceBefore = USER.balance;
+
+        vm.prank(USER);
+        (,, REVLoan memory adjustedLoan, REVLoan memory newLoan) = LOANS_CONTRACT.reallocateCollateralFromLoan(
+            newLoanId, collateralToTransfer, sauce, newAmount, collateralToAdd, payable(USER), 25
+        );
+
+        uint256 userBalanceAfter = USER.balance;
+
+        // check we received funds period
+        assertGt(userBalanceAfter, userBalanceBefore);
+        // check we received ~newAmount with a 0.1% buffer
+        assertApproxEqRel(userBalanceBefore + newLoan.amount, userBalanceAfter, 1e15);
+
+        // Check the old loan has been adjusted
+        assertEq(adjustedLoan.amount, loan.amount); // Should match the old loan
+        assertEq(adjustedLoan.collateral, loan.collateral - collateralToTransfer); // should be reduced
+        assertEq(adjustedLoan.createdAt, loan.createdAt); // Should match the old loan
+        assertEq(adjustedLoan.prepaidFeePercent, loan.prepaidFeePercent); // Should match the old loan
+        assertEq(adjustedLoan.prepaidDuration, mulDiv(loan.prepaidFeePercent, 3650 days, 500));
+        assertEq(adjustedLoan.source.token, JBConstants.NATIVE_TOKEN);
+        assertEq(address(adjustedLoan.source.terminal), address(jbMultiTerminal()));
+
+        // Check the new loan with the excess from refinancing
+        assertEq(newLoan.amount, newAmount); // Excess from reallocateCollateral
+        assertEq(newLoan.collateral, collateralToTransfer); // Matches the amount transferred
+        assertEq(newLoan.createdAt, block.timestamp);
+        assertEq(newLoan.prepaidFeePercent, 25); // Configured as 25 (min) in reallocateCollateral call
+        assertEq(newLoan.prepaidDuration, mulDiv(25, 3650 days, 500)); // Configured as 25 in reallocateCollateral call
+        assertEq(newLoan.source.token, JBConstants.NATIVE_TOKEN);
+        assertEq(address(newLoan.source.terminal), address(jbMultiTerminal()));
+    }
+
+    function test_Refinance_Not_Enough_Collateral() public {
+        // peform the auto issuance.
+        REV_DEPLOYER.autoIssueFor(REVNET_ID, block.timestamp, multisig());
+
+        vm.prank(USER);
+        uint256 tokens = jbMultiTerminal().pay{value: 1e18}(REVNET_ID, JBConstants.NATIVE_TOKEN, 1e18, USER, 0, "", "");
+
+        uint256 loanable =
+            LOANS_CONTRACT.borrowableAmountFrom(REVNET_ID, tokens, 18, uint32(uint160(JBConstants.NATIVE_TOKEN)));
+        assertGt(loanable, 0);
+
+        mockExpect(
+            address(jbPermissions()),
+            abi.encodeCall(IJBPermissions.hasPermission, (address(LOANS_CONTRACT), USER, 2, 11, true, true)),
+            abi.encode(true)
+        );
+
+        REVLoanSource memory sauce = REVLoanSource({token: JBConstants.NATIVE_TOKEN, terminal: jbMultiTerminal()});
+
+        vm.prank(USER);
+        (uint256 newLoanId,) = LOANS_CONTRACT.borrowFrom(REVNET_ID, sauce, loanable, tokens, payable(USER), 500);
+
+        REVLoan memory loan = LOANS_CONTRACT.loanOf(newLoanId);
+
+        // Ensure loans contract isn't hodling
+        assertEq(address(LOANS_CONTRACT).balance, 0);
+
+        // Ensure we actually received ETH from the borrow
+        assertGt(USER.balance, 100e18 - 1e18);
+
+        // get the updated loanableFrom the same amount as earlier
+        uint256 loanableSecondStage = LOANS_CONTRACT.borrowableAmountFrom(
+            REVNET_ID, loan.collateral, 18, uint32(uint160(JBConstants.NATIVE_TOKEN))
+        );
+
+        // loanable amount is slightly higher due to fee payment increasing the supply/assets ratio.
+        assertGt(loanableSecondStage, loanable);
+
+        // we should not have to add collateral
+        uint256 collateralToAdd = 0;
+
+        // this should be a 0.5% gain to be reallocated
+        uint256 collateralToTransfer = mulDiv(loan.collateral, 50, 10_000);
+
+        // get the new amount to borrow
+        uint256 newAmount = LOANS_CONTRACT.borrowableAmountFrom(
+            REVNET_ID, collateralToTransfer, 18, uint32(uint160(JBConstants.NATIVE_TOKEN))
+        );
+
+        vm.expectRevert(REVLoans.REVLoans_NotEnoughCollateral.selector);
+        vm.prank(USER);
+        LOANS_CONTRACT.reallocateCollateralFromLoan(
+            // collateral exceeds with + 1
+            newLoanId,
+            loan.collateral + 1,
+            sauce,
+            newAmount,
+            collateralToAdd,
+            payable(USER),
+            0
+        );
+    }
+
+    function test_Refinance_Unauthorized() public {
+        // peform the auto issuance.
+        REV_DEPLOYER.autoIssueFor(REVNET_ID, block.timestamp, multisig());
+
+        vm.prank(USER);
+        uint256 tokens = jbMultiTerminal().pay{value: 1e18}(REVNET_ID, JBConstants.NATIVE_TOKEN, 1e18, USER, 0, "", "");
+
+        uint256 loanable =
+            LOANS_CONTRACT.borrowableAmountFrom(REVNET_ID, tokens, 18, uint32(uint160(JBConstants.NATIVE_TOKEN)));
+        assertGt(loanable, 0);
+
+        mockExpect(
+            address(jbPermissions()),
+            abi.encodeCall(IJBPermissions.hasPermission, (address(LOANS_CONTRACT), USER, 2, 11, true, true)),
+            abi.encode(true)
+        );
+
+        REVLoanSource memory sauce = REVLoanSource({token: JBConstants.NATIVE_TOKEN, terminal: jbMultiTerminal()});
+
+        vm.prank(USER);
+        (uint256 newLoanId,) = LOANS_CONTRACT.borrowFrom(REVNET_ID, sauce, loanable, tokens, payable(USER), 500);
+
+        REVLoan memory loan = LOANS_CONTRACT.loanOf(newLoanId);
+
+        // Ensure loans contract isn't hodling
+        assertEq(address(LOANS_CONTRACT).balance, 0);
+
+        // Ensure we actually received ETH from the borrow
+        assertGt(USER.balance, 100e18 - 1e18);
+
+        // get the updated loanableFrom the same amount as earlier
+        uint256 loanableSecondStage = LOANS_CONTRACT.borrowableAmountFrom(
+            REVNET_ID, loan.collateral, 18, uint32(uint160(JBConstants.NATIVE_TOKEN))
+        );
+
+        // loanable amount is slightly higher due to fee payment increasing the supply/assets ratio.
+        assertGt(loanableSecondStage, loanable);
+
+        // we should not have to add collateral
+        uint256 collateralToAdd = 0;
+
+        // this should be a 0.5% gain to be reallocated
+        uint256 collateralToTransfer = mulDiv(loan.collateral, 50, 10_000);
+
+        // get the new amount to borrow
+        uint256 newAmount = LOANS_CONTRACT.borrowableAmountFrom(
+            REVNET_ID, collateralToTransfer, 18, uint32(uint160(JBConstants.NATIVE_TOKEN))
+        );
+
+        address unauthorized = address(1);
+        vm.expectRevert(abi.encodeWithSelector(REVLoans.REVLoans_Unauthorized.selector, unauthorized, USER));
+
+        vm.prank(unauthorized);
+        LOANS_CONTRACT.reallocateCollateralFromLoan(
+            newLoanId, collateralToTransfer, sauce, newAmount, collateralToAdd, payable(USER), 25
+        );
+    }
+
+    function test_BorrowWithFeeConverges() public {
+        vm.skip(true);
+
+        // Config
+        uint256 paymentPerBorrow = 0.2 ether;
+        uint16 cashOutTaxRate = 6000;
+        uint256 premint = 0;
+        uint256 amountPaidBeforeFirstBorrow = 0.5 ether;
+
+        // Deploy a new REVNET, that has multiple stages where the fee decrease.
+        // This lets people refinance their loans to get a better rate.
+        uint256 revnetProjectId;
+        {
+            FeeProjectConfig memory projectConfig = getSecondProjectConfig();
+            REVAutoIssuance[] memory issuanceConfs;
+            if (premint > 0) {
+                issuanceConfs = new REVAutoIssuance[](1);
+                issuanceConfs[0] =
+                    REVAutoIssuance({chainId: uint32(block.chainid), count: uint104(premint), beneficiary: multisig()});
+            }
+
+            JBSplit[] memory splits = new JBSplit[](1);
+            splits[0].beneficiary = payable(multisig());
+            splits[0].percent = 10_000;
+
+            REVStageConfig[] memory stageConfigurations = new REVStageConfig[](1);
+            stageConfigurations[0] = REVStageConfig({
+                startsAtOrAfter: uint40(block.timestamp),
+                autoIssuances: new REVAutoIssuance[](0),
+                splitPercent: 0, // 20%
+                splits: splits,
+                initialIssuance: 1000e18,
+                issuanceCutFrequency: 180 days,
+                issuanceCutPercent: JBConstants.MAX_WEIGHT_CUT_PERCENT / 2,
+                cashOutTaxRate: cashOutTaxRate, // 20%
+                extraMetadata: 0
+            });
+
+            // Replace the configuration.
+            projectConfig.configuration.stageConfigurations = stageConfigurations;
+            projectConfig.configuration.description.salt = "FeeChange";
+
+            revnetProjectId = REV_DEPLOYER.deployFor({
+                revnetId: 0, // Zero to deploy a new revnet
+                configuration: projectConfig.configuration,
+                terminalConfigurations: projectConfig.terminalConfigurations,
+                suckerDeploymentConfiguration: projectConfig.suckerDeploymentConfiguration
+            });
+        }
+
+        if (amountPaidBeforeFirstBorrow > 0) {
+            vm.deal(USER, amountPaidBeforeFirstBorrow);
+
+            jbMultiTerminal().pay{value: amountPaidBeforeFirstBorrow}(
+                revnetProjectId, JBConstants.NATIVE_TOKEN, amountPaidBeforeFirstBorrow, USER, 0, "", ""
+            );
+        }
+
+        // Pay the project, minting us tokens.
+        vm.startPrank(USER);
+
+        {
+            uint8[] memory permissionIds = new uint8[](1);
+            permissionIds[0] = JBPermissionIds.BURN_TOKENS;
+
+            JBPermissionsData memory permissionsData = JBPermissionsData({
+                operator: address(LOANS_CONTRACT), projectId: uint56(revnetProjectId), permissionIds: permissionIds
+            });
+
+            // Give the loans contract permission to our tokens.
+            jbPermissions().setPermissionsFor(address(USER), permissionsData);
+        }
+
+        REVLoanSource memory source = REVLoanSource({token: JBConstants.NATIVE_TOKEN, terminal: jbMultiTerminal()});
+
+        uint256 initialBorrow = 0;
+        uint256 prevBorrow = 0;
+        uint256 i;
+        while (prevBorrow != (paymentPerBorrow * (10_000 - cashOutTaxRate) / 10_000)) {
+            vm.deal(USER, paymentPerBorrow);
+
+            uint256 tokens = jbMultiTerminal().pay{value: paymentPerBorrow}(
+                revnetProjectId, JBConstants.NATIVE_TOKEN, paymentPerBorrow, USER, 0, "", ""
+            );
+
+            (, REVLoan memory loan) = LOANS_CONTRACT.borrowFrom(revnetProjectId, source, 0, tokens, payable(USER), 500);
+
+            if (i == 0) {
+                initialBorrow = loan.amount;
+            }
+
+            console.log("Loan %s: %s", i, loan.amount);
+            prevBorrow = loan.amount;
+            i++;
+        }
+
+        console.log("Initial Borrow: %s", initialBorrow);
+        console.log("Final Borrow: %s", prevBorrow);
+    }
+
+    function test_Refinance_DueTo_FeeChange() public {
+        // Deploy a new REVNET, that has multiple stages where the fee decrease.
+        // This lets people refinance their loans to get a better rate.
+        FeeProjectConfig memory projectConfig = getSecondProjectConfig();
+
+        JBSplit[] memory splits = new JBSplit[](1);
+        splits[0].beneficiary = payable(multisig());
+        splits[0].percent = 10_000;
+
+        REVStageConfig[] memory stageConfigurations = new REVStageConfig[](2);
+        stageConfigurations[0] = REVStageConfig({
+            startsAtOrAfter: uint40(block.timestamp),
+            autoIssuances: new REVAutoIssuance[](0),
+            splitPercent: 2000, // 20%
+            splits: splits,
+            initialIssuance: 1000e18,
+            issuanceCutFrequency: 180 days,
+            issuanceCutPercent: JBConstants.MAX_WEIGHT_CUT_PERCENT / 2,
+            cashOutTaxRate: 2000, // 20%
+            extraMetadata: 0
+        });
+
+        stageConfigurations[1] = REVStageConfig({
+            startsAtOrAfter: uint40(block.timestamp + 720 days),
+            autoIssuances: new REVAutoIssuance[](0),
+            splitPercent: 2000, // 20%
+            splits: splits,
+            initialIssuance: 0, // inherit from previous cycle.
+            issuanceCutFrequency: 180 days,
+            issuanceCutPercent: JBConstants.MAX_WEIGHT_CUT_PERCENT / 2,
+            cashOutTaxRate: 0, // 40%
+            extraMetadata: 0
+        });
+
+        // Replace the configuration.
+        projectConfig.configuration.stageConfigurations = stageConfigurations;
+        projectConfig.configuration.description.salt = "FeeChange";
+
+        uint256 revnetProjectId = REV_DEPLOYER.deployFor({
+            revnetId: 0, // Zero to deploy a new revnet
+            configuration: projectConfig.configuration,
+            terminalConfigurations: projectConfig.terminalConfigurations,
+            suckerDeploymentConfiguration: projectConfig.suckerDeploymentConfiguration
+        });
+
+        vm.startPrank(USER);
+        uint256 tokens =
+            jbMultiTerminal().pay{value: 1e18}(revnetProjectId, JBConstants.NATIVE_TOKEN, 1e18, USER, 0, "", "");
+
+        // Makes it so the borrow is closer to the cashoutTaxRate.
+        // Without this the borrow would be (near) feeless.
+        jbMultiTerminal().pay{value: 99e18}(revnetProjectId, JBConstants.NATIVE_TOKEN, 1e18, USER, 0, "", "");
+
+        uint256 loanable =
+            LOANS_CONTRACT.borrowableAmountFrom(revnetProjectId, tokens, 18, uint32(uint160(JBConstants.NATIVE_TOKEN)));
+        assertGt(loanable, 0);
+
+        mockExpect(
+            address(jbPermissions()),
+            abi.encodeCall(
+                IJBPermissions.hasPermission, (address(LOANS_CONTRACT), USER, revnetProjectId, 11, true, true)
+            ),
+            abi.encode(true)
+        );
+
+        uint256 balanceBefore = USER.balance;
+        REVLoanSource memory source = REVLoanSource({token: JBConstants.NATIVE_TOKEN, terminal: jbMultiTerminal()});
+        (uint256 newLoanId, REVLoan memory loan) =
+            LOANS_CONTRACT.borrowFrom(revnetProjectId, source, loanable, tokens, payable(USER), 500);
+
+        // Ensure loans contract isn't hodling
+        assertEq(address(LOANS_CONTRACT).balance, 0);
+
+        // Ensure we actually received ETH from the borrow
+        uint256 balanceAfterIntitialBorrow = USER.balance;
+        assertGt(balanceAfterIntitialBorrow, balanceBefore);
+
+        // Warp to after the cash out tax rate is lower in the second ruleset.
+        vm.warp(stageConfigurations[1].startsAtOrAfter);
+
+        // get the updated loanableFrom the same amount as earlier
+        uint256 loanableSecondStage = LOANS_CONTRACT.borrowableAmountFrom(
+            revnetProjectId, loan.collateral, 18, uint32(uint160(JBConstants.NATIVE_TOKEN))
+        );
+
+        // loanable amount is (slightly) higher due to fee payment increasing the supply/assets ratio.
+        assertGt(loanableSecondStage, loanable);
+
+        // we should not have to add collateral
+        uint256 collateralToAdd = 0;
+
+        // this should be a .5% gain to be reallocated
+        uint256 collateralToTransfer = mulDiv(loan.collateral, 50, 10_000);
+
+        // get the new amount to borrow
+        uint256 newAmount = LOANS_CONTRACT.borrowableAmountFrom(
+            revnetProjectId, collateralToTransfer, 18, uint32(uint160(JBConstants.NATIVE_TOKEN))
+        );
+
+        LOANS_CONTRACT.reallocateCollateralFromLoan(
+            newLoanId, collateralToTransfer, source, newAmount, collateralToAdd, payable(USER), 25
+        );
+
+        // Since we refinanced we should have received additional funds, as the tokens are now worth more.
+        assertGt(USER.balance, balanceAfterIntitialBorrow);
+    }
+
+    function test_Refinance_Collateral_Required() public {
+        // peform the auto issuance.
+        REV_DEPLOYER.autoIssueFor(REVNET_ID, block.timestamp, multisig());
+
+        vm.prank(USER);
+        uint256 tokens = jbMultiTerminal().pay{value: 1e18}(REVNET_ID, JBConstants.NATIVE_TOKEN, 1e18, USER, 0, "", "");
+
+        uint256 loanable =
+            LOANS_CONTRACT.borrowableAmountFrom(REVNET_ID, tokens, 18, uint32(uint160(JBConstants.NATIVE_TOKEN)));
+        assertGt(loanable, 0);
+
+        mockExpect(
+            address(jbPermissions()),
+            abi.encodeCall(IJBPermissions.hasPermission, (address(LOANS_CONTRACT), USER, 2, 11, true, true)),
+            abi.encode(true)
+        );
+
+        REVLoanSource memory sauce = REVLoanSource({token: JBConstants.NATIVE_TOKEN, terminal: jbMultiTerminal()});
+
+        vm.prank(USER);
+        (uint256 newLoanId,) = LOANS_CONTRACT.borrowFrom(REVNET_ID, sauce, loanable, tokens, payable(USER), 500);
+
+        REVLoan memory loan = LOANS_CONTRACT.loanOf(newLoanId);
+
+        // Ensure loans contract isn't hodling
+        assertEq(address(LOANS_CONTRACT).balance, 0);
+
+        // Ensure we actually received ETH from the borrow
+        assertGt(USER.balance, 100e18 - 1e18);
+
+        // warp to after cash out tax rate is lower in the second ruleset
+        vm.warp(block.timestamp + 721 days);
+
+        // get the updated loanableFrom the same amount as earlier
+        uint256 loanableSecondStage = LOANS_CONTRACT.borrowableAmountFrom(
+            REVNET_ID, loan.collateral, 18, uint32(uint160(JBConstants.NATIVE_TOKEN))
+        );
+
+        // loanable amount is slightly higher due to fee payment increasing the supply/assets ratio.
+        assertGt(loanableSecondStage, loanable);
+
+        // we should not have to add collateral
+        uint256 collateralToAdd = 0;
+
+        // this should be a 0.5% gain to be reallocated
+        uint256 collateralToTransfer = mulDiv(loan.collateral, 50, 10_000);
+
+        // get the new amount to borrow
+        uint256 newAmount = LOANS_CONTRACT.borrowableAmountFrom(
+            REVNET_ID, collateralToTransfer, 18, uint32(uint160(JBConstants.NATIVE_TOKEN))
+        );
+
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                REVLoans.REVLoans_ReallocatingMoreCollateralThanBorrowedAmountAllows.selector, 0, loan.amount
+            )
+        );
+        vm.prank(USER);
+        LOANS_CONTRACT.reallocateCollateralFromLoan(
+            // attempt moving the total collateral
+            newLoanId,
+            loan.collateral,
+            sauce,
+            newAmount,
+            collateralToAdd,
+            payable(USER),
+            0
+        );
+    }
+
+    function testFuzz_Refinance(
+        uint256 payAmount,
+        uint256 collateralPercentToTransfer,
+        uint256 secondPayAmount,
+        uint256 prepaidFeePercent,
+        uint256 daysToWarp
+    )
+        public
+    {
+        payAmount = bound(payAmount, 1e18, 100e18);
+        secondPayAmount = bound(secondPayAmount, 1e18, 10e18);
+        prepaidFeePercent = bound(prepaidFeePercent, 25, 500);
+        daysToWarp = bound(daysToWarp, 0, 3650);
+        daysToWarp = daysToWarp * 1 days;
+        collateralPercentToTransfer = bound(collateralPercentToTransfer, 1, 1000);
+
+        // pay once first to receive tokens for the borrow call
+        vm.prank(USER);
+        uint256 tokens =
+            jbMultiTerminal().pay{value: payAmount}(REVNET_ID, JBConstants.NATIVE_TOKEN, 1e18, USER, 0, "", "");
+
+        uint256 loanable =
+            LOANS_CONTRACT.borrowableAmountFrom(REVNET_ID, tokens, 18, uint32(uint160(JBConstants.NATIVE_TOKEN)));
+        assertGt(loanable, 0);
+
+        // mock call spoofing permissions of REVLoans otherwise called by user before borrow.
+        mockExpect(
+            address(jbPermissions()),
+            abi.encodeCall(IJBPermissions.hasPermission, (address(LOANS_CONTRACT), USER, 2, 11, true, true)),
+            abi.encode(true)
+        );
+
+        REVLoanSource memory sauce = REVLoanSource({token: JBConstants.NATIVE_TOKEN, terminal: jbMultiTerminal()});
+
+        vm.prank(USER);
+        (uint256 newLoanId,) = LOANS_CONTRACT.borrowFrom(REVNET_ID, sauce, loanable, tokens, payable(USER), 500);
+
+        REVLoan memory loan = LOANS_CONTRACT.loanOf(newLoanId);
+
+        // warp to after cash out tax rate is lower in the second ruleset
+        vm.warp(block.timestamp + daysToWarp);
+
+        // pay again to have balance for the refinance
+        uint256 tokens2 =
+            jbMultiTerminal().pay{value: secondPayAmount}(REVNET_ID, JBConstants.NATIVE_TOKEN, 1e18, USER, 0, "", "");
+
+        // bound up to 1% reallocated
+        uint256 collateralToTransfer = mulDiv(loan.collateral, collateralPercentToTransfer, 10_000);
+
+        // get the new amount to borrow
+        uint256 newAmount = LOANS_CONTRACT.borrowableAmountFrom(
+            REVNET_ID, collateralToTransfer + tokens2, 18, uint32(uint160(JBConstants.NATIVE_TOKEN))
+        );
+
+        uint256 reallocatedLoanValue = LOANS_CONTRACT.borrowableAmountFrom(
+            REVNET_ID, loan.collateral - collateralToTransfer, 18, uint32(uint160(JBConstants.NATIVE_TOKEN))
+        );
+
+        if (reallocatedLoanValue < loan.amount) {
+            vm.expectRevert(
+                abi.encodeWithSelector(
+                    REVLoans.REVLoans_ReallocatingMoreCollateralThanBorrowedAmountAllows.selector,
+                    reallocatedLoanValue,
+                    loan.amount
+                )
+            );
+        }
+
+        uint256 userBalanceBefore = USER.balance;
+
+        vm.prank(USER);
+        LOANS_CONTRACT.reallocateCollateralFromLoan(
+            newLoanId, collateralToTransfer, sauce, newAmount, tokens2, payable(USER), 25
+        );
+
+        if (reallocatedLoanValue < loan.amount) {
+            return;
+        }
+
+        uint256 userBalanceAfter = USER.balance;
+
+        // check we received funds period
+        assertGt(userBalanceAfter, userBalanceBefore);
+    }
+
+    function test_loanSourcesOfAndDetermineSourceFeeAmount() external {
+        // it will add the loan source upon first borrow
+        vm.prank(USER);
+        uint256 tokens = jbMultiTerminal().pay{value: 1e18}(REVNET_ID, JBConstants.NATIVE_TOKEN, 1e18, USER, 0, "", "");
+
+        uint256 loanable =
+            LOANS_CONTRACT.borrowableAmountFrom(REVNET_ID, tokens, 18, uint32(uint160(JBConstants.NATIVE_TOKEN)));
+        assertGt(loanable, 0);
+
+        // User must give the loans contract permission, similar to an "approve" call, we're just spoofing to save time.
+        mockExpect(
+            address(jbPermissions()),
+            abi.encodeCall(IJBPermissions.hasPermission, (address(LOANS_CONTRACT), USER, 2, 11, true, true)),
+            abi.encode(true)
+        );
+
+        REVLoanSource memory sauce = REVLoanSource({token: JBConstants.NATIVE_TOKEN, terminal: jbMultiTerminal()});
+
+        // Before a borrow the source does not exist
+        REVLoanSource[] memory sources = LOANS_CONTRACT.loanSourcesOf(REVNET_ID);
+        assertEq(sources.length, 0);
+
+        vm.prank(USER);
+        (, REVLoan memory loan) = LOANS_CONTRACT.borrowFrom(REVNET_ID, sauce, loanable, tokens, payable(USER), 100);
+
+        // Source should exist after a borrow
+        REVLoanSource[] memory sourcesUpdated = LOANS_CONTRACT.loanSourcesOf(REVNET_ID);
+        assertEq(sourcesUpdated.length, 1);
+        assertEq(sourcesUpdated[0].token, JBConstants.NATIVE_TOKEN);
+        assertEq(address(sourcesUpdated[0].terminal), address(jbMultiTerminal()));
+
+        // Check the fee amount after warping forward past the prepaid duration
+        vm.warp(block.timestamp + loan.prepaidDuration + 100 days);
+        uint256 feeAmount = LOANS_CONTRACT.determineSourceFeeAmount(loan, loan.amount);
+        assertGt(feeAmount, 0);
+
+        // Warp further than the loan liquidation duration to revert.
+        vm.warp(block.timestamp + 3650 days);
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                REVLoans.REVLoans_LoanExpired.selector, loan.prepaidDuration + 100 days + 3650 days, 3650 days
+            )
+        );
+
+        LOANS_CONTRACT.determineSourceFeeAmount(loan, loan.amount);
+    }
+
+    function test_InvalidPrepaidFeePercent(uint16 feePercentage) external {
+        vm.assume(
+            feePercentage < LOANS_CONTRACT.MIN_PREPAID_FEE_PERCENT()
+                || feePercentage > LOANS_CONTRACT.MAX_PREPAID_FEE_PERCENT()
+        );
+
+        vm.prank(USER);
+        uint256 tokens = jbMultiTerminal().pay{value: 1e18}(REVNET_ID, JBConstants.NATIVE_TOKEN, 1e18, USER, 0, "", "");
+
+        uint256 loanable =
+            LOANS_CONTRACT.borrowableAmountFrom(REVNET_ID, tokens, 18, uint32(uint160(JBConstants.NATIVE_TOKEN)));
+        assertGt(loanable, 0);
+
+        REVLoanSource memory sauce = REVLoanSource({token: JBConstants.NATIVE_TOKEN, terminal: jbMultiTerminal()});
+
+        vm.prank(USER);
+        vm.expectRevert(
+            abi.encodeWithSelector(REVLoans.REVLoans_InvalidPrepaidFeePercent.selector, feePercentage, 25, 500)
+        );
+        LOANS_CONTRACT.borrowFrom(REVNET_ID, sauce, 1, tokens, payable(USER), feePercentage);
+    }
+
+    function test_liquidateLoans() external {
+        vm.prank(USER);
+        uint256 tokens = jbMultiTerminal().pay{value: 1e18}(REVNET_ID, JBConstants.NATIVE_TOKEN, 1e18, USER, 0, "", "");
+
+        uint256 loanable =
+            LOANS_CONTRACT.borrowableAmountFrom(REVNET_ID, tokens, 18, uint32(uint160(JBConstants.NATIVE_TOKEN)));
+        assertGt(loanable, 0);
+
+        // User must give the loans contract permission, similar to an "approve" call, we're just spoofing to save time.
+        mockExpect(
+            address(jbPermissions()),
+            abi.encodeCall(IJBPermissions.hasPermission, (address(LOANS_CONTRACT), USER, 2, 11, true, true)),
+            abi.encode(true)
+        );
+
+        REVLoanSource memory sauce = REVLoanSource({token: JBConstants.NATIVE_TOKEN, terminal: jbMultiTerminal()});
+
+        vm.prank(USER);
+        (uint256 loanId, REVLoan memory loan) =
+            LOANS_CONTRACT.borrowFrom(REVNET_ID, sauce, loanable, tokens, payable(USER), 100);
+
+        // Take out another loan
+        vm.prank(USER);
+        uint256 tokens2 = jbMultiTerminal().pay{value: 2e18}(REVNET_ID, JBConstants.NATIVE_TOKEN, 1e18, USER, 0, "", "");
+
+        uint256 loanable2 =
+            LOANS_CONTRACT.borrowableAmountFrom(REVNET_ID, tokens, 18, uint32(uint160(JBConstants.NATIVE_TOKEN)));
+
+        // User must give the loans contract permission, similar to an "approve" call, we're just spoofing to save time.
+        mockExpect(
+            address(jbPermissions()),
+            abi.encodeCall(IJBPermissions.hasPermission, (address(LOANS_CONTRACT), USER, 2, 11, true, true)),
+            abi.encode(true)
+        );
+
+        vm.prank(USER);
+        (uint256 loanId2, REVLoan memory loan2) =
+            LOANS_CONTRACT.borrowFrom(REVNET_ID, sauce, loanable2, tokens2, payable(USER), 50);
+
+        // Warp further than the loan liquidation duration.
+        vm.warp(block.timestamp + 10_000 days);
+
+        // Check topics one and two
+        vm.expectEmit(true, true, false, false);
+        emit IREVLoans.Liquidate(loanId, REVNET_ID, loan, address(0));
+
+        // Check for the second liquidation
+        // Check topics one and two
+        vm.expectEmit(true, true, false, false);
+        emit IREVLoans.Liquidate(loanId2, REVNET_ID, loan2, address(0));
+        LOANS_CONTRACT.liquidateExpiredLoansFrom(REVNET_ID, 1, 2);
+
+        // Call again to trigger the first break (loan.createdAt = 0)
+        LOANS_CONTRACT.liquidateExpiredLoansFrom(REVNET_ID, 1, 2);
+    }
+
+    function test_liquidationRevertsContinued() external {
+        vm.prank(USER);
+        uint256 tokens = jbMultiTerminal().pay{value: 1e18}(REVNET_ID, JBConstants.NATIVE_TOKEN, 1e18, USER, 0, "", "");
+
+        uint256 loanable =
+            LOANS_CONTRACT.borrowableAmountFrom(REVNET_ID, tokens, 18, uint32(uint160(JBConstants.NATIVE_TOKEN)));
+        assertGt(loanable, 0);
+
+        // User must give the loans contract permission, similar to an "approve" call, we're just spoofing to save time.
+        mockExpect(
+            address(jbPermissions()),
+            abi.encodeCall(IJBPermissions.hasPermission, (address(LOANS_CONTRACT), USER, 2, 11, true, true)),
+            abi.encode(true)
+        );
+
+        REVLoanSource memory sauce = REVLoanSource({token: JBConstants.NATIVE_TOKEN, terminal: jbMultiTerminal()});
+
+        vm.prank(USER);
+        (uint256 loanId, REVLoan memory loan) =
+            LOANS_CONTRACT.borrowFrom(REVNET_ID, sauce, loanable, tokens, payable(USER), 100);
+
+        // Attempt to liquidate before the loan is expired and loop will break
+        LOANS_CONTRACT.liquidateExpiredLoansFrom(REVNET_ID, 0, 2);
+
+        // Repay the loan, adjusting the previous loan.
+        uint256 collateralReturned = mulDiv(loan.collateral, 1000, 10_000);
+
+        uint256 newCollateral = loan.collateral - collateralReturned;
+        uint256 borrowableFromNewCollateral = LOANS_CONTRACT.borrowableAmountFrom(
+            REVNET_ID, newCollateral, 18, uint32(uint160(JBConstants.NATIVE_TOKEN))
+        );
+
+        // Needed for edge case seeds like 17721, 11407, 334
+        if (borrowableFromNewCollateral > 0) borrowableFromNewCollateral -= 1;
+
+        uint256 amountDiff = borrowableFromNewCollateral > loan.amount ? 0 : loan.amount - borrowableFromNewCollateral;
+
+        uint256 amountPaidDown = amountDiff;
+
+        // Calculate the fee.
+        {
+            // Keep a reference to the time since the loan was created.
+            uint256 timeSinceLoanCreated = block.timestamp - loan.createdAt;
+
+            // If the loan period has passed the prepaid time frame, take a fee.
+            if (timeSinceLoanCreated > loan.prepaidDuration) {
+                // Calculate the prepaid fee for the amount being paid back.
+                uint256 prepaidAmount =
+                    JBFees.feeAmountFrom({amountBeforeFee: amountDiff, feePercent: loan.prepaidFeePercent});
+
+                // Calculate the fee as a linear proportion given the amount of time that has passed.
+                // sourceFeeAmount = mulDiv(amount, timeSinceLoanCreated, LOAN_LIQUIDATION_DURATION) - prepaidAmount;
+                amountPaidDown += JBFees.feeAmountFrom({
+                    amountBeforeFee: amountDiff - prepaidAmount,
+                    feePercent: mulDiv(timeSinceLoanCreated, JBConstants.MAX_FEE, 3650 days)
+                });
+            }
+        }
+
+        // ensure we have the balance
+        vm.deal(USER, amountPaidDown);
+
+        // empty allowance data
+        JBSingleAllowance memory allowance;
+
+        // call to pay-down the loan
+        vm.prank(USER);
+        LOANS_CONTRACT.repayLoan{value: amountPaidDown}(
+            loanId, amountPaidDown, collateralReturned, payable(USER), allowance
+        );
+
+        LOANS_CONTRACT.liquidateExpiredLoansFrom(REVNET_ID, 0, 2);
+    }
+
+    function test_repay_unauthorized() external {
+        vm.prank(USER);
+        uint256 tokens = jbMultiTerminal().pay{value: 1e18}(REVNET_ID, JBConstants.NATIVE_TOKEN, 1e18, USER, 0, "", "");
+
+        uint256 loanable =
+            LOANS_CONTRACT.borrowableAmountFrom(REVNET_ID, tokens, 18, uint32(uint160(JBConstants.NATIVE_TOKEN)));
+        assertGt(loanable, 0);
+
+        // User must give the loans contract permission, similar to an "approve" call, we're just spoofing to save time.
+        mockExpect(
+            address(jbPermissions()),
+            abi.encodeCall(IJBPermissions.hasPermission, (address(LOANS_CONTRACT), USER, 2, 11, true, true)),
+            abi.encode(true)
+        );
+
+        REVLoanSource memory sauce = REVLoanSource({token: JBConstants.NATIVE_TOKEN, terminal: jbMultiTerminal()});
+
+        vm.prank(USER);
+        (uint256 loanId,) = LOANS_CONTRACT.borrowFrom(REVNET_ID, sauce, loanable, tokens, payable(USER), 100);
+
+        // empty allowance data
+        JBSingleAllowance memory allowance;
+
+        // call to pay-down the loan
+        /* vm.prank(USER); */
+        vm.expectRevert(abi.encodeWithSelector(REVLoans.REVLoans_Unauthorized.selector, address(this), USER));
+        LOANS_CONTRACT.repayLoan{value: 0}(loanId, 0, 0, payable(USER), allowance);
+    }
+
+    function test_repay_return_invalid_collateral() external {
+        vm.prank(USER);
+        uint256 tokens = jbMultiTerminal().pay{value: 1e18}(REVNET_ID, JBConstants.NATIVE_TOKEN, 1e18, USER, 0, "", "");
+
+        uint256 loanable =
+            LOANS_CONTRACT.borrowableAmountFrom(REVNET_ID, tokens, 18, uint32(uint160(JBConstants.NATIVE_TOKEN)));
+        assertGt(loanable, 0);
+
+        // User must give the loans contract permission, similar to an "approve" call, we're just spoofing to save time.
+        mockExpect(
+            address(jbPermissions()),
+            abi.encodeCall(IJBPermissions.hasPermission, (address(LOANS_CONTRACT), USER, 2, 11, true, true)),
+            abi.encode(true)
+        );
+
+        REVLoanSource memory sauce = REVLoanSource({token: JBConstants.NATIVE_TOKEN, terminal: jbMultiTerminal()});
+
+        vm.prank(USER);
+        (uint256 loanId, REVLoan memory loan) =
+            LOANS_CONTRACT.borrowFrom(REVNET_ID, sauce, loanable, tokens, payable(USER), 100);
+
+        // empty allowance data
+        JBSingleAllowance memory allowance;
+
+        // call to pay-down the loan
+        vm.prank(USER);
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                REVLoans.REVLoans_CollateralExceedsLoan.selector, loan.collateral + 1, loan.collateral
+            )
+        );
+        LOANS_CONTRACT.repayLoan{value: 0}( // collateral exceeds with + 1
+            loanId, 0, loan.collateral + 1, payable(USER), allowance
+        );
+    }
+
+    function _balanceOf(address token, address user) internal view returns (uint256) {
+        if (token == JBConstants.NATIVE_TOKEN) {
+            return user.balance;
+        }
+
+        return IERC20(token).balanceOf(user);
+    }
+}