@bananapus/core-v6 0.0.80 → 0.0.82

package/src/JBTokens.sol

@@ -19,16 +19,37 @@ contract JBTokens is JBControlled, IJBTokens {
     // --------------------------- custom errors ------------------------- //
     //*********************************************************************//
 
+    /// @notice Thrown when deploying a token with an empty name.
     error JBTokens_EmptyName(uint256 projectId);
+
+    /// @notice Thrown when deploying a token with an empty symbol.
     error JBTokens_EmptySymbol(uint256 projectId);
+
+    /// @notice Thrown when the token to set is the zero address.
     error JBTokens_EmptyToken(uint256 projectId);
+
+    /// @notice Thrown when burning more credits than the holder's credit balance.
     error JBTokens_InsufficientCredits(uint256 count, uint256 creditBalance);
+
+    /// @notice Thrown when burning more tokens than the holder's combined token and credit balance.
     error JBTokens_InsufficientTokensToBurn(uint256 count, uint256 tokenBalance);
+
+    /// @notice Thrown when minting would push the total supply past the uint208 maximum.
     error JBTokens_OverflowAlert(uint256 value, uint256 limit);
+
+    /// @notice Thrown when the project already has a token set.
     error JBTokens_ProjectAlreadyHasToken(IJBToken token);
+
+    /// @notice Thrown when the token is already in use by another project.
     error JBTokens_TokenAlreadyBeingUsed(uint256 projectId);
+
+    /// @notice Thrown when the token reports that it cannot be added to the project.
     error JBTokens_TokenCantBeAdded(uint256 projectId);
+
+    /// @notice Thrown when the project has no token set.
     error JBTokens_TokenNotFound(uint256 projectId);
+
+    /// @notice Thrown when the token does not use 18 decimals.
     error JBTokens_TokensMustHave18Decimals(uint256 decimals);
 
     //*********************************************************************//

package/src/abstract/JBControlled.sol

@@ -12,6 +12,7 @@ abstract contract JBControlled is IJBControlled {
     // --------------------------- custom errors -------------------------- //
     //*********************************************************************//
 
+    /// @notice Thrown when the caller is not the controller of the specified project.
     error JBControlled_ControllerUnauthorized(address controller);
 
     //*********************************************************************//

package/src/abstract/JBPermissioned.sol

@@ -14,6 +14,7 @@ abstract contract JBPermissioned is Context, IJBPermissioned {
     // --------------------------- custom errors -------------------------- //
     //*********************************************************************//
 
+    /// @notice Thrown when the sender lacks the required permission from the account to perform the operation.
     error JBPermissioned_Unauthorized(address account, address sender, uint256 projectId, uint256 permissionId);
 
     //*********************************************************************//

package/src/enums/JBApprovalStatus.sol

@@ -2,12 +2,12 @@
 pragma solidity ^0.8.0;
 
 /// @notice The lifecycle states a queued ruleset can be in relative to its approval hook.
-/// @dev `Empty` — no ruleset exists. `Upcoming` — queued but not yet eligible for approval check. `Active` —
-/// currently
-/// governing the project. `ApprovalExpected` — the deadline hasn't passed yet, expected to be approved.
-/// `Approved` — passed the approval hook and will take effect. `Failed` — rejected by the approval hook; the
-/// previous
-/// ruleset continues.
+/// @dev `Empty` — no ruleset exists.
+/// `Upcoming` — queued but not yet eligible for approval check.
+/// `Active` — currently governing the project.
+/// `ApprovalExpected` — the deadline hasn't passed yet, expected to be approved.
+/// `Approved` — passed the approval hook and will take effect.
+/// `Failed` — rejected by the approval hook; the previous ruleset continues.
 enum JBApprovalStatus {
     Empty,
     Upcoming,

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/libraries/JBMetadataResolver.sol

@@ -25,9 +25,16 @@ pragma solidity 0.8.28;
  *            +-----------------------+
  */
 library JBMetadataResolver {
+    /// @notice Thrown when the data to add is not padded to a multiple of 32 bytes.
     error JBMetadataResolver_DataNotPadded(uint256 dataLength);
+
+    /// @notice Thrown when the IDs and datas arrays have mismatched lengths.
     error JBMetadataResolver_LengthMismatch(uint256 idsLength, uint256 datasLength);
+
+    /// @notice Thrown when the metadata offset exceeds the maximum addressable offset of 255.
     error JBMetadataResolver_MetadataTooLong(uint256 offset, uint256 maxOffset);
+
+    /// @notice Thrown when the metadata is shorter than the minimum required length.
     error JBMetadataResolver_MetadataTooShort(uint256 metadataLength, uint256 minMetadataLength);
 
     // Constants alphabetized per STYLE_GUIDE; trailing comments document derivation.
@@ -260,7 +267,7 @@ library JBMetadataResolver {
             if (parsedId == id) {
                 // Are we at the end of the lookup table (either at the start of data's or next offset is 0/in the
                 // padding)
-                // If not, only return until from this offset to the begining of the next offset
+                // If not, only return until from this offset to the beginning of the next offset
                 uint256 end = (i + NEXT_ID_OFFSET >= firstOffset * WORD_SIZE || metadata[i + NEXT_ID_OFFSET] == 0)
                     ? metadata.length
                     : uint256(uint8(metadata[i + NEXT_ID_OFFSET])) * WORD_SIZE;
@@ -295,6 +302,7 @@ library JBMetadataResolver {
     /// @param start The start index to slice at.
     /// @param end The end index to slice at.
     /// @param slicedBytes The sliced array.
+    /// @return slicedBytes The sliced array.
     function _sliceBytes(bytes memory data, uint256 start, uint256 end)
         private
         pure

package/src/libraries/JBPayoutSplitGroupLib.sol

@@ -44,8 +44,22 @@ interface IJBPayoutSplitGroupExecutor {
 /// @dev Extracted as an external library to reduce `JBMultiTerminal` bytecode size. Called via DELEGATECALL, so events
 /// are emitted from the terminal's address.
 library JBPayoutSplitGroupLib {
+    /// @notice A payout to a split reverted, so the amount was returned to the project's balance.
+    /// @param projectId The ID of the project whose payout reverted.
+    /// @param split The split that was being paid when the revert occurred.
+    /// @param amount The amount that was being sent to the split.
+    /// @param reason The reason the payout reverted.
+    /// @param caller The address that called the payout function.
     event PayoutReverted(uint256 indexed projectId, JBSplit split, uint256 amount, bytes reason, address caller);
 
+    /// @notice A payout was sent to a split.
+    /// @param projectId The ID of the project that the payout was made from.
+    /// @param rulesetId The ID of the ruleset the split belongs to.
+    /// @param group The group the split belongs to.
+    /// @param split The split that was paid.
+    /// @param amount The amount that was sent to the split.
+    /// @param netAmount The amount that the split recipient actually received, after fees.
+    /// @param caller The address that called the payout function.
     event SendPayoutToSplit(
         uint256 indexed projectId,
         uint256 indexed rulesetId,

package/src/periphery/JBMatchingPriceFeed.sol

@@ -8,7 +8,9 @@ import {IJBPriceFeed} from "../interfaces/IJBPriceFeed.sol";
 contract JBMatchingPriceFeed is IJBPriceFeed {
     constructor() {}
 
-    /// @inheritdoc IJBPriceFeed
+    /// @notice Gets the current price (per 1 unit) from the feed.
+    /// @param decimals The number of decimals the return value should use.
+    /// @return The current unit price from the feed, as a fixed point number with the specified number of decimals.
     function currentUnitPrice(uint256 decimals) public view virtual override returns (uint256) {
         return 10 ** decimals;
     }

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"
         });
     }