@bananapus/core-v6 0.0.80 → 0.0.82

package/src/JBMultiTerminal.sol

@@ -66,18 +66,43 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
     // --------------------------- custom errors ------------------------- //
     //*********************************************************************//
 
+    /// @notice Thrown when no terminal can be found to pay a fee in the given token.
     error JBMultiTerminal_FeeTerminalNotFound(address token);
+
+    /// @notice Thrown when a payout split routes back into the project that is paying out.
     error JBMultiTerminal_MintNotAllowed(uint256 projectId, address terminal);
+
+    /// @notice Thrown when native value is sent with an operation that does not accept it.
     error JBMultiTerminal_NoMsgValueAllowed(uint256 value);
+
+    /// @notice Thrown when a value exceeds the allowed maximum.
     error JBMultiTerminal_OverflowAlert(uint256 value, uint256 limit);
+
+    /// @notice Thrown when the Permit2 allowance is less than the amount being paid.
     error JBMultiTerminal_PermitAllowanceNotEnough(uint256 amount, uint256 allowance);
+
+    /// @notice Thrown when no terminal can be found to pay a recipient project's split in the given token.
     error JBMultiTerminal_RecipientProjectTerminalNotFound(uint256 projectId, address token);
+
+    /// @notice Thrown when a token transfer reenters during a balance-delta measurement.
     error JBMultiTerminal_ReentrantTokenTransfer(address token);
+
+    /// @notice Thrown when a split hook does not support the `IJBSplitHook` interface.
     error JBMultiTerminal_SplitHookInvalid(IJBSplitHook hook);
+
+    /// @notice Thrown when an approved temporary allowance was not fully consumed by the spender.
     error JBMultiTerminal_TemporaryAllowanceNotConsumed(address token, address spender, uint256 allowance);
+
+    /// @notice Thrown when migrating a terminal to itself.
     error JBMultiTerminal_TerminalMigrationToSelf(uint256 projectId, address token);
+
+    /// @notice Thrown when the terminal being migrated to does not accept the same token.
     error JBMultiTerminal_TerminalTokensIncompatible(uint256 projectId, address token, IJBTerminal terminal);
+
+    /// @notice Thrown when the terminal does not accept the given token.
     error JBMultiTerminal_TokenNotAccepted(address token);
+
+    /// @notice Thrown when a value is less than the required minimum.
     error JBMultiTerminal_UnderMin(uint256 value, uint256 min);
 
     //*********************************************************************//
@@ -109,7 +134,7 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
     /// @notice The contract that stores and manages the terminal's data.
     IJBTerminalStore public immutable override STORE;
 
-    /// @notice The contract storing and managing project rulesets.
+    /// @notice The contract that manages token minting and burning.
     IJBTokens public immutable override TOKENS;
 
     //*********************************************************************//
@@ -146,25 +171,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 +183,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 +306,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 +315,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 +324,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 +333,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 +434,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 +717,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 +751,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 +766,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 +792,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 +828,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 +838,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 +850,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 +861,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 +1730,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 +1819,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 +1831,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 +2024,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 +2301,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/JBPermissions.sol

@@ -17,8 +17,13 @@ contract JBPermissions is ERC2771Context, IJBPermissions {
     // --------------------------- custom errors ------------------------- //
     //*********************************************************************//
 
+    /// @notice Thrown when attempting to set the reserved permission ID 0.
     error JBPermissions_NoZeroPermission(address account, address operator, uint256 projectId);
+
+    /// @notice Thrown when a permission ID is greater than the maximum of 255.
     error JBPermissions_PermissionIdOutOfBounds(uint256 permissionId);
+
+    /// @notice Thrown when the caller is not the account and lacks ROOT permission to set permissions on its behalf.
     error JBPermissions_Unauthorized(address account, address operator, uint256 projectId, uint256 permissionId);
 
     //*********************************************************************//

package/src/JBPrices.sol

@@ -23,10 +23,19 @@ contract JBPrices is JBControlled, JBPermissioned, ERC2771Context, Ownable, IJBP
     // --------------------------- custom errors ------------------------- //
     //*********************************************************************//
 
+    /// @notice Thrown when adding a price feed that is already registered for the same currency pair.
     error JBPrices_PriceFeedAlreadyAdded(IJBPriceFeed feed);
+
+    /// @notice Thrown when no configured price feed can be found for the requested currency pair.
     error JBPrices_PriceFeedNotFound(uint256 projectId, uint256 pricingCurrency, uint256 unitCurrency);
+
+    /// @notice Thrown when the provided price feed is the zero address.
     error JBPrices_ZeroPriceFeed();
+
+    /// @notice Thrown when the pricing currency provided is zero.
     error JBPrices_ZeroPricingCurrency(uint256 projectId, uint256 pricingCurrency);
+
+    /// @notice Thrown when the unit currency provided is zero.
     error JBPrices_ZeroUnitCurrency(uint256 projectId, uint256 unitCurrency);
 
     //*********************************************************************//

package/src/JBProjects.sol

@@ -18,8 +18,13 @@ contract JBProjects is ERC721, ERC2771Context, Ownable, IJBProjects {
     // --------------------------- custom errors ------------------------- //
     //*********************************************************************//
 
+    /// @notice Thrown when the configured creation fee exceeds the allowed maximum.
     error JBProjects_CreationFeeExceedsMax(uint256 fee, uint256 max);
+
+    /// @notice Thrown when the native value sent does not equal the required creation fee.
     error JBProjects_InvalidCreationFee(uint256 value, uint256 requiredFee);
+
+    /// @notice Thrown when a non-zero creation fee is configured without a fee receiver.
     error JBProjects_ZeroCreationFeeReceiver();
 
     //*********************************************************************//

package/src/JBRulesets.sol

@@ -25,11 +25,23 @@ contract JBRulesets is JBControlled, IJBRulesets {
     // --------------------------- custom errors ------------------------- //
     //*********************************************************************//
 
+    /// @notice Thrown when the approval hook is not a contract or does not support the `IJBRulesetApprovalHook`
+    /// interface.
     error JBRulesets_InvalidRulesetApprovalHook(IJBRulesetApprovalHook hook);
+
+    /// @notice Thrown when the ruleset duration exceeds the uint32 maximum.
     error JBRulesets_InvalidRulesetDuration(uint256 duration, uint256 limit);
+
+    /// @notice Thrown when the ruleset's start plus duration exceeds the uint48 maximum.
     error JBRulesets_InvalidRulesetEndTime(uint256 timestamp, uint256 limit);
+
+    /// @notice Thrown when the ruleset weight exceeds the uint112 maximum.
     error JBRulesets_InvalidWeight(uint256 weight, uint256 limit);
+
+    /// @notice Thrown when the weight cut percent exceeds 100%.
     error JBRulesets_InvalidWeightCutPercent(uint256 percent);
+
+    /// @notice Thrown when too many weight-cut iterations remain and the weight cache must be populated first.
     error JBRulesets_WeightCacheRequired(uint256 projectId);
 
     //*********************************************************************//
@@ -396,8 +408,8 @@ contract JBRulesets is JBControlled, IJBRulesets {
             // Get a reference to the approval status.
             JBApprovalStatus approvalStatus = _approvalStatusOf({projectId: projectId, ruleset: ruleset});
 
-            // While the ruleset has a approval hook that isn't approved or if it hasn't yet started, get a reference to
-            // the ruleset that the latest is based on, which has the latest approved configuration.
+            // While the ruleset has an approval hook that isn't approved or if it hasn't yet started, get a reference
+            // to the ruleset that the latest is based on, which has the latest approved configuration.
             while (
                 (approvalStatus != JBApprovalStatus.Approved && approvalStatus != JBApprovalStatus.Empty)
                     // forge-lint: disable-next-line(block-timestamp)
@@ -472,7 +484,7 @@ contract JBRulesets is JBControlled, IJBRulesets {
         // Keep a reference to its approval status.
         JBApprovalStatus approvalStatus;
 
-        // If an upcoming approvable ruleset has been queued, and it's approval status is Approved or ApprovalExpected,
+        // If an upcoming approvable ruleset has been queued, and its approval status is Approved or ApprovalExpected,
         // return its ruleset struct
         if (upcomingApprovableRulesetId != 0) {
             ruleset = _getStructFor({projectId: projectId, rulesetId: upcomingApprovableRulesetId, withMetadata: true});
@@ -495,7 +507,7 @@ contract JBRulesets is JBControlled, IJBRulesets {
             ruleset = _getStructFor({projectId: projectId, rulesetId: latestRulesetIdOf[projectId], withMetadata: true});
 
             // If the latest ruleset starts in the future, it must start in the distant future
-            // Since its not the upcoming approvable ruleset. In this case, base the upcoming ruleset on the base
+            // Since it's not the upcoming approvable ruleset. In this case, base the upcoming ruleset on the base
             // ruleset.
             // forge-lint: disable-next-line(block-timestamp)
             while (ruleset.start > block.timestamp) {
@@ -723,7 +735,7 @@ contract JBRulesets is JBControlled, IJBRulesets {
         // Get a reference to the approval status.
         JBApprovalStatus approvalStatus = _approvalStatusOf({projectId: projectId, ruleset: baseRuleset});
 
-        // If the base ruleset has started but wasn't approved if a approval hook exists
+        // If the base ruleset has started but wasn't approved if an approval hook exists
         // OR it hasn't started but is currently approved
         // OR it hasn't started but it is likely to be approved and takes place before the proposed one,
         // set the struct to be the ruleset it's based on, which carries the latest approved ruleset.

package/src/JBSplits.sol

@@ -19,8 +19,13 @@ contract JBSplits is JBControlled, IJBSplits {
     // --------------------------- custom errors ------------------------- //
     //*********************************************************************//
 
+    /// @notice Thrown when a new set of splits omits a still-locked split from the previous set.
     error JBSplits_PreviousLockedSplitsNotIncluded(uint256 projectId, uint256 rulesetId);
+
+    /// @notice Thrown when the splits in a group sum to more than 100%.
     error JBSplits_TotalPercentExceeds100(uint256 projectId, uint256 rulesetId, uint256 groupId, uint256 percentTotal);
+
+    /// @notice Thrown when a split is configured with a percent of zero.
     error JBSplits_ZeroSplitPercent(uint256 projectId, uint256 rulesetId, uint256 groupId, uint256 splitIndex);
 
     //*********************************************************************//

package/src/JBTerminalStore.sol

@@ -39,22 +39,48 @@ contract JBTerminalStore is IJBTerminalStore {
     // --------------------------- custom errors ------------------------- //
     //*********************************************************************//
 
+    /// @notice Thrown when setting an accounting context for a token that already has one.
     error JBTerminalStore_AccountingContextAlreadySet(address token);
+
+    /// @notice Thrown when a token's provided decimals do not match the decimals it reports.
     error JBTerminalStore_AccountingContextDecimalsMismatch(
         address token, uint256 providedDecimals, uint256 expectedDecimals
     );
+
+    /// @notice Thrown when a token's decimals are outside the supported range.
     error JBTerminalStore_AccountingContextDecimalsOutOfRange(address token, uint256 decimals);
+
+    /// @notice Thrown when the project's current ruleset does not allow adding accounting contexts.
     error JBTerminalStore_AddingAccountingContextNotAllowed(uint256 projectId, uint256 rulesetId, address terminal);
+
+    /// @notice Thrown when the used surplus allowance exceeds the amount the controller granted.
     error JBTerminalStore_InadequateControllerAllowance(uint256 amount, uint256 allowance);
 
+    /// @notice Thrown when the amount to use exceeds the terminal's recorded balance or surplus.
     error JBTerminalStore_InadequateTerminalStoreBalance(uint256 amount, uint256 balance);
+
+    /// @notice Thrown when cashing out more tokens than the effective total supply.
     error JBTerminalStore_InsufficientTokens(uint256 count, uint256 totalSupply);
+
+    /// @notice Thrown when a hook specification asks to forward more than the amount paid.
     error JBTerminalStore_InvalidAmountToForwardHook(uint256 amount, uint256 paidAmount);
+
+    /// @notice Thrown when a hook specification is flagged as a no-op but carries a non-zero amount.
     error JBTerminalStore_NoopHookSpecHasAmount(uint256 amount);
+
+    /// @notice Thrown when the project has no current ruleset.
     error JBTerminalStore_RulesetNotFound(uint256 projectId);
+
+    /// @notice Thrown when paying a project whose current ruleset pauses payments.
     error JBTerminalStore_RulesetPaymentPaused(uint256 projectId, uint256 rulesetId);
+
+    /// @notice Thrown when the project's current ruleset does not allow terminal migration.
     error JBTerminalStore_TerminalMigrationNotAllowed(uint256 projectId, uint256 rulesetId);
+
+    /// @notice Thrown when a value to record exceeds the uint224 maximum.
     error JBTerminalStore_Uint224Overflow(uint256 value);
+
+    /// @notice Thrown when an accounting context's currency is zero.
     error JBTerminalStore_ZeroAccountingContextCurrency(address token);
 
     //*********************************************************************//
@@ -92,26 +118,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 +371,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.
@@ -501,7 +491,7 @@ contract JBTerminalStore is IJBTerminalStore {
             revert JBTerminalStore_InadequateTerminalStoreBalance({amount: amountPaidOut, balance: currentBalance});
         }
 
-        // Removed the paid out funds from the project's token balance.
+        // Remove the paid out funds from the project's token balance.
         unchecked {
             balanceOf[msg.sender][projectId][token] = currentBalance - amountPaidOut;
         }
@@ -1173,7 +1163,7 @@ contract JBTerminalStore is IJBTerminalStore {
         if (weight == 0) return (ruleset, 0, hookSpecifications, balanceDiff);
 
         // If the terminal should base its weight on a currency other than the terminal's currency, determine the
-        // factor. The weight is always a fixed point mumber with 18 decimals. To ensure this, the ratio should use the
+        // factor. The weight is always a fixed point number with 18 decimals. To ensure this, the ratio should use the
         // same
         // number of decimals as the `amount`.
         uint256 weightRatio = amount.currency == ruleset.baseCurrency()
@@ -1366,7 +1356,7 @@ contract JBTerminalStore is IJBTerminalStore {
             : mulDiv({
                 x: surplus,
                 y: 10 ** _MAX_FIXED_POINT_FIDELITY, // Use `_MAX_FIXED_POINT_FIDELITY` to keep as much of the
-                // `_payoutLimitRemaining`'s fidelity as possible when converting.
+                // surplus's fidelity as possible when converting.
                 denominator: PRICES.pricePerUnitOf({
                     projectId: projectId,
                     pricingCurrency: accountingContext.currency,
@@ -1442,80 +1432,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;
-        }
-    }
 }