@bananapus/core-v6 0.0.79 → 0.0.81

package/README.md

@@ -81,7 +81,6 @@ The shortest reading path is:
 - Data hooks and cash-out hooks can change economics and side effects. They are part of the protocol surface.
 - Permission checks are not always against the project owner. Some flows are scoped to the token holder instead.
 - Preview and execution are intentionally close, but callers should still treat them as separate surfaces when hooks or routing can change behavior.
-- Fee-bearing cash-out, payout, and allowance calls can carry a referral project ID. This credits fee volume; it does not redirect the fee itself.
 
 ## Where State Lives
 
@@ -89,7 +88,6 @@ The shortest reading path is:
 - controller and terminal routing: `JBDirectory`
 - ruleset history and activation: `JBRulesets`
 - balances, surplus, fees, and reclaim accounting: `JBTerminalStore`
-- referral fee-volume accounting: `JBTerminalStore`
 - operator authority: `JBPermissions`
 
 When a flow is unclear, read the contract that owns the state before the contract that forwards into it.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bananapus/core-v6",
-  "version": "0.0.79",
+  "version": "0.0.81",
   "license": "MIT",
   "repository": {
     "type": "git",

package/references/entrypoints.md

@@ -61,9 +61,9 @@ The core Juicebox V6 protocol on EVM: a modular system for launching treasury-ba
 | Function | What it does |
 |----------|--------------|
 | `pay(uint256 projectId, address token, uint256 amount, address beneficiary, uint256 minReturnedTokens, string memo, bytes metadata)` | Pays a project. Mints project tokens to beneficiary based on ruleset weight. Returns token count. |
-| `cashOutTokensOf(address holder, uint256 projectId, uint256 cashOutCount, address tokenToReclaim, uint256 minTokensReclaimed, address payable beneficiary, bytes metadata, uint256 referralProjectId)` | Burns project tokens and reclaims surplus terminal tokens via bonding curve. Optional referral credits protocol fee volume. |
-| `sendPayoutsOf(uint256 projectId, address token, uint256 amount, uint256 currency, uint256 minTokensPaidOut, uint256 referralProjectId)` | Distributes payouts from the project's balance to its payout split group, up to the payout limit. Optional referral credits protocol fee volume. |
-| `useAllowanceOf(uint256 projectId, address token, uint256 amount, uint256 currency, uint256 minTokensPaidOut, address payable beneficiary, address payable feeBeneficiary, string memo, uint256 referralProjectId)` | Withdraws from the project's surplus allowance to a beneficiary. The `feeBeneficiary` receives tokens minted by the fee payment. Optional referral credits protocol fee volume. |
+| `cashOutTokensOf(address holder, uint256 projectId, uint256 cashOutCount, address tokenToReclaim, uint256 minTokensReclaimed, address payable beneficiary, bytes metadata)` | Burns project tokens and reclaims surplus terminal tokens via bonding curve. |
+| `sendPayoutsOf(uint256 projectId, address token, uint256 amount, uint256 currency, uint256 minTokensPaidOut)` | Distributes payouts from the project's balance to its payout split group, up to the payout limit. |
+| `useAllowanceOf(uint256 projectId, address token, uint256 amount, uint256 currency, uint256 minTokensPaidOut, address payable beneficiary, address payable feeBeneficiary, string memo)` | Withdraws from the project's surplus allowance to a beneficiary. The `feeBeneficiary` receives tokens minted by the fee payment. |
 | `addToBalanceOf(uint256 projectId, address token, uint256 amount, bool shouldReturnHeldFees, string memo, bytes metadata)` | Adds funds to a project's balance without minting tokens. Can unlock held fees. |
 | `migrateBalanceOf(uint256 projectId, address token, IJBTerminal to)` | Migrates a project's token balance to another terminal. Requires `allowTerminalMigration`. |
 | `processHeldFeesOf(uint256 projectId, address token, uint256 count)` | Processes up to `count` held fees for a project, sending them to the fee beneficiary project. |
@@ -74,7 +74,6 @@ The core Juicebox V6 protocol on EVM: a modular system for launching treasury-ba
 | `previewPayFor(uint256 projectId, address token, uint256 amount, address beneficiary, bytes metadata)` | Simulates a full payment including the reserved/beneficiary token split. Returns `(ruleset, beneficiaryTokenCount, reservedTokenCount, hookSpecifications)`. Composes `STORE.previewPayFrom` + `controller.previewMintOf`. |
 | `previewCashOutFrom(address holder, uint256 projectId, uint256 cashOutCount, address tokenToReclaim, address payable beneficiary, bytes metadata)` | Simulates a full cash out including bonding curve and data hook effects. Cash-out data hooks may alter pricing inputs, but not the caller-supplied burn count. Returns `(ruleset, reclaimAmount, cashOutTaxRate, hookSpecifications)`. Delegates to `STORE.previewCashOutFrom`. |
 | `heldFeesOf(uint256 projectId, address token, uint256 count)` | Returns up to `count` held fees for a project/token. |
-| `currentReferralProjectId()` | Returns the in-flight packed referral `(chainId << 48) | projectId`, or 0 outside a fee-bearing call. |
 
 ### JBTerminalStore
 
@@ -94,11 +93,8 @@ The core Juicebox V6 protocol on EVM: a modular system for launching treasury-ba
 | `currentTotalReclaimableSurplusOf(uint256 projectId, uint256 cashOutCount, uint256 decimals, uint256 currency)` | Convenience view: reclaimable surplus across all terminals and all tokens. |
 | `currentSurplusOf(uint256 projectId, IJBTerminal[] terminals, address[] tokens, uint256 decimals, uint256 currency)` | Returns the current surplus across specified terminals and tokens. Empty arrays default to all. |
 | `currentTotalSurplusOf(uint256 projectId, uint256 decimals, uint256 currency)` | Convenience view: total surplus across all terminals and all tokens. |
-| `feeVolumeByReferralOf(address terminal, uint256 referralChainId, uint256 referralProjectId)` | Returns cumulative protocol fee volume credited to a referrer through a terminal. |
 | `previewPayFrom(address terminal, address payer, JBTokenAmount amount, uint256 projectId, address beneficiary, bytes metadata)` | Simulates a payment without modifying state. Uses the explicit `terminal` parameter for balance/surplus lookups. Invokes data hooks if configured. Returns ruleset, token count, and hook specifications. |
 | `previewCashOutFrom(address terminal, address holder, uint256 projectId, uint256 cashOutCount, address tokenToReclaim, bool beneficiaryIsFeeless, bytes metadata)` | Simulates a cash out without modifying state. Uses the explicit `terminal` parameter for balance/surplus lookups. Invokes data hooks if configured, including any pricing-only adjustments they return. Returns ruleset, reclaim amount, tax rate, and hook specifications. |
-| `recordFeeReferralCreditOf(uint256 referralProjectId, JBTokenAmount amount)` | Credits normalized fee volume to a packed referral project for the calling terminal. No-ops for zero referral, zero amount, or missing price feed. |
-| `totalFeeVolumeOf(address terminal)` | Returns total referral-creditable fee volume recorded for a terminal. |
 
 ### JBRulesets
 

package/references/types-errors-events.md

@@ -17,7 +17,7 @@ Use this file when you need deeper protocol reference material after the repo-lo
 | `JBCurrencyAmount` | `amount (uint224)`, `currency (uint32)` | Payout limits and surplus allowances |
 | `JBFundAccessLimitGroup` | `terminal (address)`, `token (address)`, `payoutLimits (JBCurrencyAmount[])`, `surplusAllowances (JBCurrencyAmount[])` | `JBRulesetConfig.fundAccessLimitGroups` |
 | `JBPermissionsData` | `operator (address)`, `projectId (uint64)`, `permissionIds (uint8[])` | `setPermissionsFor()` input |
-| `JBFee` | `amount (uint224)`, `referralChainId (uint32)`, `beneficiary (address)`, `unlockTimestamp (uint48)`, `referralProjectId (uint48)` | Held fees in `JBMultiTerminal`; referral fields preserve fee attribution until processing |
+| `JBFee` | `amount (uint224)`, `beneficiary (address)`, `unlockTimestamp (uint48)` | Held fees in `JBMultiTerminal` |
 | `JBSingleAllowance` | `sigDeadline (uint256)`, `amount (uint160)`, `expiration (uint48)`, `nonce (uint48)`, `signature (bytes)` | Permit2 allowance in terminal payments |
 | `JBRulesetWithMetadata` | `ruleset (JBRuleset)`, `metadata (JBRulesetMetadata)` | `allRulesetsOf()`, `currentRulesetOf()` return values |
 | `JBRulesetWeightCache` | `weight (uint112)`, `weightCutMultiple (uint168)` | Weight caching for long-running rulesets in `JBRulesets` |
@@ -93,8 +93,7 @@ Use this file when you need deeper protocol reference material after the repo-lo
 - `JBProjects` constructor optionally mints project #1 to `feeProjectOwner` -- if `address(0)`, no fee project is created
 - `JBMultiTerminal` derives `DIRECTORY` from the provided `store` in its constructor -- not passed directly
 - `JBPrices.pricePerUnitOf()` checks project direct feeds, project inverse feeds, default direct feeds, then default inverse feeds. It skips feeds that revert or return zero.
-- `useAllowanceOf()` takes 9 args including `address payable feeBeneficiary` and `uint256 referralProjectId` -- do NOT omit them
-- `sendPayoutsOf()` and `cashOutTokensOf()` also take `uint256 referralProjectId`; pass `0` for no referral credit
+- `useAllowanceOf()` takes 8 args including `address payable feeBeneficiary` -- do NOT omit it
 - `JBFeelessAddresses.isFeelessFor()` takes 3 args: `(addr, projectId, caller)`. The optional hook can use `caller` to scope dynamic grants.
 - Cash out tax rate of 0% = proportional (1:1) redemption; 100% = nothing reclaimable (all surplus locked). Do NOT confuse with a "cash out rate" where 100% means full redemption.
 - `cashOutTaxRate` in `JBRulesetMetadata` is `uint16` (max 10,000 basis points), NOT 9-decimal precision
@@ -214,7 +213,6 @@ The most important events for indexing and off-chain monitoring. Indexed params
 | `ProcessFee` | `IJBFeeTerminal` | `projectId*`, `token*`, `amount*`, `wasHeld`, `beneficiary` |
 | `ReturnHeldFees` | `IJBFeeTerminal` | `projectId*`, `token*`, `amount*`, `returnedFees`, `leftoverAmount` |
 | `FeeReverted` | `IJBFeeTerminal` | `projectId*`, `token*`, `feeProjectId*`, `amount`, `reason` |
-| `ReferralCredit` | `IJBTerminalStore` | `terminal*`, `referralChainId*`, `referralProjectId*`, `amount`, `newTotal` |
 | `Create` | `IJBProjects` | `projectId*`, `owner*` |
 | `SetTokenMetadata` | `IJBTokens` | `projectId*`, `name`, `symbol` |
 | `OperatorPermissionsSet` | `IJBPermissions` | (operator, account, projectId, permissionIds, packed, caller) |

package/src/JBMultiTerminal.sol

@@ -146,25 +146,6 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
     /// @custom:param token The token the fees are held in.
     mapping(uint256 projectId => mapping(address token => uint256)) internal _nextHeldFeeIndexOf;
 
-    //*********************************************************************//
-    // --------------- public transient stored properties --------------- //
-    //*********************************************************************//
-
-    /// @notice Caller-originated referrer reference for the duration of the current external fee-paying call.
-    /// @dev Encoded as `(referralChainId << 48) | referralProjectId`: bits [79:48] are the referrer's EIP-155 chain
-    /// ID (uint32), bits [47:0] are the referrer's project ID on that chain (uint48). The upper bits of the
-    /// uint256 are reserved for future encoding extensions.
-    /// @dev The entry points `cashOutTokensOf`, `sendPayoutsOf`, and `useAllowanceOf` auto-resolve a bare project ID
-    /// (non-zero project, zero chain bits) to the current execution chain via `block.chainid` before writing this
-    /// slot. So storage (and indexers reading `feeVolumeByReferralOf`) always observe a fully-resolved
-    /// `(chainId, projectId)` pair — callers can write `referralProjectId: someProjectId` without manually packing
-    /// their own chain ID.
-    /// @dev Set by the three entry points via the `_setReferralProjectId` save-restore wrapper. Read inside `_pay`
-    /// to credit `feeVolumeByReferralOf` when the fee project's pay call is recorded locally.
-    /// @dev Public so pay, cash out, and split hooks can introspect which referral originated the in-flight call (e.g.
-    /// to apply referral-specific logic). Reads `0` outside any fee-paying call.
-    uint256 public transient override currentReferralProjectId;
-
     //*********************************************************************//
     // -------------- internal transient stored properties -------------- //
     //*********************************************************************//
@@ -177,9 +158,6 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
     /// the fee basis to `executePayout`.
     uint256 internal transient _internalSplitPayProjectId;
 
-    /// @notice The in-flight fee amount that can credit `currentReferralProjectId`.
-    uint256 internal transient _feeReferralCreditAmount;
-
     //*********************************************************************//
     // -------------------------- constructor ---------------------------- //
     //*********************************************************************//
@@ -303,10 +281,6 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
     /// data hook and cash out hooks if applicable.
     /// @param metadata Bytes to send along to the emitted event, as well as the data hook and cash out hooks if
     /// applicable.
-    /// @param referralProjectId Optional referrer reference to credit with the protocol fee volume taken by this
-    /// call, encoded as `(referralChainId << 48) | referralProjectId` (chain ID in the upper 32 bits, project ID
-    /// in the lower 48). A bare project ID (chain bits zero) is auto-resolved to the current chain via `block.chainid`.
-    /// Pass `0` for no referral credit.
     /// @return reclaimAmount The amount of **terminal tokens** sent to `beneficiary` in exchange for the burned project
     /// tokens, as a fixed point number with the same number of decimals as the terminal token's accounting context.
     function cashOutTokensOf(
@@ -316,8 +290,7 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
         address tokenToReclaim,
         uint256 minTokensReclaimed,
         address payable beneficiary,
-        bytes calldata metadata,
-        uint256 referralProjectId
+        bytes calldata metadata
     )
         external
         override
@@ -326,9 +299,6 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
         // Enforce permissions.
         _requirePermissionFrom({account: holder, projectId: projectId, permissionId: JBPermissionIds.CASH_OUT_TOKENS});
 
-        // Save-restore the transient referral slot so nested reentrant fee-paying calls don't pollute each other.
-        uint256 priorReferral = _setReferralProjectId(referralProjectId);
-
         reclaimAmount = _cashOutTokensOf({
             holder: holder,
             projectId: projectId,
@@ -338,8 +308,6 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
             metadata: metadata
         });
 
-        _setReferralProjectId(priorReferral);
-
         // The amount being reclaimed must be at least as much as was expected.
         _checkMin({value: reclaimAmount, min: minTokensReclaimed});
     }
@@ -441,7 +409,7 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
                 revert JBMultiTerminal_MintNotAllowed({projectId: projectId, terminal: address(terminal)});
             }
 
-            // Send the `projectId` in the metadata as a referral.
+            // Send the source `projectId` in the metadata for same-terminal split-pay accounting.
             bytes memory metadata = bytes(abi.encodePacked(projectId));
 
             // Add to balance if preferred.
@@ -724,9 +692,6 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
     /// @param token The token to process held fees for.
     /// @param count The number of fees to process.
     function processHeldFeesOf(uint256 projectId, address token, uint256 count) external override {
-        // Preserve any in-flight referral context if this function is reached through reentrancy.
-        uint256 previousReferralProjectId = currentReferralProjectId;
-
         // Keep a reference to the terminal that'll receive the fees.
         IJBTerminal feeTerminal = _primaryTerminalOf({projectId: JBConstants.FEE_BENEFICIARY_PROJECT_ID, token: token});
 
@@ -761,11 +726,6 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
                 _nextHeldFeeIndexOf[projectId][token] = currentIndex + 1;
             }
 
-            // Restore the originating fee-paying call's referral project for this fee's processing so the credit in
-            // `_processFee` attributes to the right (chain, project) pair. Reconstructs the packed encoding from the
-            // two struct halves: `(chainId << 48) | projectId`.
-            currentReferralProjectId = (uint256(heldFee.referralChainId) << 48) | uint256(heldFee.referralProjectId);
-
             // Process the standard fee on the original gross amount recorded when the held fee was created.
             _processFee({
                 projectId: projectId,
@@ -781,9 +741,6 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
             }
         }
 
-        // Restore the previous transient value so reentrant held-fee processing does not erase an outer referral.
-        currentReferralProjectId = previousReferralProjectId;
-
         // If all held fees have been processed, reset the array and index entirely to bound storage growth.
         if (
             _nextHeldFeeIndexOf[projectId][token] >= _heldFeesOf[projectId][token].length
@@ -810,29 +767,20 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
     /// in terms of the token's accounting context currency), as a fixed point number with the same number of decimals
     /// as the token's accounting context. If the amount of tokens paid out would be less than this amount, the send is
     /// reverted.
-    /// @param referralProjectId Optional referrer reference to credit with the protocol fee volume taken by this
-    /// call, encoded as `(referralChainId << 48) | referralProjectId` (chain ID in the upper 32 bits, project ID
-    /// in the lower 48). A bare project ID (chain bits zero) is auto-resolved to the current chain via `block.chainid`.
-    /// Pass `0` for no referral credit.
     /// @return amountPaidOut The total amount paid out.
     function sendPayoutsOf(
         uint256 projectId,
         address token,
         uint256 amount,
         uint256 currency,
-        uint256 minTokensPaidOut,
-        uint256 referralProjectId
+        uint256 minTokensPaidOut
     )
         external
         override
         returns (uint256 amountPaidOut)
     {
-        uint256 priorReferral = _setReferralProjectId(referralProjectId);
-
         amountPaidOut = _sendPayoutsOf({projectId: projectId, token: token, amount: amount, currency: currency});
 
-        _setReferralProjectId(priorReferral);
-
         // The amount being paid out must be at least as much as was expected.
         _checkMin({value: amountPaidOut, min: minTokensPaidOut});
     }
@@ -855,10 +803,6 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
     /// @param feeBeneficiary The address that receives the **project tokens** minted by the fee project in exchange
     /// for the protocol fee paid in terminal tokens.
     /// @param memo A memo to pass along to the emitted event.
-    /// @param referralProjectId Optional referrer reference to credit with the protocol fee volume taken by this
-    /// call, encoded as `(referralChainId << 48) | referralProjectId` (chain ID in the upper 32 bits, project ID
-    /// in the lower 48). A bare project ID (chain bits zero) is auto-resolved to the current chain via `block.chainid`.
-    /// Pass `0` for no referral credit.
     /// @return netAmountPaidOut The number of **terminal tokens** sent to `beneficiary`, net of the protocol fee, as a
     /// fixed point number with the same number of decimals as the terminal token's accounting context.
     function useAllowanceOf(
@@ -869,8 +813,7 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
         uint256 minTokensPaidOut,
         address payable beneficiary,
         address payable feeBeneficiary,
-        string calldata memo,
-        uint256 referralProjectId
+        string calldata memo
     )
         external
         override
@@ -882,8 +825,6 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
         // Enforce permissions.
         _requirePermissionFrom({account: owner, projectId: projectId, permissionId: JBPermissionIds.USE_ALLOWANCE});
 
-        uint256 priorReferral = _setReferralProjectId(referralProjectId);
-
         netAmountPaidOut = _useAllowanceOf({
             projectId: projectId,
             owner: owner,
@@ -895,8 +836,6 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
             memo: memo
         });
 
-        _setReferralProjectId(priorReferral);
-
         // The amount being withdrawn must be at least as much as was expected.
         _checkMin({value: netAmountPaidOut, min: minTokensPaidOut});
     }
@@ -1766,17 +1705,6 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
         // Keep a reference to the token amount to forward to the store.
         JBTokenAmount memory tokenAmount = _tokenAmountOf({projectId: projectId, token: token, value: amount});
 
-        // Credit only the one pay call currently being made by `_processFee`. Ordinary split pays to project #1 can
-        // happen while `currentReferralProjectId` is set, but they are not protocol-fee payments. Consume this before
-        // recording the payment so fee-project data hooks cannot reenter and use the in-flight credit.
-        if (
-            projectId == JBConstants.FEE_BENEFICIARY_PROJECT_ID && currentReferralProjectId != 0
-                && _feeReferralCreditAmount != 0
-        ) {
-            delete _feeReferralCreditAmount;
-            STORE.recordFeeReferralCreditOf({referralProjectId: currentReferralProjectId, amount: tokenAmount});
-        }
-
         // Record the payment.
         // Keep a reference to the ruleset the payment is being made during.
         // Keep a reference to the pay hook specifications.
@@ -1866,11 +1794,9 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
     )
         internal
     {
-        if (feeTerminal == IJBTerminal(address(this))) _feeReferralCreditAmount = amount;
         try this.executeProcessFee({
             projectId: projectId, token: token, amount: amount, beneficiary: beneficiary, feeTerminal: feeTerminal
         }) {
-            delete _feeReferralCreditAmount;
             emit ProcessFee({
                 projectId: projectId,
                 token: token,
@@ -1880,7 +1806,6 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
                 caller: _msgSender()
             });
         } catch (bytes memory reason) {
-            delete _feeReferralCreditAmount;
             // Fee processing is fail-open for project liveness: a broken project #1 terminal or fee route must not
             // trap payouts, cash outs, allowances, held-fee processing, or terminal migration. The fee is forgiven,
             // credited back to the originating project on this terminal, and surfaced through `FeeReverted`.
@@ -2074,22 +1999,13 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
             _checkFitsIn({value: amount, max: type(uint224).max});
 
             // Store the gross amount so future repayments can recover the corresponding fee.
-            // Capture the in-flight `currentReferralProjectId` so attribution survives the 28-day hold window —
-            // by the time `processHeldFeesOf` runs, the transient slot has been cleared. The encoded
-            // `(chainId << 48) | projectId` pair in the transient slot is decomposed into its two halves so the
-            // struct stays in 2 storage slots.
-            uint256 encodedReferral = currentReferralProjectId;
             _heldFeesOf[projectId][token].push(
                 JBFee({
                     // forge-lint: disable-next-line(unsafe-typecast)
                     amount: uint224(amount),
-                    // forge-lint: disable-next-line(unsafe-typecast)
-                    referralChainId: uint32(encodedReferral >> 48),
                     beneficiary: beneficiary,
                     // forge-lint: disable-next-line(unsafe-typecast)
-                    unlockTimestamp: uint48(block.timestamp + _FEE_HOLDING_SECONDS),
-                    // forge-lint: disable-next-line(unsafe-typecast)
-                    referralProjectId: uint48(encodedReferral)
+                    unlockTimestamp: uint48(block.timestamp + _FEE_HOLDING_SECONDS)
                 })
             );
 
@@ -2360,22 +2276,4 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
     function _feeAmountFrom(uint256 amount) private pure returns (uint256) {
         return JBFees.standardFeeAmountFrom(amount);
     }
-
-    /// @notice Set the transient `currentReferralProjectId` slot and return the prior value (for save-restore).
-    /// @dev Returning the prior value lets the caller restore it after the inner call completes, which is required
-    /// to keep nested reentrant fee-paying calls from polluting each other. Per EIP-1153, a revert in the inner
-    /// call also reverts the transient write, so no explicit cleanup on the failure path is needed.
-    /// @dev Backfills `block.chainid` into the chain-bits half of the encoding when the caller passed a bare
-    /// project ID (non-zero project, zero chain). This lets callers write `referralProjectId: someProjectId`
-    /// without manually packing their own chain ID — the entry point resolves it to the current execution chain,
-    /// so storage and indexers always see a fully-resolved `(chainId, projectId)` pair.
-    /// @param referralProjectId The new value to write into the transient slot.
-    /// @return prior The value previously stored in the slot.
-    function _setReferralProjectId(uint256 referralProjectId) private returns (uint256 prior) {
-        if (referralProjectId != 0 && referralProjectId >> 48 == 0) {
-            referralProjectId |= block.chainid << 48;
-        }
-        prior = currentReferralProjectId;
-        currentReferralProjectId = referralProjectId;
-    }
 }

package/src/JBTerminalStore.sol

@@ -92,26 +92,6 @@ contract JBTerminalStore is IJBTerminalStore {
         public
         override balanceOf;
 
-    /// @notice Cumulative fee payment amount credited to a referrer (chainId, projectId) pair as a result of
-    /// fee-paying calls that originated through a given terminal.
-    /// @dev Written by terminals via `recordFeeReferralCreditOf`; the writing terminal is `msg.sender`, so a caller
-    /// can only pollute their own bucket.
-    /// @dev Nested by chain ID then project ID so off-chain consumers can read the credit for a specific
-    /// `(chainId, projectId)` directly without re-packing the encoded form themselves.
-    /// @custom:param terminal The terminal that originated the fee-paying call.
-    /// @custom:param referralChainId The EIP-155 chain ID of the referrer's home chain.
-    /// @custom:param referralProjectId The referrer's bare project ID on `referralChainId`.
-    mapping(address terminal => mapping(uint256 referralChainId => mapping(uint256 referralProjectId => uint256)))
-        public
-        override feeVolumeByReferralOf;
-
-    /// @notice Cumulative fee payment amount credited across all referral projects for a given terminal.
-    /// @dev Updated in lockstep with `feeVolumeByReferralOf` so consumers can compute a referrer's pro-rata share
-    /// in a single SLOAD pair without enumerating referrers. Used as the denominator by split hooks that distribute
-    /// rewards proportional to attributed fee volume.
-    /// @custom:param terminal The terminal that originated the fee-paying calls.
-    mapping(address terminal => uint256) public override totalFeeVolumeOf;
-
     /// @notice The currency-denominated amount of funds that a project has already paid out from its payout limit
     /// during the current ruleset for each terminal, in terms of the payout limit's currency.
     /// @dev Increases as projects pay out funds.
@@ -365,22 +345,6 @@ contract JBTerminalStore is IJBTerminalStore {
         }
     }
 
-    /// @notice Credit a referral project with a fee payment amount routed through `msg.sender` (the calling terminal).
-    /// @dev Called by `JBMultiTerminal._pay` after a payment lands on the fee project. Permissionless: writes are
-    /// scoped to `msg.sender`'s slots so an arbitrary caller can only pollute their own buckets — off-chain
-    /// consumers should filter on known terminal addresses. The amount is normalized to `NATIVE_TOKEN` units
-    /// (18 decimals) here in the store (where `PRICES` is available) so all credits share a common denominator.
-    /// @param referralProjectId The referral project to credit.
-    /// @param amount The fee amount paid by the originating fee-take call (raw value, decimals, currency).
-    function recordFeeReferralCreditOf(uint256 referralProjectId, JBTokenAmount calldata amount) external override {
-        _creditFeeReferral({
-            referralProjectId: referralProjectId,
-            amount: _normalizeToNativeTokenUnits({
-                value: amount.value, decimals: amount.decimals, currency: amount.currency
-            })
-        });
-    }
-
     /// @notice Records a payment — calculates how many project tokens to mint based on the payment amount and the
     /// current ruleset's weight. Uses the data hook if configured, otherwise mints proportionally.
     /// @dev Called by the terminal after accepting funds. Updates the project's recorded balance.
@@ -1442,80 +1406,4 @@ contract JBTerminalStore is IJBTerminalStore {
             }
         }
     }
-
-    //*********************************************************************//
-    // -------------------------- private helpers ------------------------ //
-    //*********************************************************************//
-
-    /// @notice Credit a referrer with a fee payment amount. Internal counterpart of `recordFeeReferralCreditOf` —
-    /// both write to the same slots and emit the same event.
-    /// @dev No-op when `referralProjectId == 0` or `amount == 0`.
-    /// @dev Unpacks the encoded `(chainId << 48) | projectId` form into the nested mapping at write-time so the
-    /// public getter exposes `(terminal, chainId, projectId) → cumulative` directly. The event topics carry the
-    /// two halves separately as well.
-    /// @param referralProjectId The packed `(chainId << 48) | projectId` referrer reference to credit.
-    /// @param amount The fee amount to credit.
-    function _creditFeeReferral(uint256 referralProjectId, uint256 amount) private {
-        if (referralProjectId == 0 || amount == 0) return;
-
-        uint256 referralChainId = referralProjectId >> 48;
-        uint256 bareProjectId = referralProjectId & ((1 << 48) - 1);
-
-        feeVolumeByReferralOf[msg.sender][referralChainId][bareProjectId] += amount;
-        uint256 newTotal = totalFeeVolumeOf[msg.sender] + amount;
-        totalFeeVolumeOf[msg.sender] = newTotal;
-
-        emit ReferralCredit({
-            terminal: msg.sender,
-            referralChainId: referralChainId,
-            referralProjectId: bareProjectId,
-            amount: amount,
-            newTotal: newTotal,
-            caller: msg.sender
-        });
-    }
-
-    /// @notice Normalize a fee-token amount to `JBConstants.NATIVE_TOKEN` units at 18 decimals.
-    /// @dev Two-step: first adjust decimals to 18 via `JBFixedPointNumber.adjustDecimals`, then convert currency
-    /// via `PRICES.pricePerUnitOf` using the fee project's price feeds. If no price feed exists for the pair, the
-    /// `try` block catches the revert and the credit is silently skipped — the payment itself still succeeds.
-    /// @param value The amount in the source token's native decimals.
-    /// @param decimals The source token's decimals.
-    /// @param currency The source token's accounting-context currency (`uint32(uint160(token))`).
-    /// @return normalized The amount expressed in `NATIVE_TOKEN` units (18 decimals), or 0 if conversion failed.
-    function _normalizeToNativeTokenUnits(
-        uint256 value,
-        uint256 decimals,
-        uint256 currency
-    )
-        private
-        view
-        returns (uint256 normalized)
-    {
-        // Adjust the source amount up/down to 18 decimals so all credits share a common precision.
-        normalized = decimals == _MAX_FIXED_POINT_FIDELITY
-            ? value
-            : JBFixedPointNumber.adjustDecimals({
-                value: value, decimals: decimals, targetDecimals: _MAX_FIXED_POINT_FIDELITY
-            });
-
-        if (normalized == 0 || currency == JBConstants.NATIVE_TOKEN_CURRENCY) return normalized;
-
-        // Convert from the source currency to NATIVE_TOKEN via the fee project's price feeds. A missing feed
-        // reverts inside `PRICES.pricePerUnitOf` — caught here so the payment is not blocked.
-        try PRICES.pricePerUnitOf({
-            projectId: JBConstants.FEE_BENEFICIARY_PROJECT_ID,
-            pricingCurrency: currency,
-            unitCurrency: JBConstants.NATIVE_TOKEN_CURRENCY,
-            decimals: _MAX_FIXED_POINT_FIDELITY
-        }) returns (
-            uint256 price
-        ) {
-            normalized = price == 0
-                ? 0
-                : mulDiv({x: normalized, y: 10 ** _MAX_FIXED_POINT_FIDELITY, denominator: price});
-        } catch {
-            normalized = 0;
-        }
-    }
 }

package/src/interfaces/IJBCashOutTerminal.sol

@@ -84,8 +84,6 @@ interface IJBCashOutTerminal is IJBTerminal {
     /// @param minTokensReclaimed The minimum number of terminal tokens that must be reclaimed.
     /// @param beneficiary The address to send the reclaimed terminal tokens to.
     /// @param metadata Extra data to send to the data hook and cash out hooks.
-    /// @param referralProjectId Optional project to credit with the protocol fee volume taken by this call. Pass `0`
-    /// for no referral credit.
     /// @return reclaimAmount The number of terminal tokens reclaimed from the project's surplus.
     function cashOutTokensOf(
         address holder,
@@ -94,8 +92,7 @@ interface IJBCashOutTerminal is IJBTerminal {
         address tokenToReclaim,
         uint256 minTokensReclaimed,
         address payable beneficiary,
-        bytes calldata metadata,
-        uint256 referralProjectId
+        bytes calldata metadata
     )
         external
         returns (uint256 reclaimAmount);

package/src/interfaces/IJBMultiTerminal.sol

@@ -31,19 +31,6 @@ interface IJBMultiTerminal is IJBTerminal, IJBFeeTerminal, IJBCashOutTerminal, I
     /// @notice The contract that manages token minting and burning.
     function TOKENS() external view returns (IJBTokens);
 
-    /// @notice The caller-originated referrer reference for the in-flight fee-paying external call.
-    /// @dev Encoded as `(referralChainId << 48) | referralProjectId`: bits [79:48] are the referrer's EIP-155 chain
-    /// ID (uint32), bits [47:0] are the referrer's project ID on that chain (uint48). Allows a referrer with a
-    /// project on chain X to be credited for activity on chain Y. A bare project ID (chain bits zero) is auto-
-    /// resolved to the current execution chain via `block.chainid` at the entry point, so storage and indexers
-    /// always see a fully-resolved `(chainId, projectId)` pair.
-    /// @dev Backed by transient storage. Set by `cashOutTokensOf`, `sendPayoutsOf`, and `useAllowanceOf` (save-
-    /// restore wrapper) so hooks invoked during that call (pay hooks, cash out hooks, split hooks) can introspect
-    /// which referrer originated the activity. Reads `0` outside any fee-paying call.
-    /// @dev Per-referrer cumulative fee payment amounts credited via this terminal are stored in
-    /// `JBTerminalStore.feeVolumeByReferralOf(address terminal, uint256 referralChainId, uint256 referralProjectId)`.
-    function currentReferralProjectId() external view returns (uint256);
-
     /// @notice The cumulative amount of fee-free intra-terminal payouts a project has received for a given token.
     /// @dev Incremented each time a fee-free payout lands (same terminal, no fee charged) and consumed during
     /// zero-tax cash outs to prevent a round-trip fee bypass (intra-terminal payout -> zero-tax cash out). Exposed

package/src/interfaces/IJBPayoutTerminal.sol

@@ -102,16 +102,13 @@ interface IJBPayoutTerminal is IJBTerminal {
     /// @param amount The total amount of tokens to pay out.
     /// @param currency The currency the amount is denominated in.
     /// @param minTokensPaidOut The minimum number of terminal tokens expected to be paid out.
-    /// @param referralProjectId Optional project to credit with the protocol fee volume taken by this call. Pass `0`
-    /// for no referral credit.
     /// @return amountPaidOut The total amount paid out.
     function sendPayoutsOf(
         uint256 projectId,
         address token,
         uint256 amount,
         uint256 currency,
-        uint256 minTokensPaidOut,
-        uint256 referralProjectId
+        uint256 minTokensPaidOut
     )
         external
         returns (uint256 amountPaidOut);
@@ -125,8 +122,6 @@ interface IJBPayoutTerminal is IJBTerminal {
     /// @param beneficiary The address to send the funds to.
     /// @param feeBeneficiary The address that will receive any project tokens minted from fees.
     /// @param memo A memo to pass along to the emitted event.
-    /// @param referralProjectId Optional project to credit with the protocol fee volume taken by this call. Pass `0`
-    /// for no referral credit.
     /// @return netAmountPaidOut The net amount paid out to the beneficiary after fees.
     function useAllowanceOf(
         uint256 projectId,
@@ -136,8 +131,7 @@ interface IJBPayoutTerminal is IJBTerminal {
         uint256 minTokensPaidOut,
         address payable beneficiary,
         address payable feeBeneficiary,
-        string calldata memo,
-        uint256 referralProjectId
+        string calldata memo
     )
         external
         returns (uint256 netAmountPaidOut);

package/src/interfaces/IJBTerminalStore.sol

@@ -15,25 +15,6 @@ import {JBTokenAmount} from "../structs/JBTokenAmount.sol";
 /// allowances, calculates token issuance per payment, and determines cash-out reclaim amounts via the bonding curve.
 /// Terminals delegate all state-changing accounting to this contract.
 interface IJBTerminalStore {
-    /// @notice Emitted when a referrer is credited with a fee payment amount.
-    /// @dev `referralChainId` and `referralProjectId` are emitted as separate indexed topics so off-chain consumers
-    /// can filter directly on either dimension. The public `feeVolumeByReferralOf` getter exposes the same unpacked
-    /// `(terminal, referralChainId, referralProjectId)` tuple.
-    /// @param terminal The terminal that originated the fee-paying call (`msg.sender` on `recordFeeReferralCreditOf`).
-    /// @param referralChainId The EIP-155 chain ID of the referrer's home chain.
-    /// @param referralProjectId The referrer's bare project ID on `referralChainId` (no chain bits).
-    /// @param amount The fee amount credited, in the terminal's accounting-context units.
-    /// @param newTotal The new value of `totalFeeVolumeOf[terminal]` after this credit.
-    /// @param caller The address that recorded the credit.
-    event ReferralCredit(
-        address indexed terminal,
-        uint256 indexed referralChainId,
-        uint256 indexed referralProjectId,
-        uint256 amount,
-        uint256 newTotal,
-        address caller
-    );
-
     /// @notice The directory of terminals and controllers for projects.
     function DIRECTORY() external view returns (IJBDirectory);
 
@@ -161,27 +142,6 @@ interface IJBTerminalStore {
         view
         returns (uint256);
 
-    /// @notice The cumulative fee payment amount credited to a referrer (chainId, projectId) pair as a result of
-    /// fee-paying calls that originated through a given terminal.
-    /// @dev Written by terminals via `recordFeeReferralCreditOf` — `msg.sender` is recorded as the writing terminal,
-    /// so a malicious caller can only pollute their own slot. Off-chain consumers should filter on known terminal
-    /// addresses.
-    /// @dev Nested by chain ID then project ID so consumers can read the credit for a specific
-    /// `(chainId, projectId)` directly without re-packing the encoded form. The encoded `(chainId << 48) | projectId`
-    /// form is used only inside the transient slot and the entry-point parameter; storage exposes the unpacked pair.
-    /// @param terminal The terminal that originated the fee-paying call.
-    /// @param referralChainId The EIP-155 chain ID of the referrer's home chain.
-    /// @param referralProjectId The referrer's bare project ID on `referralChainId`.
-    /// @return The cumulative fee amount credited.
-    function feeVolumeByReferralOf(
-        address terminal,
-        uint256 referralChainId,
-        uint256 referralProjectId
-    )
-        external
-        view
-        returns (uint256);
-
     /// @notice Simulates a cash out without modifying state.
     /// @param terminal The terminal to simulate the cash out from.
     /// @param holder The address cashing out.
@@ -234,13 +194,6 @@ interface IJBTerminalStore {
         view
         returns (JBRuleset memory ruleset, uint256 tokenCount, JBPayHookSpecification[] memory hookSpecifications);
 
-    /// @notice The cumulative fee payment amount credited across all referral projects for a given terminal.
-    /// @dev Incremented in lockstep with `feeVolumeByReferralOf` so consumers can compute pro-rata shares in a
-    /// single SLOAD pair without enumerating referrers.
-    /// @param terminal The terminal that originated the fee-paying calls.
-    /// @return The cumulative total fee amount credited across all referrers for this terminal.
-    function totalFeeVolumeOf(address terminal) external view returns (uint256);
-
     /// @notice Returns the amount of payout limit used by a terminal for a project in a given cycle.
     /// @param terminal The terminal to get the used payout limit of.
     /// @param projectId The ID of the project.
@@ -316,15 +269,6 @@ interface IJBTerminalStore {
             JBCashOutHookSpecification[] memory hookSpecifications
         );
 
-    /// @notice Credit a referral project with a fee payment amount routed through `msg.sender` (the calling terminal).
-    /// @dev Permissionless: the write is scoped to `msg.sender`'s slot, so an arbitrary caller can only pollute
-    /// their own bucket. The amount is normalized to `JBConstants.NATIVE_TOKEN` units (18 decimals) using the fee
-    /// project's price feeds so credits across different fee tokens (ETH, USDC, USDT, …) are summable. No-op when
-    /// `referralProjectId == 0`, when `amount.value == 0`, or when no price feed exists for the pair.
-    /// @param referralProjectId The referral project to credit.
-    /// @param amount The fee amount paid by this fee-take call (raw token amount, decimals, and currency).
-    function recordFeeReferralCreditOf(uint256 referralProjectId, JBTokenAmount calldata amount) external;
-
     /// @notice Records a payment to a project.
     /// @param payer The address of the payer.
     /// @param amount The amount to pay.

package/src/structs/JBFee.sol

@@ -4,20 +4,10 @@ pragma solidity ^0.8.0;
 /// @custom:member amount The total amount the fee was taken from, as a fixed point number with the same number of
 /// decimals as the token's accounting context. `uint224` covers any realistic per-call fee basis (max
 /// ~2.7e49 ETH-equivalent at 18 decimals) and is the same width the protocol's payout/surplus-allowance limits use.
-/// @custom:member referralChainId The EIP-155 chain ID of the referrer's home chain, captured from the upper bits of
-/// the transient referral encoding at fee-take time. A value of `0` is the "current chain" sentinel — a referrer that
-/// only encoded a project ID without a chain prefix is credited on the chain the fee is paid on. Packing this beside
-/// `amount` in the same storage slot avoids growing `JBFee` to a third slot.
 /// @custom:member beneficiary The address that will receive the tokens that are minted as a result of the fee payment.
 /// @custom:member unlockTimestamp The timestamp at which the fee is unlocked and can be processed.
-/// @custom:member referralProjectId The referrer's project ID on `referralChainId`. Captured from the lower bits of
-/// `currentReferralProjectId` at fee-take time so held-fee attribution survives the 28-day hold window. The transient
-/// slot and terminal entry-point arguments use the packed `(referralChainId << 48) | referralProjectId` form; this
-/// struct stores the two halves separately for cheap storage.
 struct JBFee {
     uint224 amount;
-    uint32 referralChainId;
     address beneficiary;
     uint48 unlockTimestamp;
-    uint48 referralProjectId;
 }

package/test/mock/MockMaliciousBeneficiary.sol

@@ -18,8 +18,7 @@ contract MaliciousPayoutBeneficiary is IERC721Receiver, Test {
             amount: 5 * 10 ** 18,
             currency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
             token: JBConstants.NATIVE_TOKEN,
-            minTokensPaidOut: 0,
-            referralProjectId: 0
+            minTokensPaidOut: 0
         });
         assertEq(_reentrantPayout, 0);
     }
@@ -50,8 +49,7 @@ contract MaliciousAllowanceBeneficiary is IERC721Receiver, Test {
             minTokensPaidOut: 0,
             beneficiary: payable(address(this)),
             feeBeneficiary: payable(0x000000000000000000000000000000000000007B),
-            memo: "MEMO",
-            referralProjectId: 0
+            memo: "MEMO"
         });
     }
 

package/src/periphery/JBTriangularPriceFeed.sol

@@ -1,58 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity 0.8.28;
-
-import {mulDiv} from "@prb/math/src/Common.sol";
-
-import {IJBPriceFeed} from "../interfaces/IJBPriceFeed.sol";
-
-/// @notice A composite price feed that triangulates two existing feeds sharing a common quote ("pivot") currency to
-/// price a pair that has no direct feed.
-/// @dev Composes `NUMERATOR` (the pivot priced per unit of the target pair's *unit* currency) and `DENOMINATOR` (the
-/// pivot priced per unit of the target pair's *pricing* currency) into "pricing currency per unit currency". The
-/// pivot is implicit in the two legs supplied at construction — it is never hardcoded — so different instances can
-/// triangulate through different pivots, and `JBPrices` stays a plain registry with no triangulation logic.
-///
-/// Worked example (ETH<->USDC has no direct feed, triangulate through USD): supply
-/// `NUMERATOR` = the USD-per-USDC feed and `DENOMINATOR` = the USD-per-ETH feed. `currentUnitPrice` then returns
-/// "ETH per 1 USDC", and registering this feed for the `(pricingCurrency = ETH, unitCurrency = USDC)` pair lets
-/// `JBPrices` auto-invert it to "USDC per 1 ETH" for the opposite direction.
-///
-/// Safety: this feed inherits each leg's staleness/validity reverts. If either leg reverts (stale, negative, or
-/// incomplete round) the composite reverts, so a stale or invalid leg can never yield a usable composite price.
-contract JBTriangularPriceFeed is IJBPriceFeed {
-    //*********************************************************************//
-    // --------------- public immutable stored properties ---------------- //
-    //*********************************************************************//
-
-    /// @notice The feed pricing one unit of the target pair's *unit* currency in the shared pivot currency.
-    IJBPriceFeed public immutable NUMERATOR;
-
-    /// @notice The feed pricing one unit of the target pair's *pricing* currency in the shared pivot currency.
-    IJBPriceFeed public immutable DENOMINATOR;
-
-    //*********************************************************************//
-    // -------------------------- constructor ---------------------------- //
-    //*********************************************************************//
-
-    /// @param numerator The feed pricing the unit currency in the pivot currency (e.g. a USD-per-USDC feed).
-    /// @param denominator The feed pricing the pricing currency in the pivot currency (e.g. a USD-per-ETH feed).
-    constructor(IJBPriceFeed numerator, IJBPriceFeed denominator) {
-        NUMERATOR = numerator;
-        DENOMINATOR = denominator;
-    }
-
-    //*********************************************************************//
-    // ------------------------- external views -------------------------- //
-    //*********************************************************************//
-
-    /// @inheritdoc IJBPriceFeed
-    /// @dev Returns `numerator / denominator` at the requested precision, which cancels the shared pivot unit and
-    /// yields "pricing currency per 1 unit currency".
-    function currentUnitPrice(uint256 decimals) external view override returns (uint256) {
-        return mulDiv({
-            x: NUMERATOR.currentUnitPrice(decimals),
-            y: 10 ** decimals,
-            denominator: DENOMINATOR.currentUnitPrice(decimals)
-        });
-    }
-}