@bananapus/core-v6 0.0.53 → 0.0.55

package/src/JBPrices.sol

@@ -202,7 +202,7 @@ contract JBPrices is JBControlled, JBPermissioned, ERC2771Context, Ownable, IJBP
         // is in the range of ~1e9 to ~1e27 (for 18 decimals). Extreme prices outside this range may lose
         // significant precision due to fixed-point division truncation.
         if (feed != IJBPriceFeed(address(0))) {
-            return mulDiv(10 ** decimals, 10 ** decimals, feed.currentUnitPrice(decimals));
+            return mulDiv({x: 10 ** decimals, y: 10 ** decimals, denominator: feed.currentUnitPrice(decimals)});
         }
 
         // Check for a default feed (project ID 0) if not found.

package/src/JBRulesets.sol

@@ -623,11 +623,11 @@ contract JBRulesets is JBControlled, IJBRulesets {
     {
         // A subsequent ruleset to one with a duration of 0 should have the next possible weight.
         if (baseRulesetDuration == 0) {
-            return mulDiv(
-                baseRulesetWeight,
-                JBConstants.MAX_WEIGHT_CUT_PERCENT - baseRulesetWeightCutPercent,
-                JBConstants.MAX_WEIGHT_CUT_PERCENT
-            );
+            return mulDiv({
+                x: baseRulesetWeight,
+                y: JBConstants.MAX_WEIGHT_CUT_PERCENT - baseRulesetWeightCutPercent,
+                denominator: JBConstants.MAX_WEIGHT_CUT_PERCENT
+            });
         }
 
         // The weight should be based off the base ruleset's weight.
@@ -673,7 +673,7 @@ contract JBRulesets is JBControlled, IJBRulesets {
 
         for (uint256 i; i < weightCutMultiple;) {
             // Base the new weight on the specified ruleset's weight.
-            weight = mulDiv(weight, cutFactor, maxPercent);
+            weight = mulDiv({x: weight, y: cutFactor, denominator: maxPercent});
 
             // The calculation doesn't need to continue if the weight is 0.
             if (weight == 0) break;

package/src/JBTokens.sol

@@ -230,7 +230,7 @@ contract JBTokens is JBControlled, IJBTokens {
         });
 
         // Initialize the token.
-        token.initialize({name: name, symbol: symbol, tokens: address(this)});
+        token.initialize({name: name, symbol: symbol, tokensAddress: address(this)});
     }
 
     /// @notice Create new tokens for a holder. If the project has an ERC-20 deployed, tokens are minted directly to

package/src/interfaces/IJBCashOutTerminal.sol

@@ -9,39 +9,6 @@ import {JBRuleset} from "../structs/JBRuleset.sol";
 
 /// @notice A terminal that can be cashed out from.
 interface IJBCashOutTerminal is IJBTerminal {
-    /// @notice Atomically cash out a holder's tokens of one project and add the reclaim to another project's
-    /// balance (no project tokens minted on the destination side).
-    /// @dev Equivalent to calling `cashOutTokensOf` followed by `addToBalanceOf` on the destination project,
-    /// except the source-side cash out fee is skipped (the equivalent fee is bound on the destination
-    /// project's side instead). Held-fee return is hardcoded to `false` on the destination side — this
-    /// entrypoint is for value top-up only, not fee unlock.
-    /// @dev The destination terminal is whichever terminal the directory has registered as the beneficiary
-    /// project's primary terminal for `tokenToReclaim` (which may itself be a router that swaps before adding
-    /// to balance). Cashout-side hooks (if specified by the data hook) execute additively.
-    /// @dev Round-trip fee preservation is enforced by snapshotting the beneficiary project's
-    /// accounting-context balances on this terminal before and after the routing, and crediting
-    /// `_feeFreeSurplusOf` by the per-token delta on each context that grew. The beneficiary project's current
-    /// ruleset can set `pauseCrossProjectFeeFreeInflows` to opt out.
-    /// @param holder The address whose project tokens are being burned.
-    /// @param projectId The ID of the project whose project tokens are being burned.
-    /// @param cashOutCount The number of project tokens to burn.
-    /// @param tokenToReclaim The terminal token reclaimed from the source project's surplus.
-    /// @param beneficiaryProjectId The destination project receiving the reclaim.
-    /// @param cashOutMetadata Forwarded to the source project's data hook and any cashout hook specifications.
-    /// @param addToBalanceMetadata Forwarded to the destination project's `addToBalanceOf` event.
-    /// @return reclaimAmount The gross reclaim amount returned by the store.
-    function addToBalanceAfterCashOutTokensOf(
-        address holder,
-        uint256 projectId,
-        uint256 cashOutCount,
-        address tokenToReclaim,
-        uint256 beneficiaryProjectId,
-        bytes calldata cashOutMetadata,
-        bytes calldata addToBalanceMetadata
-    )
-        external
-        returns (uint256 reclaimAmount);
-
     /// @notice A cash out was processed for a project.
     /// @param rulesetId The ID of the ruleset during the cash out.
     /// @param rulesetCycleNumber The cycle number of the ruleset during the cash out.
@@ -129,39 +96,4 @@ interface IJBCashOutTerminal is IJBTerminal {
     )
         external
         returns (uint256 reclaimAmount);
-
-    /// @notice Atomically cash out a holder's tokens of one project and pay the reclaim into another. Equivalent
-    /// to calling `cashOutTokensOf` followed by `pay` on the destination project, except the source-side cash out
-    /// fee is skipped (the equivalent fee is bound on the destination project's side instead).
-    /// @dev The destination terminal is whichever terminal the directory has registered as the beneficiary project's
-    /// primary terminal for `tokenToReclaim` (which may itself be a router that swaps before paying). Cashout-side
-    /// hooks (if specified by the data hook) execute additively.
-    /// @dev Round-trip fee preservation is enforced by snapshotting the beneficiary project's accounting-context
-    /// balances on this terminal before and after the routing, and crediting `_feeFreeSurplusOf` by the per-token
-    /// delta on each context that grew. The beneficiary project's current ruleset can set
-    /// `pauseCrossProjectFeeFreeInflows` to opt out.
-    /// @param holder The address whose project tokens are being burned.
-    /// @param projectId The ID of the project whose project tokens are being burned.
-    /// @param cashOutCount The number of project tokens to burn.
-    /// @param tokenToReclaim The terminal token reclaimed from the source project's surplus.
-    /// @param beneficiaryProjectId The destination project.
-    /// @param beneficiary The address that receives the newly minted tokens of the destination project.
-    /// @param minTokensOut The minimum number of destination-project tokens that must be minted; reverts otherwise.
-    /// @param cashOutMetadata Forwarded to the source project's data hook and any cashout hook specifications.
-    /// @param payMetadata Forwarded to the destination project's pay flow.
-    /// @return reclaimAmount The gross reclaim amount returned by the store.
-    /// @return beneficiaryTokenCount The number of destination-project tokens minted to `beneficiary`.
-    function payAfterCashOutTokensOf(
-        address holder,
-        uint256 projectId,
-        uint256 cashOutCount,
-        address tokenToReclaim,
-        uint256 beneficiaryProjectId,
-        address beneficiary,
-        uint256 minTokensOut,
-        bytes calldata cashOutMetadata,
-        bytes calldata payMetadata
-    )
-        external
-        returns (uint256 reclaimAmount, uint256 beneficiaryTokenCount);
 }

package/src/interfaces/IJBFeeTerminal.sol

@@ -27,7 +27,7 @@ interface IJBFeeTerminal is IJBTerminal {
     /// @param projectId The ID of the project the fee was held for.
     /// @param token The token the fee is denominated in.
     /// @param amount The amount from which the fee was calculated.
-    /// @param fee The fee amount held.
+    /// @param fee The fee numerator used to calculate the held fee, out of `JBConstants.MAX_FEE`.
     /// @param beneficiary The address that will receive project tokens when the fee is processed.
     /// @param caller The address that triggered the fee hold.
     event HoldFee(

package/src/interfaces/IJBFeelessAddresses.sol

@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 
+import {IJBFeelessHook} from "./IJBFeelessHook.sol";
+
 /// @notice Tracks addresses that are exempt from fees, both globally and on a per-project basis.
 /// @dev `projectId = 0` is the wildcard — an address feeless for project 0 is feeless for ALL projects.
 interface IJBFeelessAddresses {
@@ -11,11 +13,21 @@ interface IJBFeelessAddresses {
     /// @param caller The address that set the feeless status.
     event SetFeelessAddress(uint256 indexed projectId, address indexed addr, bool indexed isFeeless, address caller);
 
-    /// @notice Returns whether the specified address is feeless for a specific project, considering both the wildcard
-    /// (projectId 0) and project-specific feeless status.
+    /// @notice The optional hook (set by the owner) that can grant feeless status with arbitrary logic. Set to the
+    /// zero address to disable.
+    /// @param hook The new feeless hook. The zero address disables hook consultation.
+    /// @param caller The address that set the hook.
+    event SetFeelessHook(IJBFeelessHook indexed hook, address caller);
+
+    /// @notice The optional hook consulted (in addition to the static mappings) when computing feeless status.
+    /// @dev `address(0)` means no hook is set.
+    function feelessHook() external view returns (IJBFeelessHook);
+
+    /// @notice Returns whether the specified address is feeless for a specific project, considering the wildcard
+    /// (projectId 0) feeless status, the project-specific feeless status, and the feeless hook (if set).
     /// @param addr The address to check.
     /// @param projectId The ID of the project to check.
-    /// @return A flag indicating whether the address is feeless (globally or for the project).
+    /// @return A flag indicating whether the address is feeless (globally, for the project, or per the hook).
     function isFeelessFor(address addr, uint256 projectId) external view returns (bool);
 
     /// @notice Sets whether an address is feeless globally (for all projects).
@@ -28,4 +40,8 @@ interface IJBFeelessAddresses {
     /// @param addr The address to set the feeless status of.
     /// @param flag A flag indicating whether the address should be feeless for the project.
     function setFeelessAddressFor(uint256 projectId, address addr, bool flag) external;
+
+    /// @notice Sets (or clears) the feeless hook consulted by `isFeelessFor`.
+    /// @param hook The new hook. Pass `address(0)` to disable hook consultation.
+    function setFeelessHook(IJBFeelessHook hook) external;
 }

package/src/interfaces/IJBFeelessHook.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+
+/// @notice Optional hook that can grant feeless status to addresses based on arbitrary off-chain or on-chain logic.
+/// @dev Plugged into `JBFeelessAddresses` by the contract owner. The hook is OR'd with the static feeless mappings,
+/// so it can only widen the feeless set, never shrink it.
+/// @dev `JBFeelessAddresses` invokes this hook inside a try/catch — a reverting hook is treated as returning `false`,
+/// so a broken hook cannot brick the fee path in terminals.
+interface IJBFeelessHook is IERC165 {
+    /// @notice Returns whether the address should be treated as feeless for the project.
+    /// @param projectId The ID of the project the fee would be charged on behalf of.
+    /// @param addr The address being checked (typically a payout recipient, surplus allowance beneficiary, or
+    /// cash-out beneficiary).
+    /// @return A flag indicating whether the address is feeless for the project under the hook's custom logic.
+    function isFeeless(uint256 projectId, address addr) external view returns (bool);
+}

package/src/interfaces/IJBToken.sol

@@ -29,8 +29,8 @@ interface IJBToken {
     /// @notice Initializes the token with a name, symbol, and the JBTokens contract.
     /// @param name The token's name.
     /// @param symbol The token's symbol.
-    /// @param tokens The JBTokens contract that manages this token.
-    function initialize(string memory name, string memory symbol, address tokens) external;
+    /// @param tokensAddress The JBTokens contract that manages this token.
+    function initialize(string memory name, string memory symbol, address tokensAddress) external;
 
     /// @notice Mints tokens to an account.
     /// @param account The address to mint tokens to.

package/src/libraries/JBCashOuts.sol

@@ -42,7 +42,7 @@ library JBCashOuts {
         if (cashOutCount >= totalSupply) return surplus;
 
         // Get a reference to the linear proportion.
-        uint256 base = mulDiv(surplus, cashOutCount, totalSupply);
+        uint256 base = mulDiv({x: surplus, y: cashOutCount, denominator: totalSupply});
 
         // These conditions are all part of the same curve.
         // Edge conditions are separated to minimize the operations performed in those cases.
@@ -50,11 +50,12 @@ library JBCashOuts {
             return base;
         }
 
-        return mulDiv(
-            base,
-            (JBConstants.MAX_CASH_OUT_TAX_RATE - cashOutTaxRate) + mulDiv(cashOutTaxRate, cashOutCount, totalSupply),
-            JBConstants.MAX_CASH_OUT_TAX_RATE
-        );
+        return mulDiv({
+            x: base,
+            y: (JBConstants.MAX_CASH_OUT_TAX_RATE - cashOutTaxRate)
+                + mulDiv({x: cashOutTaxRate, y: cashOutCount, denominator: totalSupply}),
+            denominator: JBConstants.MAX_CASH_OUT_TAX_RATE
+        });
     }
 
     /// @notice Returns the minimum number of tokens that must be cashed out to receive at least `desiredOutput` of
@@ -93,9 +94,9 @@ library JBCashOuts {
 
         // Linear case (no tax): out = surplus * c / totalSupply, so c = ceil(out * totalSupply / surplus).
         if (cashOutTaxRate == 0) {
-            uint256 count = mulDiv(desiredOutput, totalSupply, surplus);
+            uint256 count = mulDiv({x: desiredOutput, y: totalSupply, denominator: surplus});
             // Round up if the floor division undershoots.
-            if (mulDiv(surplus, count, totalSupply) < desiredOutput) count++;
+            if (mulDiv({x: surplus, y: count, denominator: totalSupply}) < desiredOutput) count++;
             return count;
         }
 

package/src/libraries/JBConstants.sol

@@ -18,12 +18,9 @@ library JBConstants {
     /// @notice The denominator for split percentages (9-decimal precision). A split of 1,000,000,000 = 100%.
     uint32 public constant SPLITS_TOTAL_PERCENT = 1_000_000_000;
 
-    /// @notice The fee denominator. The protocol fee is `FEE / MAX_FEE` (currently 25/1000 = 2.5%).
+    /// @notice The fee denominator. The protocol fee is `STANDARD_FEE / MAX_FEE`.
     uint16 public constant MAX_FEE = 1000;
 
-    /// @notice The fee numerator. The protocol fee is `FEE / MAX_FEE` = 25/1000 = 2.5%, charged on outflows.
-    uint16 public constant FEE = 25;
-
-    /// @notice The project ID that receives protocol fees. Should be the first project launched at deployment.
-    uint256 public constant FEE_BENEFICIARY_PROJECT_ID = 1;
+    /// @notice The standard protocol fee numerator. The protocol fee is `STANDARD_FEE / MAX_FEE` = 2.5%.
+    uint16 public constant STANDARD_FEE = 25;
 }

package/src/libraries/JBFees.sol

@@ -3,53 +3,49 @@ pragma solidity 0.8.28;
 
 import {mulDiv} from "@prb/math/src/Common.sol";
 
-import {JBConstants} from "./../libraries/JBConstants.sol";
+import {JBConstants} from "./JBConstants.sol";
 
 /// @notice Fee calculations.
 library JBFees {
-    /// @notice Returns the fee amount that, when added to `amountAfterFee`, produces the gross amount needed to yield
-    /// `amountAfterFee` after the fee is deducted.
-    /// @dev Use this to back-calculate the fee from a desired post-fee payout.
-    /// @param amountAfterFee The desired post-fee amount, as a fixed point number.
-    /// @param feePercent The fee percent, out of `JBConstants.MAX_FEE`.
-    /// @return The fee amount, as a fixed point number with the same number of decimals as the provided `amount`.
-    function feeAmountResultingIn(uint256 amountAfterFee, uint256 feePercent) internal pure returns (uint256) {
-        return mulDiv(amountAfterFee, JBConstants.MAX_FEE, JBConstants.MAX_FEE - feePercent) - amountAfterFee;
-    }
-
     /// @notice Returns the fee that would be taken from `amountBeforeFee`.
     /// @dev Use this to forward-calculate the fee from a known pre-fee amount.
     /// @dev Fee rounding error is bounded by N-1 wei (N = number of splits). Economically
     /// insignificant. Rounds down (mulDiv floors), so the fee beneficiary may receive up to 1 wei less per split.
     /// @param amountBeforeFee The amount before the fee is applied, as a fixed point number.
     /// @param feePercent The fee percent, out of `JBConstants.MAX_FEE`.
-    /// @return The fee amount, as a fixed point number with the same number of decimals as the provided `amount`.
+    /// @return The fee amount, as a fixed point number with the same number of decimals as `amountBeforeFee`.
     function feeAmountFrom(uint256 amountBeforeFee, uint256 feePercent) internal pure returns (uint256) {
-        return mulDiv(amountBeforeFee, feePercent, JBConstants.MAX_FEE);
+        return mulDiv({x: amountBeforeFee, y: feePercent, denominator: JBConstants.MAX_FEE});
+    }
+
+    /// @notice Returns the fee amount that, when added to `amountAfterFee`, produces the gross amount needed to yield
+    /// `amountAfterFee` after the fee is deducted.
+    /// @dev Use this to back-calculate the fee from a desired post-fee payout.
+    /// @param amountAfterFee The desired post-fee amount, as a fixed point number.
+    /// @param feePercent The fee percent, out of `JBConstants.MAX_FEE`.
+    /// @return The fee amount, as a fixed point number with the same number of decimals as `amountAfterFee`.
+    function feeAmountResultingIn(uint256 amountAfterFee, uint256 feePercent) internal pure returns (uint256) {
+        return mulDiv({x: amountAfterFee, y: JBConstants.MAX_FEE, denominator: JBConstants.MAX_FEE - feePercent})
+            - amountAfterFee;
     }
 
-    /// @notice Specialization of `feeAmountFrom` that hardcodes the standard protocol fee
-    /// (`JBConstants.FEE / JBConstants.MAX_FEE` = 25 / 1000 = 1 / 40). Both numerator and denominator are
-    /// compile-time constants so callers don't need to pass them every call.
-    /// @dev Pre-reduced: `mulDiv(amount, 25, 1000)` ≡ `amount / 40` (gcd(25, 1000) = 25). Plain integer
-    /// division is exact (rounds down) and shaves the entire `mulDiv` 512-bit pipeline at every fee site.
-    /// If `JBConstants.FEE` or `JBConstants.MAX_FEE` changes, the constant `40` here MUST be reduced again.
+    /// @notice Returns the standard protocol fee taken from `amountBeforeFee`.
+    /// @dev The standard fee is `25 / 1_000`, pre-reduced to `1 / 40`. If `JBConstants.STANDARD_FEE` or
+    /// `JBConstants.MAX_FEE` changes, this denominator must be reduced again.
     /// @param amountBeforeFee The amount before the fee is applied, as a fixed point number.
     /// @return The fee amount, as a fixed point number with the same number of decimals as `amountBeforeFee`.
     function standardFeeAmountFrom(uint256 amountBeforeFee) internal pure returns (uint256) {
+        // `JBConstants.STANDARD_FEE / JBConstants.MAX_FEE` is currently `1 / 40`.
         return amountBeforeFee / 40;
     }
 
-    /// @notice Specialization of `feeAmountResultingIn` that hardcodes the standard protocol fee
-    /// (`JBConstants.FEE / JBConstants.MAX_FEE`). Use to back-calculate the standard fee from a known
-    /// post-fee payout.
-    /// @dev Pre-reduced: `mulDiv(amount, 1000, 1000 - 25) - amount` ≡ `mulDiv(amount, 40, 39) - amount`
-    /// (gcd(1000, 975) = 25). `mulDiv` (not raw `*`) preserves overflow-safety for the rare wildly-large
-    /// inputs and matches the rounding behavior of `feeAmountResultingIn` exactly. If `JBConstants.FEE` or
-    /// `JBConstants.MAX_FEE` changes, the constants `40` and `39` here MUST be reduced again.
+    /// @notice Back-calculates the standard protocol fee from a known post-fee amount.
+    /// @dev `1 / (1 - 25 / 1_000) - 1` reduces to `40 / 39 - 1`. If `JBConstants.STANDARD_FEE` or
+    /// `JBConstants.MAX_FEE` changes, these constants must be reduced again.
     /// @param amountAfterFee The desired post-fee amount, as a fixed point number.
     /// @return The fee amount that, when added to `amountAfterFee`, yields the gross pre-fee amount.
     function standardFeeAmountResultingIn(uint256 amountAfterFee) internal pure returns (uint256) {
-        return mulDiv(amountAfterFee, 40, 39) - amountAfterFee;
+        // Use `mulDiv` instead of `amountAfterFee * 40 / 39` to preserve overflow safety.
+        return mulDiv({x: amountAfterFee, y: 40, denominator: 39}) - amountAfterFee;
     }
 }

package/src/libraries/JBPayoutSplitGroupLib.sol

@@ -141,7 +141,7 @@ library JBPayoutSplitGroupLib {
         // refund = amount * (netPayoutAmount - sent) / netPayoutAmount. For full consumption this branch is
         // skipped. For zero consumption this refunds the full `amount` (i.e. the gross, fee allocation included).
         if (sent < netPayoutAmount) {
-            uint256 refund = mulDiv(amount, netPayoutAmount - sent, netPayoutAmount);
+            uint256 refund = mulDiv({x: amount, y: netPayoutAmount - sent, denominator: netPayoutAmount});
             if (refund != 0) {
                 store.recordAddedBalanceFor({projectId: projectId, token: token, amount: refund});
             }
@@ -151,7 +151,7 @@ library JBPayoutSplitGroupLib {
         // gross-equivalent of what the hook actually consumed so the held fee scales with consumption rather
         // than with the project's original payout intent.
         if (netPayoutAmount < amount && sent != 0) {
-            feeEligibleAmount = mulDiv(amount, sent, netPayoutAmount);
+            feeEligibleAmount = mulDiv({x: amount, y: sent, denominator: netPayoutAmount});
         }
     }
 
@@ -192,7 +192,7 @@ library JBPayoutSplitGroupLib {
             JBSplit memory split = payoutSplits[i];
 
             // The amount to send to the split.
-            uint256 payoutAmount = mulDiv(leftoverAmount, split.percent, leftoverPercentage);
+            uint256 payoutAmount = mulDiv({x: leftoverAmount, y: split.percent, denominator: leftoverPercentage});
 
             // Send the payout (inlined to keep stack pressure manageable with the tuple return).
             // Returns (netPayoutAmount sent, feeEligible gross-equivalent). For non-hook splits and fully-consumed

package/src/libraries/JBRulesetMetadataResolver.sol

@@ -71,25 +71,20 @@ library JBRulesetMetadataResolver {
         return ((ruleset.metadata >> 79) & 1) == 1;
     }
 
-    function pauseCrossProjectFeeFreeInflows(JBRuleset memory ruleset) internal pure returns (bool) {
-        return ((ruleset.metadata >> 80) & 1) == 1;
-    }
-
     function useDataHookForPay(JBRuleset memory ruleset) internal pure returns (bool) {
-        return (ruleset.metadata >> 81) & 1 == 1;
+        return (ruleset.metadata >> 80) & 1 == 1;
     }
 
     function useDataHookForCashOut(JBRuleset memory ruleset) internal pure returns (bool) {
-        return (ruleset.metadata >> 82) & 1 == 1;
+        return (ruleset.metadata >> 81) & 1 == 1;
     }
 
     function dataHook(JBRuleset memory ruleset) internal pure returns (address) {
-        return address(uint160(ruleset.metadata >> 83));
+        return address(uint160(ruleset.metadata >> 82));
     }
 
     function metadata(JBRuleset memory ruleset) internal pure returns (uint16) {
-        // 13-bit field at bits 243-255.
-        return uint16(ruleset.metadata >> 243);
+        return uint16(ruleset.metadata >> 242);
     }
 
     /// @notice Pack the funding cycle metadata.
@@ -130,16 +125,14 @@ library JBRulesetMetadataResolver {
         if (rulesetMetadata.holdFees) packed |= 1 << 78;
         // scopeCashOutsToLocalBalances in bit 79.
         if (rulesetMetadata.scopeCashOutsToLocalBalances) packed |= 1 << 79;
-        // pause cross-project fee-free inflows in bit 80.
-        if (rulesetMetadata.pauseCrossProjectFeeFreeInflows) packed |= 1 << 80;
-        // use pay data source in bit 81.
-        if (rulesetMetadata.useDataHookForPay) packed |= 1 << 81;
-        // use cash out data source in bit 82.
-        if (rulesetMetadata.useDataHookForCashOut) packed |= 1 << 82;
-        // data source address in bits 83-242.
-        packed |= uint256(uint160(address(rulesetMetadata.dataHook))) << 83;
-        // metadata in bits 243-255 (13 bits).
-        packed |= (uint256(rulesetMetadata.metadata) & 0x1FFF) << 243;
+        // use pay data source in bit 80.
+        if (rulesetMetadata.useDataHookForPay) packed |= 1 << 80;
+        // use cash out data source in bit 81.
+        if (rulesetMetadata.useDataHookForCashOut) packed |= 1 << 81;
+        // data source address in bits 82-241.
+        packed |= uint256(uint160(address(rulesetMetadata.dataHook))) << 82;
+        // metadata in bits 242-255 (14 bits).
+        packed |= (uint256(rulesetMetadata.metadata) & 0x3FFF) << 242;
     }
 
     /// @notice Expand the funding cycle metadata.
@@ -162,7 +155,6 @@ library JBRulesetMetadataResolver {
             ownerMustSendPayouts: ownerMustSendPayouts(ruleset),
             holdFees: holdFees(ruleset),
             scopeCashOutsToLocalBalances: scopeCashOutsToLocalBalances(ruleset),
-            pauseCrossProjectFeeFreeInflows: pauseCrossProjectFeeFreeInflows(ruleset),
             useDataHookForPay: useDataHookForPay(ruleset),
             useDataHookForCashOut: useDataHookForCashOut(ruleset),
             dataHook: dataHook(ruleset),

package/src/structs/JBRulesetMetadata.sol

@@ -23,12 +23,10 @@ pragma solidity ^0.8.0;
 /// @custom:member holdFees If `true`, fees are accumulated but not processed until a future ruleset (or manually).
 /// @custom:member scopeCashOutsToLocalBalances If `true`, omnichain cash-out calculations use only the local chain's
 /// balances (not cross-chain aggregates).
-/// @custom:member pauseCrossProjectFeeFreeInflows If `true`, the project cannot be targeted by
-/// `payAfterCashOutTokensOf` calls during this ruleset.
 /// @custom:member useDataHookForPay If `true`, the data hook is called before recording payments.
 /// @custom:member useDataHookForCashOut If `true`, the data hook is called before recording cash outs.
 /// @custom:member dataHook Contract called before pay/cash-out to potentially override token counts or add hooks.
-/// @custom:member metadata 13 bits of application-specific metadata (upper 3 bits of the uint16 are ignored).
+/// @custom:member metadata 14 bits of application-specific metadata (upper 2 bits are ignored).
 struct JBRulesetMetadata {
     uint16 reservedPercent;
     uint16 cashOutTaxRate;
@@ -45,7 +43,6 @@ struct JBRulesetMetadata {
     bool ownerMustSendPayouts;
     bool holdFees;
     bool scopeCashOutsToLocalBalances;
-    bool pauseCrossProjectFeeFreeInflows;
     bool useDataHookForPay;
     bool useDataHookForCashOut;
     address dataHook;

package/test/helpers/JBTest.sol

@@ -68,8 +68,7 @@ contract JBTest is Test {
             useDataHookForPay: false,
             useDataHookForCashOut: false,
             dataHook: address(0),
-            metadata: 0,
-            pauseCrossProjectFeeFreeInflows: false
+            metadata: 0
         });
 
         uint256 packed = _rulesMetadata.packRulesetMetadata();
@@ -107,8 +106,7 @@ contract JBTest is Test {
             useDataHookForPay: false,
             useDataHookForCashOut: false,
             dataHook: address(0),
-            metadata: 0,
-            pauseCrossProjectFeeFreeInflows: false
+            metadata: 0
         });
     }
 
@@ -132,8 +130,7 @@ contract JBTest is Test {
             useDataHookForPay: false,
             useDataHookForCashOut: false,
             dataHook: address(0),
-            metadata: 0,
-            pauseCrossProjectFeeFreeInflows: false
+            metadata: 0
         });
 
         uint256 packed = _rulesMetadata.packRulesetMetadata();

package/test/mock/MockFeelessHook.sol

@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.28;
+
+import {IJBFeelessHook} from "../../src/interfaces/IJBFeelessHook.sol";
+
+import {ERC165, IERC165} from "@openzeppelin/contracts/utils/introspection/ERC165.sol";
+
+/// @notice Configurable `IJBFeelessHook` mock for unit tests.
+/// @dev `mode` controls behavior of `isFeeless`:
+///   - 0: returns `defaultResult` for any (projectId, addr)
+///   - 1: reverts with `Nope()`
+///   - 2: reverts via `require(false, "nope")`
+///   - 3: returns `true` iff `(projectId, addr)` has been allowlisted via `setAllowed`
+contract MockFeelessHook is ERC165, IJBFeelessHook {
+    error Nope();
+
+    uint256 public mode;
+    bool public defaultResult;
+    mapping(uint256 => mapping(address => bool)) internal _allowed;
+
+    function setMode(uint256 newMode) external {
+        mode = newMode;
+    }
+
+    function setDefaultResult(bool result) external {
+        defaultResult = result;
+    }
+
+    function setAllowed(uint256 projectId, address addr, bool flag) external {
+        _allowed[projectId][addr] = flag;
+    }
+
+    function isFeeless(uint256 projectId, address addr) external view override returns (bool) {
+        if (mode == 1) revert Nope();
+        if (mode == 2) require(false, "nope");
+        if (mode == 3) return _allowed[projectId][addr];
+        return defaultResult;
+    }
+
+    function supportsInterface(bytes4 interfaceId) public view override(IERC165, ERC165) returns (bool) {
+        return interfaceId == type(IJBFeelessHook).interfaceId || super.supportsInterface(interfaceId);
+    }
+}
+
+/// @notice Non-conforming "hook" that returns false for the IJBFeelessHook interfaceId in ERC-165.
+/// @dev Used to test the `setFeelessHook` validation guard. Has the `isFeeless` selector so the
+/// call shape matches, but its `supportsInterface` advertises only IERC165, not IJBFeelessHook.
+contract MockNonConformingFeelessHook is ERC165 {
+    function isFeeless(uint256, address) external pure returns (bool) {
+        return true;
+    }
+}
+
+/// @notice "Hook" with no `supportsInterface` at all — `setFeelessHook` should revert when this is passed.
+contract MockEoaLikeFeelessHook {
+    function isFeeless(uint256, address) external pure returns (bool) {
+        return true;
+    }
+}