@bananapus/core-v6 0.0.9 → 0.0.10

package/src/JBTokens.sol

@@ -70,47 +70,6 @@ contract JBTokens is JBControlled, IJBTokens {
         TOKEN = token;
     }
 
-    //*********************************************************************//
-    // ------------------------- external views -------------------------- //
-    //*********************************************************************//
-
-    /// @notice The total balance a holder has for a specified project, including both tokens and token credits.
-    /// @param holder The holder to get a balance for.
-    /// @param projectId The project to get the `holder`'s balance for.
-    /// @return balance The combined token and token credit balance of the `holder`.
-    function totalBalanceOf(address holder, uint256 projectId) external view override returns (uint256 balance) {
-        // Get a reference to the holder's credits for the project.
-        balance = creditBalanceOf[holder][projectId];
-
-        // Get a reference to the project's current token.
-        IJBToken token = tokenOf[projectId];
-
-        // If the project has a current token, add the holder's balance to the total.
-        if (token != IJBToken(address(0))) {
-            balance += token.balanceOf(holder);
-        }
-    }
-
-    //*********************************************************************//
-    // --------------------------- public views -------------------------- //
-    //*********************************************************************//
-
-    /// @notice The total supply for a specific project, including both tokens and token credits.
-    /// @param projectId The ID of the project to get the total supply of.
-    /// @return totalSupply The total supply of the project's tokens and token credits.
-    function totalSupplyOf(uint256 projectId) public view override returns (uint256 totalSupply) {
-        // Get a reference to the total supply of the project's credits
-        totalSupply = totalCreditSupplyOf[projectId];
-
-        // Get a reference to the project's current token.
-        IJBToken token = tokenOf[projectId];
-
-        // If the project has a current token, add its total supply to the total.
-        if (token != IJBToken(address(0))) {
-            totalSupply += token.totalSupply();
-        }
-    }
-
     //*********************************************************************//
     // ---------------------- external transactions ---------------------- //
     //*********************************************************************//
@@ -373,4 +332,45 @@ contract JBTokens is JBControlled, IJBTokens {
             holder: holder, projectId: projectId, recipient: recipient, count: count, caller: msg.sender
         });
     }
+
+    //*********************************************************************//
+    // ------------------------- external views -------------------------- //
+    //*********************************************************************//
+
+    /// @notice The total balance a holder has for a specified project, including both tokens and token credits.
+    /// @param holder The holder to get a balance for.
+    /// @param projectId The project to get the `holder`'s balance for.
+    /// @return balance The combined token and token credit balance of the `holder`.
+    function totalBalanceOf(address holder, uint256 projectId) external view override returns (uint256 balance) {
+        // Get a reference to the holder's credits for the project.
+        balance = creditBalanceOf[holder][projectId];
+
+        // Get a reference to the project's current token.
+        IJBToken token = tokenOf[projectId];
+
+        // If the project has a current token, add the holder's balance to the total.
+        if (token != IJBToken(address(0))) {
+            balance += token.balanceOf(holder);
+        }
+    }
+
+    //*********************************************************************//
+    // --------------------------- public views -------------------------- //
+    //*********************************************************************//
+
+    /// @notice The total supply for a specific project, including both tokens and token credits.
+    /// @param projectId The ID of the project to get the total supply of.
+    /// @return totalSupply The total supply of the project's tokens and token credits.
+    function totalSupplyOf(uint256 projectId) public view override returns (uint256 totalSupply) {
+        // Get a reference to the total supply of the project's credits
+        totalSupply = totalCreditSupplyOf[projectId];
+
+        // Get a reference to the project's current token.
+        IJBToken token = tokenOf[projectId];
+
+        // If the project has a current token, add its total supply to the total.
+        if (token != IJBToken(address(0))) {
+            totalSupply += token.totalSupply();
+        }
+    }
 }

package/src/interfaces/IJBCashOutTerminal.sol

@@ -7,13 +7,17 @@ import {JBAfterCashOutRecordedContext} from "../structs/JBAfterCashOutRecordedCo
 
 /// @notice A terminal that can be cashed out from.
 interface IJBCashOutTerminal is IJBTerminal {
-    event HookAfterRecordCashOut(
-        IJBCashOutHook indexed hook,
-        JBAfterCashOutRecordedContext context,
-        uint256 specificationAmount,
-        uint256 fee,
-        address caller
-    );
+    /// @notice A cash out was processed for a project.
+    /// @param rulesetId The ID of the ruleset during the cash out.
+    /// @param rulesetCycleNumber The cycle number of the ruleset during the cash out.
+    /// @param projectId The ID of the project being cashed out from.
+    /// @param holder The address whose tokens were cashed out.
+    /// @param beneficiary The address that received the reclaimed funds.
+    /// @param cashOutCount The number of tokens cashed out.
+    /// @param cashOutTaxRate The cash out tax rate applied.
+    /// @param reclaimAmount The amount of funds reclaimed.
+    /// @param metadata Extra metadata associated with the cash out.
+    /// @param caller The address that called the cash out function.
     event CashOutTokens(
         uint256 indexed rulesetId,
         uint256 indexed rulesetCycleNumber,
@@ -27,6 +31,20 @@ interface IJBCashOutTerminal is IJBTerminal {
         address caller
     );
 
+    /// @notice A cash out hook was called after a cash out was recorded.
+    /// @param hook The cash out hook that was called.
+    /// @param context The context passed to the hook.
+    /// @param specificationAmount The amount specified for the hook.
+    /// @param fee The fee taken from the hook's amount.
+    /// @param caller The address that called the cash out function.
+    event HookAfterRecordCashOut(
+        IJBCashOutHook indexed hook,
+        JBAfterCashOutRecordedContext context,
+        uint256 specificationAmount,
+        uint256 fee,
+        address caller
+    );
+
     /// @notice Cashes out a holder's tokens for a project, reclaiming the token's proportional share of the project's
     /// surplus.
     /// @param holder The address whose tokens are being cashed out.

package/src/interfaces/IJBController.sol

@@ -27,14 +27,49 @@ import {JBTerminalConfig} from "./../structs/JBTerminalConfig.sol";
 /// @notice Coordinates rulesets and project tokens, and is the entry point for most operations related to rulesets and
 /// project tokens.
 interface IJBController is IERC165, IJBProjectUriRegistry, IJBDirectoryAccessControl {
+    /// @notice Tokens were burned from a holder's balance.
+    /// @param holder The address whose tokens were burned.
+    /// @param projectId The ID of the project whose tokens were burned.
+    /// @param tokenCount The number of tokens burned.
+    /// @param memo A memo associated with the burn.
+    /// @param caller The address that called the burn function.
     event BurnTokens(
         address indexed holder, uint256 indexed projectId, uint256 tokenCount, string memo, address caller
     );
+
+    /// @notice An ERC-20 token was deployed for a project.
+    /// @param projectId The ID of the project the token was deployed for.
+    /// @param deployer The address that deployed the token.
+    /// @param salt The salt used for deterministic deployment.
+    /// @param saltHash The hash of the salt.
+    /// @param caller The address that called the deploy function.
     event DeployERC20(
         uint256 indexed projectId, address indexed deployer, bytes32 salt, bytes32 saltHash, address caller
     );
+
+    /// @notice A project was launched with its initial rulesets and terminals.
+    /// @param rulesetId The ID of the first queued ruleset.
+    /// @param projectId The ID of the newly created project.
+    /// @param projectUri The metadata URI of the project.
+    /// @param memo A memo associated with the launch.
+    /// @param caller The address that called the launch function.
     event LaunchProject(uint256 rulesetId, uint256 projectId, string projectUri, string memo, address caller);
+
+    /// @notice Rulesets were launched for an existing project.
+    /// @param rulesetId The ID of the first queued ruleset.
+    /// @param projectId The ID of the project.
+    /// @param memo A memo associated with the launch.
+    /// @param caller The address that called the launch function.
     event LaunchRulesets(uint256 rulesetId, uint256 projectId, string memo, address caller);
+
+    /// @notice Tokens were minted for a beneficiary.
+    /// @param beneficiary The address that received the minted tokens.
+    /// @param projectId The ID of the project whose tokens were minted.
+    /// @param tokenCount The total number of tokens minted, including reserved tokens.
+    /// @param beneficiaryTokenCount The number of tokens minted for the beneficiary.
+    /// @param memo A memo associated with the mint.
+    /// @param reservedPercent The reserved percent applied to the mint.
+    /// @param caller The address that called the mint function.
     event MintTokens(
         address indexed beneficiary,
         uint256 indexed projectId,
@@ -44,11 +79,37 @@ interface IJBController is IERC165, IJBProjectUriRegistry, IJBDirectoryAccessCon
         uint256 reservedPercent,
         address caller
     );
+
+    /// @notice A project was prepared for migration from another controller.
+    /// @param projectId The ID of the project being prepared for migration.
+    /// @param from The controller the project is being migrated from.
+    /// @param caller The address that called the prep migration function.
     event PrepMigration(uint256 indexed projectId, address from, address caller);
+
+    /// @notice Rulesets were queued for a project.
+    /// @param rulesetId The ID of the first queued ruleset.
+    /// @param projectId The ID of the project.
+    /// @param memo A memo associated with the queue operation.
+    /// @param caller The address that called the queue function.
     event QueueRulesets(uint256 rulesetId, uint256 projectId, string memo, address caller);
+
+    /// @notice A reserved token distribution to a split reverted.
+    /// @param projectId The ID of the project.
+    /// @param split The split that the distribution reverted for.
+    /// @param tokenCount The number of tokens that failed to distribute.
+    /// @param reason The revert reason.
+    /// @param caller The address that called the distribution function.
     event ReservedDistributionReverted(
         uint256 indexed projectId, JBSplit split, uint256 tokenCount, bytes reason, address caller
     );
+
+    /// @notice Reserved tokens were sent to a specific split.
+    /// @param projectId The ID of the project.
+    /// @param rulesetId The ID of the ruleset during the distribution.
+    /// @param groupId The ID of the split group.
+    /// @param split The split that received the tokens.
+    /// @param tokenCount The number of tokens sent to the split.
+    /// @param caller The address that called the distribution function.
     event SendReservedTokensToSplit(
         uint256 indexed projectId,
         uint256 indexed rulesetId,
@@ -57,6 +118,15 @@ interface IJBController is IERC165, IJBProjectUriRegistry, IJBDirectoryAccessCon
         uint256 tokenCount,
         address caller
     );
+
+    /// @notice Reserved tokens were distributed to a project's splits.
+    /// @param rulesetId The ID of the ruleset during the distribution.
+    /// @param rulesetCycleNumber The cycle number of the ruleset.
+    /// @param projectId The ID of the project.
+    /// @param owner The project's owner.
+    /// @param tokenCount The total number of reserved tokens distributed.
+    /// @param leftoverAmount The number of tokens left over after distribution.
+    /// @param caller The address that called the distribution function.
     event SendReservedTokensToSplits(
         uint256 indexed rulesetId,
         uint256 indexed rulesetCycleNumber,
@@ -66,6 +136,11 @@ interface IJBController is IERC165, IJBProjectUriRegistry, IJBDirectoryAccessCon
         uint256 leftoverAmount,
         address caller
     );
+
+    /// @notice A project's metadata URI was set.
+    /// @param projectId The ID of the project.
+    /// @param uri The metadata URI that was set.
+    /// @param caller The address that called the set URI function.
     event SetUri(uint256 indexed projectId, string uri, address caller);
 
     /// @notice The directory of terminals and controllers for projects.
@@ -74,6 +149,9 @@ interface IJBController is IERC165, IJBProjectUriRegistry, IJBDirectoryAccessCon
     /// @notice The contract that stores fund access limits for each project.
     function FUND_ACCESS_LIMITS() external view returns (IJBFundAccessLimits);
 
+    /// @notice The address of the contract that manages omnichain ruleset ops.
+    function OMNICHAIN_RULESET_OPERATOR() external view returns (address);
+
     /// @notice The contract that stores prices for each project.
     function PRICES() external view returns (IJBPrices);
 
@@ -89,9 +167,6 @@ interface IJBController is IERC165, IJBProjectUriRegistry, IJBDirectoryAccessCon
     /// @notice The contract that manages token minting and burning.
     function TOKENS() external view returns (IJBTokens);
 
-    /// @notice The address of the contract that manages omnichain ruleset ops.
-    function OMNICHAIN_RULESET_OPERATOR() external view returns (address);
-
     /// @notice Returns an array of a project's rulesets with metadata, sorted from latest to earliest.
     /// @param projectId The ID of the project to get the rulesets of.
     /// @param startingId The ID of the ruleset to begin with. If 0, the project's latest ruleset is used.

package/src/interfaces/IJBDirectory.sol

@@ -8,12 +8,37 @@ import {IJBTerminal} from "./IJBTerminal.sol";
 
 /// @notice Tracks the terminals and the controller used by each project.
 interface IJBDirectory {
+    /// @notice A terminal was added to a project.
+    /// @param projectId The ID of the project the terminal was added to.
+    /// @param terminal The terminal that was added.
+    /// @param caller The address that added the terminal.
     event AddTerminal(uint256 indexed projectId, IJBTerminal indexed terminal, address caller);
+
+    /// @notice A project's controller was set.
+    /// @param projectId The ID of the project whose controller was set.
+    /// @param controller The controller that was set.
+    /// @param caller The address that set the controller.
     event SetController(uint256 indexed projectId, IERC165 indexed controller, address caller);
+
+    /// @notice An address's permission to set a project's first controller was updated.
+    /// @param addr The address whose permission was updated.
+    /// @param isAllowed Whether the address is allowed to set a project's first controller.
+    /// @param caller The address that updated the permission.
     event SetIsAllowedToSetFirstController(address indexed addr, bool indexed isAllowed, address caller);
+
+    /// @notice A project's primary terminal for a token was set.
+    /// @param projectId The ID of the project whose primary terminal was set.
+    /// @param token The token the primary terminal was set for.
+    /// @param terminal The terminal that was set as primary.
+    /// @param caller The address that set the primary terminal.
     event SetPrimaryTerminal(
         uint256 indexed projectId, address indexed token, IJBTerminal indexed terminal, address caller
     );
+
+    /// @notice A project's terminals were set.
+    /// @param projectId The ID of the project whose terminals were set.
+    /// @param terminals The terminals that were set.
+    /// @param caller The address that set the terminals.
     event SetTerminals(uint256 indexed projectId, IJBTerminal[] terminals, address caller);
 
     /// @notice Mints ERC-721s that represent project ownership and transfers.

package/src/interfaces/IJBFeeTerminal.sol

@@ -7,6 +7,13 @@ import {JBFee} from "../structs/JBFee.sol";
 
 /// @notice A terminal that can process and hold fees.
 interface IJBFeeTerminal is IJBTerminal {
+    /// @notice A fee payment to the fee project reverted and was returned to the project's balance.
+    /// @param projectId The ID of the project the fee was for.
+    /// @param token The token the fee was denominated in.
+    /// @param feeProjectId The ID of the fee project.
+    /// @param amount The amount of the fee that reverted.
+    /// @param reason The revert reason.
+    /// @param caller The address that triggered the fee processing.
     event FeeReverted(
         uint256 indexed projectId,
         address indexed token,
@@ -15,6 +22,14 @@ interface IJBFeeTerminal is IJBTerminal {
         bytes reason,
         address caller
     );
+
+    /// @notice A fee was held for later processing.
+    /// @param projectId The ID of the project the fee was held for.
+    /// @param token The token the fee is denominated in.
+    /// @param amount The amount from which the fee was calculated.
+    /// @param fee The fee amount held.
+    /// @param beneficiary The address that will receive project tokens when the fee is processed.
+    /// @param caller The address that triggered the fee hold.
     event HoldFee(
         uint256 indexed projectId,
         address indexed token,
@@ -23,6 +38,14 @@ interface IJBFeeTerminal is IJBTerminal {
         address beneficiary,
         address caller
     );
+
+    /// @notice A fee was processed and paid to the fee project.
+    /// @param projectId The ID of the project the fee was for.
+    /// @param token The token the fee was denominated in.
+    /// @param amount The fee amount processed.
+    /// @param wasHeld Whether the fee was previously held.
+    /// @param beneficiary The address that received project tokens from the fee payment.
+    /// @param caller The address that triggered the fee processing.
     event ProcessFee(
         uint256 indexed projectId,
         address indexed token,
@@ -31,6 +54,14 @@ interface IJBFeeTerminal is IJBTerminal {
         address beneficiary,
         address caller
     );
+
+    /// @notice Held fees were returned to a project's balance.
+    /// @param projectId The ID of the project the held fees were returned to.
+    /// @param token The token the fees are denominated in.
+    /// @param amount The amount that triggered the fee return.
+    /// @param returnedFees The total amount of fees returned.
+    /// @param leftoverAmount The leftover amount after returning fees.
+    /// @param caller The address that triggered the fee return.
     event ReturnHeldFees(
         uint256 indexed projectId,
         address indexed token,

package/src/interfaces/IJBFeelessAddresses.sol

@@ -3,6 +3,10 @@ pragma solidity ^0.8.0;
 
 /// @notice Tracks addresses that are exempt from fees.
 interface IJBFeelessAddresses {
+    /// @notice An address's feeless status was set.
+    /// @param addr The address whose feeless status was set.
+    /// @param isFeeless Whether the address is feeless.
+    /// @param caller The address that set the feeless status.
     event SetFeelessAddress(address indexed addr, bool indexed isFeeless, address caller);
 
     /// @notice Returns whether the specified address is feeless.

package/src/interfaces/IJBFundAccessLimits.sol

@@ -6,6 +6,11 @@ import {JBFundAccessLimitGroup} from "./../structs/JBFundAccessLimitGroup.sol";
 
 /// @notice Stores fund access limits (payout limits and surplus allowances) for each project.
 interface IJBFundAccessLimits {
+    /// @notice Fund access limits were set for a project's ruleset.
+    /// @param rulesetId The ID of the ruleset the limits apply within.
+    /// @param projectId The ID of the project the limits were set for.
+    /// @param fundAccessLimitGroup The fund access limit group that was set.
+    /// @param caller The address that set the fund access limits.
     event SetFundAccessLimits(
         uint256 indexed rulesetId,
         uint256 indexed projectId,

package/src/interfaces/IJBMigratable.sol

@@ -5,20 +5,24 @@ import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 
 /// @notice A controller that supports project migration to and from other controllers.
 interface IJBMigratable is IERC165 {
+    /// @notice A project was migrated from this controller to another.
+    /// @param projectId The ID of the project that was migrated.
+    /// @param to The controller the project was migrated to.
+    /// @param caller The address that called the migrate function.
     event Migrate(uint256 indexed projectId, IERC165 to, address caller);
 
-    /// @notice Migrates a project from this controller to another.
-    /// @param projectId The ID of the project being migrated.
-    /// @param to The controller to migrate the project to.
-    function migrate(uint256 projectId, IERC165 to) external;
+    /// @notice Called after this controller has been set as the project's controller in the directory.
+    /// @param from The controller being migrated from.
+    /// @param projectId The ID of the project that was migrated.
+    function afterReceiveMigrationFrom(IERC165 from, uint256 projectId) external;
 
     /// @notice Prepares this controller to receive a project being migrated from another controller.
     /// @param from The controller being migrated from.
     /// @param projectId The ID of the project being migrated.
     function beforeReceiveMigrationFrom(IERC165 from, uint256 projectId) external;
 
-    /// @notice Called after this controller has been set as the project's controller in the directory.
-    /// @param from The controller being migrated from.
-    /// @param projectId The ID of the project that was migrated.
-    function afterReceiveMigrationFrom(IERC165 from, uint256 projectId) external;
+    /// @notice Migrates a project from this controller to another.
+    /// @param projectId The ID of the project being migrated.
+    /// @param to The controller to migrate the project to.
+    function migrate(uint256 projectId, IERC165 to) external;
 }

package/src/interfaces/IJBPayoutTerminal.sol

@@ -7,7 +7,22 @@ import {JBSplit} from "../structs/JBSplit.sol";
 
 /// @notice A terminal that can send payouts.
 interface IJBPayoutTerminal is IJBTerminal {
+    /// @notice A payout to a split hook reverted.
+    /// @param projectId The ID of the project the payout was for.
+    /// @param split The split that the payout reverted for.
+    /// @param amount The amount of the payout.
+    /// @param reason The revert reason.
+    /// @param caller The address that called the payout function.
     event PayoutReverted(uint256 indexed projectId, JBSplit split, uint256 amount, bytes reason, address caller);
+
+    /// @notice A direct payout transfer reverted.
+    /// @param projectId The ID of the project the payout was for.
+    /// @param addr The address the payout was sent to.
+    /// @param token The token being paid out.
+    /// @param amount The amount of the payout.
+    /// @param fee The fee taken from the payout.
+    /// @param reason The revert reason.
+    /// @param caller The address that called the payout function.
     event PayoutTransferReverted(
         uint256 indexed projectId,
         address addr,
@@ -17,6 +32,35 @@ interface IJBPayoutTerminal is IJBTerminal {
         bytes reason,
         address caller
     );
+
+    /// @notice A payout was sent to a specific split.
+    /// @param projectId The ID of the project the payout was for.
+    /// @param rulesetId The ID of the ruleset during the payout.
+    /// @param group The split group the payout was part of.
+    /// @param split The split that received the payout.
+    /// @param amount The gross amount of the payout.
+    /// @param netAmount The net amount of the payout after fees.
+    /// @param caller The address that called the payout function.
+    event SendPayoutToSplit(
+        uint256 indexed projectId,
+        uint256 indexed rulesetId,
+        uint256 indexed group,
+        JBSplit split,
+        uint256 amount,
+        uint256 netAmount,
+        address caller
+    );
+
+    /// @notice Payouts were sent from a project.
+    /// @param rulesetId The ID of the ruleset during the payouts.
+    /// @param rulesetCycleNumber The cycle number of the ruleset during the payouts.
+    /// @param projectId The ID of the project that sent the payouts.
+    /// @param projectOwner The owner of the project.
+    /// @param amount The total amount of tokens paid out.
+    /// @param amountPaidOut The amount paid out to splits.
+    /// @param fee The total fee taken.
+    /// @param netLeftoverPayoutAmount The net leftover amount sent to the project owner.
+    /// @param caller The address that called the payout function.
     event SendPayouts(
         uint256 indexed rulesetId,
         uint256 indexed rulesetCycleNumber,
@@ -28,15 +72,18 @@ interface IJBPayoutTerminal is IJBTerminal {
         uint256 netLeftoverPayoutAmount,
         address caller
     );
-    event SendPayoutToSplit(
-        uint256 indexed projectId,
-        uint256 indexed rulesetId,
-        uint256 indexed group,
-        JBSplit split,
-        uint256 amount,
-        uint256 netAmount,
-        address caller
-    );
+
+    /// @notice Surplus allowance was used to send funds to a beneficiary.
+    /// @param rulesetId The ID of the ruleset during the allowance usage.
+    /// @param rulesetCycleNumber The cycle number of the ruleset.
+    /// @param projectId The ID of the project using the allowance.
+    /// @param beneficiary The address that received the funds.
+    /// @param feeBeneficiary The address that received project tokens from fees.
+    /// @param amount The gross amount of the allowance used.
+    /// @param amountPaidOut The amount paid out before fees.
+    /// @param netAmountPaidOut The net amount paid out to the beneficiary after fees.
+    /// @param memo A memo associated with the allowance usage.
+    /// @param caller The address that called the use allowance function.
     event UseAllowance(
         uint256 indexed rulesetId,
         uint256 indexed rulesetCycleNumber,

package/src/interfaces/IJBPermissions.sol

@@ -5,6 +5,13 @@ import {JBPermissionsData} from "./../structs/JBPermissionsData.sol";
 
 /// @notice Stores permissions for all addresses and operators.
 interface IJBPermissions {
+    /// @notice Permissions were set for an operator on behalf of an account.
+    /// @param operator The operator whose permissions were set.
+    /// @param account The account the permissions are for.
+    /// @param projectId The project ID the permissions are scoped to.
+    /// @param permissionIds The permission IDs that were set.
+    /// @param packed The packed permissions bitmap.
+    /// @param caller The address that set the permissions.
     event OperatorPermissionsSet(
         address indexed operator,
         address indexed account,
@@ -17,13 +24,6 @@ interface IJBPermissions {
     /// @notice The project ID considered a wildcard, granting permissions to all projects.
     function WILDCARD_PROJECT_ID() external view returns (uint256);
 
-    /// @notice Returns the packed permissions that an operator has for an account and project.
-    /// @param operator The address of the operator.
-    /// @param account The address of the account being operated on behalf of.
-    /// @param projectId The project ID the permissions are scoped to. 0 is a wildcard for all projects.
-    /// @return The packed permissions as a uint256 bitmap.
-    function permissionsOf(address operator, address account, uint256 projectId) external view returns (uint256);
-
     /// @notice Checks if an operator has a specific permission for an account and project.
     /// @param operator The operator to check.
     /// @param account The account being operated on behalf of.
@@ -64,6 +64,13 @@ interface IJBPermissions {
         view
         returns (bool);
 
+    /// @notice Returns the packed permissions that an operator has for an account and project.
+    /// @param operator The address of the operator.
+    /// @param account The address of the account being operated on behalf of.
+    /// @param projectId The project ID the permissions are scoped to. 0 is a wildcard for all projects.
+    /// @return The packed permissions as a uint256 bitmap.
+    function permissionsOf(address operator, address account, uint256 projectId) external view returns (uint256);
+
     /// @notice Sets permissions for an operator on behalf of an account.
     /// @param account The account setting its operator's permissions.
     /// @param permissionsData The data specifying the permissions the operator is being given.

package/src/interfaces/IJBPermitTerminal.sol

@@ -7,6 +7,10 @@ import {IJBTerminal} from "./IJBTerminal.sol";
 
 /// @notice A terminal that supports Permit2 token approvals.
 interface IJBPermitTerminal is IJBTerminal {
+    /// @notice A Permit2 allowance approval failed.
+    /// @param token The token the approval was attempted for.
+    /// @param owner The owner of the tokens.
+    /// @param reason The failure reason.
     event Permit2AllowanceFailed(address indexed token, address indexed owner, bytes reason);
 
     /// @notice The Permit2 contract used for token approvals.

package/src/interfaces/IJBPrices.sol

@@ -6,6 +6,12 @@ import {IJBProjects} from "./IJBProjects.sol";
 
 /// @notice Manages price feeds and provides unit prices for currency conversions.
 interface IJBPrices {
+    /// @notice A price feed was added for a project's currency pair.
+    /// @param projectId The ID of the project the price feed was added for.
+    /// @param pricingCurrency The currency the feed's output price is in terms of.
+    /// @param unitCurrency The currency being priced by the feed.
+    /// @param feed The price feed that was added.
+    /// @param caller The address that added the price feed.
     event AddPriceFeed(
         uint256 indexed projectId,
         uint256 indexed pricingCurrency,

package/src/interfaces/IJBProjects.sol

@@ -7,7 +7,15 @@ import {IJBTokenUriResolver} from "./IJBTokenUriResolver.sol";
 
 /// @notice Mints ERC-721s that represent project ownership and transfers.
 interface IJBProjects is IERC721 {
+    /// @notice A new project was created.
+    /// @param projectId The ID of the newly created project.
+    /// @param owner The address that owns the project.
+    /// @param caller The address that created the project.
     event Create(uint256 indexed projectId, address indexed owner, address caller);
+
+    /// @notice The token URI resolver was set.
+    /// @param resolver The new token URI resolver.
+    /// @param caller The address that set the resolver.
     event SetTokenUriResolver(IJBTokenUriResolver indexed resolver, address caller);
 
     /// @notice Returns the total number of projects that have been created.

package/src/interfaces/IJBRulesetApprovalHook.sol

@@ -3,8 +3,8 @@ pragma solidity ^0.8.0;
 
 import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 
-import {JBRuleset} from "./../structs/JBRuleset.sol";
 import {JBApprovalStatus} from "./../enums/JBApprovalStatus.sol";
+import {JBRuleset} from "./../structs/JBRuleset.sol";
 
 /// @notice Determines whether the next ruleset in a project's queue is approved or rejected.
 /// @dev Project rulesets are stored in a queue. Rulesets take effect after the previous ruleset in the queue ends, and