@rev-net/core-v6 0.0.57 → 0.0.61

package/src/REVOwner.sol

@@ -26,7 +26,6 @@ import {mulDiv} from "@prb/math/src/Common.sol";
 
 import {IREVDeployer} from "./interfaces/IREVDeployer.sol";
 import {IREVLoans} from "./interfaces/IREVLoans.sol";
-import {REVLoanSource} from "./structs/REVLoanSource.sol";
 
 /// @notice The runtime hook for all revnets — set as every revnet's `dataHook` in ruleset metadata. At pay time, it
 /// coordinates the 721 hook (NFT tier minting) with the buyback hook (secondary market swap routing) and scales weight
@@ -45,6 +44,8 @@ contract REVOwner is IJBRulesetDataHook, IJBCashOutHook, IJBPeerChainAdjustedAcc
 
     error REVOwner_AlreadyInitialized(address deployer);
     error REVOwner_CashOutDelayNotFinished(uint256 cashOutDelay, uint256 blockTimestamp);
+    error REVOwner_InvalidLoanSourceToken(uint256 revnetId, address token);
+    error REVOwner_NativeFeeValueMismatch(uint256 expected, uint256 actual);
     error REVOwner_Unauthorized(address caller, address expectedCaller);
 
     //*********************************************************************//
@@ -81,7 +82,7 @@ contract REVOwner is IJBRulesetDataHook, IJBCashOutHook, IJBPeerChainAdjustedAcc
 
     /// @notice The deployer that manages revnet state.
     /// @dev Set once via `setDeployer()` using the precomputed canonical REVDeployer address.
-    IREVDeployer public DEPLOYER;
+    IREVDeployer public deployer;
 
     //*********************************************************************//
     // -------------------- private stored properties -------------------- //
@@ -99,7 +100,7 @@ contract REVOwner is IJBRulesetDataHook, IJBCashOutHook, IJBPeerChainAdjustedAcc
     /// @param feeRevnetId The Juicebox project ID of the fee revnet.
     /// @param suckerRegistry The sucker registry.
     /// @param loans The loan contract.
-    /// @param deployer The account allowed to bind the canonical deployer via `setDeployer`. Passed explicitly
+    /// @param deployerAddress The account allowed to bind the canonical deployer via `setDeployer`. Passed explicitly
     /// because CREATE2 deployments set `msg.sender` to the factory, not the intended operator.
     constructor(
         IJBBuybackHookRegistry buybackHook,
@@ -107,14 +108,14 @@ contract REVOwner is IJBRulesetDataHook, IJBCashOutHook, IJBPeerChainAdjustedAcc
         uint256 feeRevnetId,
         IJBSuckerRegistry suckerRegistry,
         IREVLoans loans,
-        address deployer
+        address deployerAddress
     ) {
         BUYBACK_HOOK = buybackHook;
         DIRECTORY = directory;
         FEE_REVNET_ID = feeRevnetId;
         SUCKER_REGISTRY = suckerRegistry;
         LOANS = loans;
-        _DEPLOYER = deployer;
+        _DEPLOYER = deployerAddress;
     }
 
     //*********************************************************************//
@@ -153,17 +154,17 @@ contract REVOwner is IJBRulesetDataHook, IJBCashOutHook, IJBPeerChainAdjustedAcc
             revnetId: context.projectId, decimals: context.surplus.decimals, currency: context.surplus.currency
         });
 
+        // Start with local supply and surplus (including collateral and borrowed amounts).
+        totalSupply = context.totalSupply + totalCollateral;
+        effectiveSurplusValue = context.surplus.value + totalBorrowed;
+
         // If the cash out is from a sucker, return the full cash out amount without taxes or fees.
+        // Sucker cash-outs are the bridge accounting path: the value moving out of this chain must stay proportional
+        // to this chain's local backing. Do not add remote supply/surplus here, even for unscoped revnets.
         // This relies on the sucker registry to only contain trusted sucker contracts deployed via
         // the registry's own deploySuckersFor flow — external addresses cannot register as suckers.
         if (_isSuckerOf({revnetId: context.projectId, addr: context.holder})) {
-            return (
-                0,
-                context.cashOutCount,
-                context.totalSupply + totalCollateral,
-                context.surplus.value + totalBorrowed,
-                hookSpecifications
-            );
+            return (0, context.cashOutCount, totalSupply, effectiveSurplusValue, hookSpecifications);
         }
 
         // Keep a reference to the cash out delay of the revnet.
@@ -178,10 +179,6 @@ contract REVOwner is IJBRulesetDataHook, IJBCashOutHook, IJBPeerChainAdjustedAcc
         // Get the terminal that will receive the cash out fee.
         IJBTerminal feeTerminal = DIRECTORY.primaryTerminalOf({projectId: FEE_REVNET_ID, token: context.surplus.token});
 
-        // Start with local supply and surplus (including collateral and borrowed amounts).
-        totalSupply = context.totalSupply + totalCollateral;
-        effectiveSurplusValue = context.surplus.value + totalBorrowed;
-
         // If the ruleset aggregates cross-chain state, add remote supply and surplus.
         if (!context.scopeCashOutsToLocalBalances) {
             totalSupply += SUCKER_REGISTRY.remoteTotalSupplyOf(context.projectId);
@@ -452,8 +449,16 @@ contract REVOwner is IJBRulesetDataHook, IJBCashOutHook, IJBPeerChainAdjustedAcc
         // No caller validation needed — this hook only pays fees to the fee project using funds forwarded by the
         // caller. A non-terminal caller would just be donating their own funds as fees. There's nothing to exploit.
 
-        // If there's sufficient approval, transfer normally.
-        if (context.forwardedAmount.token != JBConstants.NATIVE_TOKEN) {
+        if (context.forwardedAmount.token == JBConstants.NATIVE_TOKEN) {
+            // Native fee processing must be value-balanced by the current call. Otherwise a non-terminal caller could
+            // spend ETH that was forcibly sent or accidentally stranded in this hook.
+            if (msg.value != context.forwardedAmount.value) {
+                revert REVOwner_NativeFeeValueMismatch({expected: context.forwardedAmount.value, actual: msg.value});
+            }
+        } else {
+            if (msg.value != 0) revert REVOwner_NativeFeeValueMismatch({expected: 0, actual: msg.value});
+
+            // If there's sufficient approval, transfer normally.
             IERC20(context.forwardedAmount.token)
                 .safeTransferFrom({from: msg.sender, to: address(this), value: context.forwardedAmount.value});
         }
@@ -504,29 +509,29 @@ contract REVOwner is IJBRulesetDataHook, IJBCashOutHook, IJBPeerChainAdjustedAcc
         }
     }
 
+    /// @notice Store the cash out delay for a revnet.
+    /// @dev Only callable by the deployer.
+    /// @param revnetId The ID of the revnet.
+    /// @param cashOutDelay The timestamp after which cash outs are allowed.
+    function setCashOutDelayOf(uint256 revnetId, uint256 cashOutDelay) external {
+        if (msg.sender != address(deployer)) {
+            revert REVOwner_Unauthorized({caller: msg.sender, expectedCaller: address(deployer)});
+        }
+        cashOutDelayOf[revnetId] = cashOutDelay;
+    }
+
     /// @notice Bind the canonical deployer address exactly once.
     /// @dev The deployer address is precomputed and supplied by the account that created this REVOwner instance.
     /// Only that deploy-time binder may call this, which avoids an ambient public initializer where any first caller
     /// could seize the deployer role before the deterministic REVDeployer is actually deployed.
-    /// @param deployer The canonical REVDeployer instance that will manage revnet runtime state.
-    function setDeployer(IREVDeployer deployer) external {
+    /// @param newDeployer The canonical REVDeployer instance that will manage revnet runtime state.
+    function setDeployer(IREVDeployer newDeployer) external {
         // Only the account that deployed this REVOwner may complete the one-time deployer binding.
         if (msg.sender != _DEPLOYER) revert REVOwner_Unauthorized({caller: msg.sender, expectedCaller: _DEPLOYER});
         // Prevent the deployer binding from being overwritten after initialization.
-        if (address(DEPLOYER) != address(0)) revert REVOwner_AlreadyInitialized({deployer: address(DEPLOYER)});
+        if (address(deployer) != address(0)) revert REVOwner_AlreadyInitialized({deployer: address(deployer)});
         // Store the canonical REVDeployer that is authorized to manage runtime hook state.
-        DEPLOYER = deployer;
-    }
-
-    /// @notice Store the cash out delay for a revnet.
-    /// @dev Only callable by the deployer.
-    /// @param revnetId The ID of the revnet.
-    /// @param cashOutDelay The timestamp after which cash outs are allowed.
-    function setCashOutDelayOf(uint256 revnetId, uint256 cashOutDelay) external {
-        if (msg.sender != address(DEPLOYER)) {
-            revert REVOwner_Unauthorized({caller: msg.sender, expectedCaller: address(DEPLOYER)});
-        }
-        cashOutDelayOf[revnetId] = cashOutDelay;
+        deployer = newDeployer;
     }
 
     /// @notice Store the tiered ERC-721 hook for a revnet.
@@ -534,8 +539,8 @@ contract REVOwner is IJBRulesetDataHook, IJBCashOutHook, IJBPeerChainAdjustedAcc
     /// @param revnetId The ID of the revnet.
     /// @param hook The tiered ERC-721 hook.
     function setTiered721HookOf(uint256 revnetId, IJB721TiersHook hook) external {
-        if (msg.sender != address(DEPLOYER)) {
-            revert REVOwner_Unauthorized({caller: msg.sender, expectedCaller: address(DEPLOYER)});
+        if (msg.sender != address(deployer)) {
+            revert REVOwner_Unauthorized({caller: msg.sender, expectedCaller: address(deployer)});
         }
         tiered721HookOf[revnetId] = hook;
     }
@@ -587,38 +592,41 @@ contract REVOwner is IJBRulesetDataHook, IJBCashOutHook, IJBPeerChainAdjustedAcc
 
         collateralCount = loans.totalCollateralOf(revnetId);
 
-        REVLoanSource[] memory sources = loans.loanSourcesOf(revnetId);
-        // Loan sources are project configuration, and this read-only aggregation needs the latest terminal/pricing
-        // state for each configured source.
+        address[] memory sources = loans.loanSourceTokensOf(revnetId);
+        if (sources.length == 0) return (0, collateralCount);
+
+        IJBTerminal multiTerminal = deployer.MULTI_TERMINAL();
+        // Loan sources are tokens whose accounting contexts live on the canonical multi terminal.
         for (uint256 i; i < sources.length; i++) {
-            REVLoanSource memory source = sources[i];
+            address sourceToken = sources[i];
             // Each configured source must be queried live so cash-out math includes current outstanding debt.
-            uint256 tokensLoaned =
-                loans.totalBorrowedFrom({revnetId: revnetId, terminal: source.terminal, token: source.token});
+            uint256 tokensLoaned = loans.totalBorrowedFrom({revnetId: revnetId, token: sourceToken});
             if (tokensLoaned == 0) continue;
 
-            // Read the source token's accounting context so debt can be normalized before cross-currency conversion.
-            JBAccountingContext memory accountingContext =
-                source.terminal.accountingContextForTokenOf({projectId: revnetId, token: source.token});
+            JBAccountingContext memory sourceContext =
+                multiTerminal.accountingContextForTokenOf({projectId: revnetId, token: sourceToken});
+            if (sourceContext.token != sourceToken) {
+                revert REVOwner_InvalidLoanSourceToken({revnetId: revnetId, token: sourceToken});
+            }
 
             // Normalize each source from its native token decimals into the caller's requested decimals.
             uint256 normalizedTokens;
-            if (accountingContext.decimals > decimals) {
-                normalizedTokens = tokensLoaned / (10 ** (accountingContext.decimals - decimals));
-            } else if (accountingContext.decimals < decimals) {
-                normalizedTokens = tokensLoaned * (10 ** (decimals - accountingContext.decimals));
+            if (sourceContext.decimals > decimals) {
+                normalizedTokens = tokensLoaned / (10 ** (sourceContext.decimals - decimals));
+            } else if (sourceContext.decimals < decimals) {
+                normalizedTokens = tokensLoaned * (10 ** (decimals - sourceContext.decimals));
             } else {
                 normalizedTokens = tokensLoaned;
             }
 
-            if (accountingContext.currency == currency) {
+            if (sourceContext.currency == currency) {
                 borrowedAmount += normalizedTokens;
             } else {
                 // Convert source-token debt into the requested currency using the loans contract's shared prices.
                 uint256 pricePerUnit = loans.PRICES()
                     .pricePerUnitOf({
                     projectId: revnetId,
-                    pricingCurrency: accountingContext.currency,
+                    pricingCurrency: sourceContext.currency,
                     unitCurrency: currency,
                     decimals: decimals
                 });
@@ -633,6 +641,14 @@ contract REVOwner is IJBRulesetDataHook, IJBCashOutHook, IJBPeerChainAdjustedAcc
     // --------------------- internal transactions ----------------------- //
     //*********************************************************************//
 
+    /// @notice Clears any token allowance granted by `_beforeTransferTo`.
+    /// @param to The address that was approved by `_beforeTransferTo`.
+    /// @param token The token whose allowance should be revoked.
+    function _afterTransferTo(address to, address token) internal {
+        if (token == JBConstants.NATIVE_TOKEN) return;
+        IERC20(token).forceApprove({spender: to, value: 0});
+    }
+
     /// @notice Logic to trigger before transferring tokens from this contract.
     /// @param to The address to transfer to.
     /// @param token The token to transfer.
@@ -645,10 +661,4 @@ contract REVOwner is IJBRulesetDataHook, IJBCashOutHook, IJBPeerChainAdjustedAcc
         IERC20(token).safeIncreaseAllowance({spender: to, value: amount});
         return 0;
     }
-
-    /// @notice Clears any token allowance granted by `_beforeTransferTo`.
-    function _afterTransferTo(address to, address token) internal {
-        if (token == JBConstants.NATIVE_TOKEN) return;
-        IERC20(token).forceApprove({spender: to, value: 0});
-    }
 }

package/src/interfaces/IREVDeployer.sol

@@ -8,6 +8,8 @@ import {IJBController} from "@bananapus/core-v6/src/interfaces/IJBController.sol
 import {IJBDirectory} from "@bananapus/core-v6/src/interfaces/IJBDirectory.sol";
 import {IJBPermissions} from "@bananapus/core-v6/src/interfaces/IJBPermissions.sol";
 import {IJBProjects} from "@bananapus/core-v6/src/interfaces/IJBProjects.sol";
+import {IJBTerminal} from "@bananapus/core-v6/src/interfaces/IJBTerminal.sol";
+import {JBAccountingContext} from "@bananapus/core-v6/src/structs/JBAccountingContext.sol";
 import {JBRulesetConfig} from "@bananapus/core-v6/src/structs/JBRulesetConfig.sol";
 import {JBTerminalConfig} from "@bananapus/core-v6/src/structs/JBTerminalConfig.sol";
 import {IJBSuckerRegistry} from "@bananapus/suckers-v6/src/interfaces/IJBSuckerRegistry.sol";
@@ -142,6 +144,10 @@ interface IREVDeployer {
     /// @return The loans contract address.
     function LOANS() external view returns (IREVLoans);
 
+    /// @notice The canonical terminal that holds revnet treasury balances.
+    /// @return The multi terminal contract.
+    function MULTI_TERMINAL() external view returns (IJBTerminal);
+
     /// @notice The runtime data hook contract that handles pay and cash out callbacks for revnets.
     /// @return The owner contract address.
     function OWNER() external view returns (address);
@@ -158,6 +164,10 @@ interface IREVDeployer {
     /// @return The publisher contract.
     function PUBLISHER() external view returns (CTPublisher);
 
+    /// @notice The canonical router terminal registry installed as a project terminal for alternate payment routes.
+    /// @return The router terminal registry contract, cast as a terminal.
+    function ROUTER_TERMINAL_REGISTRY() external view returns (IJBTerminal);
+
     /// @notice The registry that deploys and tracks suckers for revnets.
     /// @return The sucker registry contract.
     function SUCKER_REGISTRY() external view returns (IJBSuckerRegistry);
@@ -176,7 +186,7 @@ interface IREVDeployer {
     /// @dev Every revnet gets a 721 hook — pass an empty config if no tiers are needed initially.
     /// @param revnetId The ID of the Juicebox project to initialize. Send 0 to deploy a new revnet.
     /// @param configuration Core revnet configuration.
-    /// @param terminalConfigurations The terminals to set up for the revnet.
+    /// @param accountingContextsToAccept The accounting contexts the canonical multi terminal should accept.
     /// @param suckerDeploymentConfiguration The suckers to set up for cross-chain token transfers.
     /// @param tiered721HookConfiguration How to configure the tiered ERC-721 hook for the revnet.
     /// @param allowedPosts Restrictions on which croptop posts to allow on the revnet's ERC-721 tiers.
@@ -185,7 +195,7 @@ interface IREVDeployer {
     function deployFor(
         uint256 revnetId,
         REVConfig memory configuration,
-        JBTerminalConfig[] memory terminalConfigurations,
+        JBAccountingContext[] memory accountingContextsToAccept,
         REVSuckerDeploymentConfig memory suckerDeploymentConfiguration,
         REVDeploy721TiersHookConfig memory tiered721HookConfiguration,
         REVCroptopAllowedPost[] memory allowedPosts
@@ -197,14 +207,14 @@ interface IREVDeployer {
     /// @dev Convenience overload — constructs an empty 721 config internally and delegates to the 6-arg version.
     /// @param revnetId The ID of the Juicebox project to initialize. Send 0 to deploy a new revnet.
     /// @param configuration Core revnet configuration.
-    /// @param terminalConfigurations The terminals to set up for the revnet.
+    /// @param accountingContextsToAccept The accounting contexts the canonical multi terminal should accept.
     /// @param suckerDeploymentConfiguration The suckers to set up for cross-chain token transfers.
     /// @return The ID of the newly created or initialized revnet.
     /// @return hook The tiered ERC-721 hook deployed for the revnet.
     function deployFor(
         uint256 revnetId,
         REVConfig memory configuration,
-        JBTerminalConfig[] memory terminalConfigurations,
+        JBAccountingContext[] memory accountingContextsToAccept,
         REVSuckerDeploymentConfig memory suckerDeploymentConfiguration
     )
         external

package/src/interfaces/IREVLoans.sol

@@ -10,7 +10,6 @@ import {JBSingleAllowance} from "@bananapus/core-v6/src/structs/JBSingleAllowanc
 import {IJBSuckerRegistry} from "@bananapus/suckers-v6/src/interfaces/IJBSuckerRegistry.sol";
 import {IPermit2} from "@uniswap/permit2/src/interfaces/IPermit2.sol";
 import {REVLoan} from "../structs/REVLoan.sol";
-import {REVLoanSource} from "../structs/REVLoanSource.sol";
 
 /// @notice Manages loans against revnet token collateral.
 interface IREVLoans {
@@ -18,7 +17,7 @@ interface IREVLoans {
     /// @param loanId The ID of the newly created loan.
     /// @param revnetId The ID of the revnet being borrowed from.
     /// @param loan The loan data.
-    /// @param source The source of the loan (terminal and token).
+    /// @param token The token borrowed from the revnet's canonical multi terminal.
     /// @param borrowAmount The amount borrowed.
     /// @param collateralCount The amount of collateral tokens locked.
     /// @param sourceFeeAmount The fee amount charged by the source.
@@ -28,7 +27,7 @@ interface IREVLoans {
         uint256 indexed loanId,
         uint256 indexed revnetId,
         REVLoan loan,
-        REVLoanSource source,
+        address token,
         uint256 borrowAmount,
         uint256 collateralCount,
         uint256 sourceFeeAmount,
@@ -124,12 +123,11 @@ interface IREVLoans {
     /// @return The directory contract.
     function DIRECTORY() external view returns (IJBDirectory);
 
-    /// @notice Whether a revnet currently has outstanding loans from the specified terminal in the specified token.
+    /// @notice Whether a revnet currently has outstanding loans from the specified token.
     /// @param revnetId The ID of the revnet to check.
-    /// @param terminal The terminal to check.
     /// @param token The token to check.
     /// @return A flag indicating if the revnet has an active loan source.
-    function isLoanSourceOf(uint256 revnetId, IJBPayoutTerminal terminal, address token) external view returns (bool);
+    function isLoanSourceOf(uint256 revnetId, address token) external view returns (bool);
 
     /// @notice The duration after which a loan expires and its collateral is permanently lost.
     /// @return The loan liquidation duration in seconds.
@@ -140,13 +138,13 @@ interface IREVLoans {
     /// @return The loan data.
     function loanOf(uint256 loanId) external view returns (REVLoan memory);
 
-    /// @notice The sources of each revnet's loans.
-    /// @dev This array only grows -- sources are appended when a new (terminal, token) pair is first used for
-    /// borrowing, but are never removed. Gas cost scales linearly with the number of distinct sources, though this is
-    /// practically bounded to a small number of unique (terminal, token) pairs.
+    /// @notice The token sources of each revnet's loans.
+    /// @dev This array only grows -- sources are appended when a token is first used for borrowing, but are never
+    /// removed. Gas cost scales linearly with the number of distinct sources, though this is practically bounded to the
+    /// revnet's accepted accounting contexts.
     /// @param revnetId The ID of the revnet to get the loan sources for.
-    /// @return The array of loan sources.
-    function loanSourcesOf(uint256 revnetId) external view returns (REVLoanSource[] memory);
+    /// @return The array of loan source tokens.
+    function loanSourceTokensOf(uint256 revnetId) external view returns (address[] memory);
 
     /// @notice The maximum fee percent that can be prepaid when borrowing, in terms of `JBConstants.MAX_FEE`.
     /// @return The maximum prepaid fee percent.
@@ -168,13 +166,17 @@ interface IREVLoans {
     /// @return The REV revnet ID.
     function REV_ID() external view returns (uint256);
 
+    /// @notice The fee percent charged by the REV revnet on each loan, in terms of `JBConstants.MAX_FEE`.
+    /// @return The REV prepaid fee percent.
+    function REV_PREPAID_FEE_PERCENT() external view returns (uint256);
+
     /// @notice The sucker registry used to discover peer chain suckers for cross-chain supply/surplus awareness.
     /// @return The sucker registry.
     function SUCKER_REGISTRY() external view returns (IJBSuckerRegistry);
 
-    /// @notice The fee percent charged by the REV revnet on each loan, in terms of `JBConstants.MAX_FEE`.
-    /// @return The REV prepaid fee percent.
-    function REV_PREPAID_FEE_PERCENT() external view returns (uint256);
+    /// @notice The canonical payout terminal that holds revnet treasury balances and sources all revnet loans.
+    /// @return The canonical payout terminal.
+    function TERMINAL() external view returns (IJBPayoutTerminal);
 
     /// @notice The revnet ID for a given loan ID.
     /// @param loanId The loan ID to look up.
@@ -185,19 +187,11 @@ interface IREVLoans {
     /// @return The token URI resolver.
     function tokenUriResolver() external view returns (IJBTokenUriResolver);
 
-    /// @notice The total amount loaned out by a revnet from a specified terminal in a specified token.
+    /// @notice The total amount loaned out by a revnet from a specified token.
     /// @param revnetId The ID of the revnet to check.
-    /// @param terminal The terminal the loans were issued from.
     /// @param token The token loaned.
     /// @return The total amount borrowed.
-    function totalBorrowedFrom(
-        uint256 revnetId,
-        IJBPayoutTerminal terminal,
-        address token
-    )
-        external
-        view
-        returns (uint256);
+    function totalBorrowedFrom(uint256 revnetId, address token) external view returns (uint256);
 
     /// @notice The total amount of collateral supporting a revnet's loans.
     /// @param revnetId The ID of the revnet.
@@ -214,8 +208,8 @@ interface IREVLoans {
 
     /// @notice Open a loan by borrowing from a revnet. Collateral tokens are burned and only re-minted upon repayment.
     /// @param revnetId The ID of the revnet to borrow from.
-    /// @param source The source of the loan (terminal and token).
-    /// @param minBorrowAmount The minimum amount to borrow, denominated in the source's token.
+    /// @param token The token to borrow from the revnet's canonical multi terminal.
+    /// @param minBorrowAmount The minimum amount to borrow, denominated in `token`.
     /// @param collateralCount The amount of tokens to use as collateral for the loan.
     /// @param beneficiary The address that will receive the borrowed funds and fee payment tokens.
     /// @param prepaidFeePercent The fee percent to charge upfront, in terms of `JBConstants.MAX_FEE`.
@@ -224,7 +218,7 @@ interface IREVLoans {
     /// @return The loan created.
     function borrowFrom(
         uint256 revnetId,
-        REVLoanSource calldata source,
+        address token,
         uint256 minBorrowAmount,
         uint256 collateralCount,
         address payable beneficiary,
@@ -243,7 +237,7 @@ interface IREVLoans {
     /// @notice Refinance a loan by transferring extra collateral from an existing loan to a new loan.
     /// @param loanId The ID of the loan to reallocate collateral from.
     /// @param collateralCountToTransfer The amount of collateral to transfer from the original loan.
-    /// @param source The source of the new loan (terminal and token). Must match the existing loan's source.
+    /// @param token The token of the new loan. Must match the existing loan's source token.
     /// @param minBorrowAmount The minimum amount to borrow for the new loan.
     /// @param collateralCountToAdd Additional collateral to add to the new loan from your balance.
     /// @param beneficiary The address that will receive the borrowed funds and fee payment tokens.
@@ -255,7 +249,7 @@ interface IREVLoans {
     function reallocateCollateralFromLoan(
         uint256 loanId,
         uint256 collateralCountToTransfer,
-        REVLoanSource calldata source,
+        address token,
         uint256 minBorrowAmount,
         uint256 collateralCountToAdd,
         address payable beneficiary,

package/src/interfaces/IREVOwner.sol

@@ -10,7 +10,11 @@ interface IREVOwner {
     /// @return The cash out delay timestamp.
     function cashOutDelayOf(uint256 revnetId) external view returns (uint256);
 
+    /// @notice The canonical deployer managing revnet runtime state.
+    /// @return The revnet deployer instance.
+    function deployer() external view returns (IREVDeployer);
+
     /// @notice Bind the canonical deployer exactly once.
-    /// @param deployer The revnet deployer instance.
-    function setDeployer(IREVDeployer deployer) external;
+    /// @param newDeployer The revnet deployer instance.
+    function setDeployer(IREVDeployer newDeployer) external;
 }

package/src/libraries/REVLoansSourceFees.sol

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.28;
+
+import {JBConstants} from "@bananapus/core-v6/src/libraries/JBConstants.sol";
+import {JBFees} from "@bananapus/core-v6/src/libraries/JBFees.sol";
+import {mulDiv} from "@prb/math/src/Common.sol";
+
+import {REVLoan} from "../structs/REVLoan.sol";
+
+/// @notice Source-fee arithmetic for REV loans.
+library REVLoansSourceFees {
+    error REVLoans_LoanExpired(uint256 timeSinceLoanCreated, uint256 loanLiquidationDuration);
+
+    /// @notice Determines the source fee amount for a loan when paying off a certain amount.
+    /// @param loan The loan to determine the source fee for.
+    /// @param amount The amount of principal being paid off.
+    /// @param timeSinceLoanCreated The elapsed time since the loan was created.
+    /// @param loanLiquidationDuration The duration after which loans are expired.
+    /// @return sourceFeeAmount The source fee amount for the repayment.
+    function sourceFeeAmountFrom(
+        REVLoan memory loan,
+        uint256 amount,
+        uint256 timeSinceLoanCreated,
+        uint256 loanLiquidationDuration
+    )
+        internal
+        pure
+        returns (uint256 sourceFeeAmount)
+    {
+        // Inside the prepaid window, the borrower already paid the source fee up front.
+        if (timeSinceLoanCreated <= loan.prepaidDuration) return 0;
+
+        // Expired loans cannot be managed through repay/reallocate paths. Uses `>` so the exact boundary second is
+        // still repayable, matching the liquidation path's `<=` check.
+        if (timeSinceLoanCreated > loanLiquidationDuration) {
+            revert REVLoans_LoanExpired({
+                timeSinceLoanCreated: timeSinceLoanCreated, loanLiquidationDuration: loanLiquidationDuration
+            });
+        }
+
+        // The prepaid fee reduces the amount that can still accrue a time-based source fee.
+        uint256 prepaid = JBFees.feeAmountFrom({amountBeforeFee: loan.amount, feePercent: loan.prepaidFeePercent});
+
+        // Linearly ramp the remaining source fee from 0 after the prepaid window to 100% at liquidation.
+        uint256 fullSourceFeeAmount = JBFees.feeAmountFrom({
+            amountBeforeFee: loan.amount - prepaid,
+            feePercent: mulDiv({
+                x: timeSinceLoanCreated - loan.prepaidDuration,
+                y: JBConstants.MAX_FEE,
+                denominator: loanLiquidationDuration - loan.prepaidDuration
+            })
+        });
+
+        // Charge only the pro-rata part of the full source fee for the principal being repaid.
+        return mulDiv({x: fullSourceFeeAmount, y: amount, denominator: loan.amount});
+    }
+}

package/src/structs/REVLoan.sol

@@ -1,8 +1,6 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 
-import {REVLoanSource} from "./REVLoanSource.sol";
-
 /// @notice An active loan against a revnet. The borrower locked collateral tokens (which were burned) and received
 /// funds from the revnet's terminal. The loan can be repaid within the prepaid duration at no extra cost; after that,
 /// repayment cost increases linearly until liquidation at 10 years.
@@ -12,12 +10,12 @@ import {REVLoanSource} from "./REVLoanSource.sol";
 /// @custom:member prepaidFeePercent The percentage of fees prepaid at creation (determines prepaid duration).
 /// @custom:member prepaidDuration The duration (seconds) during which repayment costs nothing beyond the original
 /// amount.
-/// @custom:member source The terminal and token from which funds were drawn.
+/// @custom:member sourceToken The token borrowed from the revnet's canonical multi terminal.
 struct REVLoan {
     uint112 amount;
     uint112 collateral;
     uint48 createdAt;
     uint16 prepaidFeePercent;
     uint32 prepaidDuration;
-    REVLoanSource source;
+    address sourceToken;
 }

package/src/structs/REVLoanSource.sol

@@ -1,11 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.0;
-
-import {IJBPayoutTerminal} from "@bananapus/core-v6/src/interfaces/IJBPayoutTerminal.sol";
-
-/// @custom:member token The token to loan.
-/// @custom:member terminal The terminal to loan from.
-struct REVLoanSource {
-    address token;
-    IJBPayoutTerminal terminal;
-}