@bananapus/721-hook-v6 0.0.43 → 0.0.46

package/src/abstract/ERC721.sol

@@ -72,7 +72,7 @@ abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Er
      */
     function balanceOf(address owner) public view virtual returns (uint256) {
         if (owner == address(0)) {
-            revert ERC721InvalidOwner(address(0));
+            revert ERC721InvalidOwner({owner: address(0)});
         }
         return _balances[owner];
     }
@@ -153,13 +153,13 @@ abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Er
      */
     function transferFrom(address from, address to, uint256 tokenId) public virtual {
         if (to == address(0)) {
-            revert ERC721InvalidReceiver(address(0));
+            revert ERC721InvalidReceiver({receiver: address(0)});
         }
         // Setting an "auth" arguments enables the `_isAuthorized` check which verifies that the token exists
         // (from != 0). Therefore, it is not needed to verify that the return value is not 0 here.
         address previousOwner = _update({to: to, tokenId: tokenId, auth: _msgSender()});
         if (previousOwner != from) {
-            revert ERC721IncorrectOwner(from, tokenId, previousOwner);
+            revert ERC721IncorrectOwner({sender: from, tokenId: tokenId, owner: previousOwner});
         }
     }
 
@@ -206,7 +206,9 @@ abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Er
      */
     function _isAuthorized(address owner, address spender, uint256 tokenId) internal view virtual returns (bool) {
         return spender != address(0)
-            && (owner == spender || isApprovedForAll(owner, spender) || _getApproved(tokenId) == spender);
+            && (owner == spender
+                || isApprovedForAll({owner: owner, operator: spender})
+                || _getApproved(tokenId) == spender);
     }
 
     /**
@@ -218,11 +220,11 @@ abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Er
      * assumption.
      */
     function _checkAuthorized(address owner, address spender, uint256 tokenId) internal view virtual {
-        if (!_isAuthorized(owner, spender, tokenId)) {
+        if (!_isAuthorized({owner: owner, spender: spender, tokenId: tokenId})) {
             if (owner == address(0)) {
-                revert ERC721NonexistentToken(tokenId);
+                revert ERC721NonexistentToken({tokenId: tokenId});
             } else {
-                revert ERC721InsufficientApproval(spender, tokenId);
+                revert ERC721InsufficientApproval({operator: spender, tokenId: tokenId});
             }
         }
     }
@@ -280,7 +282,7 @@ abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Er
 
         _owners[tokenId] = to;
 
-        emit Transfer(from, to, tokenId);
+        emit Transfer({from: from, to: to, tokenId: tokenId});
 
         return from;
     }
@@ -299,11 +301,11 @@ abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Er
      */
     function _mint(address to, uint256 tokenId) internal {
         if (to == address(0)) {
-            revert ERC721InvalidReceiver(address(0));
+            revert ERC721InvalidReceiver({receiver: address(0)});
         }
         address previousOwner = _update({to: to, tokenId: tokenId, auth: address(0)});
         if (previousOwner != address(0)) {
-            revert ERC721InvalidSender(address(0));
+            revert ERC721InvalidSender({sender: address(0)});
         }
     }
 
@@ -345,7 +347,7 @@ abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Er
     function _burn(uint256 tokenId) internal {
         address previousOwner = _update({to: address(0), tokenId: tokenId, auth: address(0)});
         if (previousOwner == address(0)) {
-            revert ERC721NonexistentToken(tokenId);
+            revert ERC721NonexistentToken({tokenId: tokenId});
         }
     }
 
@@ -362,13 +364,13 @@ abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Er
      */
     function _transfer(address from, address to, uint256 tokenId) internal {
         if (to == address(0)) {
-            revert ERC721InvalidReceiver(address(0));
+            revert ERC721InvalidReceiver({receiver: address(0)});
         }
         address previousOwner = _update({to: to, tokenId: tokenId, auth: address(0)});
         if (previousOwner == address(0)) {
-            revert ERC721NonexistentToken(tokenId);
+            revert ERC721NonexistentToken({tokenId: tokenId});
         } else if (previousOwner != from) {
-            revert ERC721IncorrectOwner(from, tokenId, previousOwner);
+            revert ERC721IncorrectOwner({sender: from, tokenId: tokenId, owner: previousOwner});
         }
     }
 
@@ -430,12 +432,12 @@ abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Er
             address owner = _requireOwned(tokenId);
 
             // We do not use _isAuthorized because single-token approvals should not be able to call approve
-            if (auth != address(0) && owner != auth && !isApprovedForAll(owner, auth)) {
-                revert ERC721InvalidApprover(auth);
+            if (auth != address(0) && owner != auth && !isApprovedForAll({owner: owner, operator: auth})) {
+                revert ERC721InvalidApprover({approver: auth});
             }
 
             if (emitEvent) {
-                emit Approval(owner, to, tokenId);
+                emit Approval({owner: owner, approved: to, tokenId: tokenId});
             }
         }
 
@@ -452,10 +454,10 @@ abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Er
      */
     function _setApprovalForAll(address owner, address operator, bool approved) internal virtual {
         if (operator == address(0)) {
-            revert ERC721InvalidOperator(operator);
+            revert ERC721InvalidOperator({operator: operator});
         }
         _operatorApprovals[owner][operator] = approved;
-        emit ApprovalForAll(owner, operator, approved);
+        emit ApprovalForAll({owner: owner, operator: operator, approved: approved});
     }
 
     /**
@@ -467,7 +469,7 @@ abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Er
     function _requireOwned(uint256 tokenId) internal view returns (address) {
         address owner = _ownerOf(tokenId);
         if (owner == address(0)) {
-            revert ERC721NonexistentToken(tokenId);
+            revert ERC721NonexistentToken({tokenId: tokenId});
         }
         return owner;
     }
@@ -489,11 +491,11 @@ abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Er
                 bytes4 retval
             ) {
                 if (retval != IERC721Receiver.onERC721Received.selector) {
-                    revert ERC721InvalidReceiver(to);
+                    revert ERC721InvalidReceiver({receiver: to});
                 }
             } catch (bytes memory reason) {
                 if (reason.length == 0) {
-                    revert ERC721InvalidReceiver(to);
+                    revert ERC721InvalidReceiver({receiver: to});
                 } else {
                     /// @solidity memory-safe-assembly
                     assembly {

package/src/abstract/JB721Hook.sol

@@ -20,19 +20,20 @@ import {IJB721Hook} from "../interfaces/IJB721Hook.sol";
 import {ERC721} from "./ERC721.sol";
 
 /// @title JB721Hook
-/// @notice When a project which uses this hook is paid, this hook may mint NFTs to the payer, depending on this hook's
-/// setup, the amount paid, and information specified by the payer. The project's owner can enable NFT cash outs
-/// through this hook, allowing the NFT holders to burn their NFTs to reclaim funds from the project (in proportion to
-/// the NFT's price).
+/// @notice Abstract base for Juicebox 721 hooks. Implements the pay hook and cash-out hook interfaces: when a project
+/// is paid through its terminal, this hook mints NFTs to the payer; when NFT holders cash out, this hook burns their
+/// NFTs and lets the terminal send them their share of the project's surplus (proportional to the NFT's price).
+/// @dev Subclasses (like `JB721TiersHook`) implement the actual minting logic via `_processPayment` and burn
+/// tracking via `_didBurn`.
 abstract contract JB721Hook is ERC721, IJB721Hook {
     //*********************************************************************//
     // --------------------------- custom errors ------------------------- //
     //*********************************************************************//
 
-    error JB721Hook_InvalidCashOut();
-    error JB721Hook_InvalidPay();
+    error JB721Hook_InvalidCashOut(address caller, uint256 contextProjectId, uint256 projectId, uint256 msgValue);
+    error JB721Hook_InvalidPay(address caller, uint256 contextProjectId, uint256 projectId);
     error JB721Hook_UnauthorizedToken(uint256 tokenId, address holder);
-    error JB721Hook_UnexpectedTokenCashedOut();
+    error JB721Hook_UnexpectedTokenCashedOut(uint256 cashOutCount);
 
     //*********************************************************************//
     // --------------- public immutable stored properties ---------------- //
@@ -93,7 +94,9 @@ abstract contract JB721Hook is ERC721, IJB721Hook {
         )
     {
         // Make sure (fungible) project tokens aren't also being cashed out.
-        if (context.cashOutCount > 0) revert JB721Hook_UnexpectedTokenCashedOut();
+        if (context.cashOutCount > 0) {
+            revert JB721Hook_UnexpectedTokenCashedOut({cashOutCount: context.cashOutCount});
+        }
 
         // Fetch the cash out hook metadata using the corresponding metadata ID.
         (bool metadataExists, bytes memory metadata) = JBMetadataResolver.getDataFor({
@@ -184,7 +187,6 @@ abstract contract JB721Hook is ERC721, IJB721Hook {
     /// `context.beneficiary`. Part of `IJBCashOutHook`.
     /// @dev Reverts if the calling contract is not one of the project's terminals.
     /// @param context The cash out context passed in by the terminal.
-    // slither-disable-next-line locked-ether
     function afterCashOutRecordedWith(JBAfterCashOutRecordedContext calldata context)
         external
         payable
@@ -199,7 +201,11 @@ abstract contract JB721Hook is ERC721, IJB721Hook {
         if (
             msg.value != 0 || !DIRECTORY.isTerminalOf({projectId: projectId, terminal: IJBTerminal(msg.sender)})
                 || context.projectId != projectId
-        ) revert JB721Hook_InvalidCashOut();
+        ) {
+            revert JB721Hook_InvalidCashOut({
+                caller: msg.sender, contextProjectId: context.projectId, projectId: projectId, msgValue: msg.value
+            });
+        }
 
         // Fetch the cash out hook metadata using the corresponding metadata ID.
         (bool metadataExists, bytes memory metadata) = JBMetadataResolver.getDataFor({
@@ -236,7 +242,6 @@ abstract contract JB721Hook is ERC721, IJB721Hook {
     /// `IJBPayHook`.
     /// @dev Reverts if the calling contract is not one of the project's terminals.
     /// @param context The payment context passed in by the terminal.
-    // slither-disable-next-line locked-ether
     function afterPayRecordedWith(JBAfterPayRecordedContext calldata context) external payable virtual override {
         uint256 projectId = PROJECT_ID;
 
@@ -246,7 +251,7 @@ abstract contract JB721Hook is ERC721, IJB721Hook {
             !DIRECTORY.isTerminalOf({projectId: projectId, terminal: IJBTerminal(msg.sender)})
                 || context.projectId != projectId
         ) {
-            revert JB721Hook_InvalidPay();
+            revert JB721Hook_InvalidPay({caller: msg.sender, contextProjectId: context.projectId, projectId: projectId});
         }
 
         // Process the payment.
@@ -270,7 +275,8 @@ abstract contract JB721Hook is ERC721, IJB721Hook {
         PROJECT_ID = projectId;
     }
 
-    /// @notice Process a received payment.
-    /// @param context The payment context passed in by the terminal.
+    /// @notice Process a received payment by minting NFTs and/or updating credits. Subclasses implement the
+    /// specific minting logic (e.g., tier selection, credit tracking, split distribution).
+    /// @param context The payment context passed in by the terminal (includes amount, payer, beneficiary, metadata).
     function _processPayment(JBAfterPayRecordedContext calldata context) internal virtual;
 }

package/src/interfaces/IJB721Checkpoints.sol

@@ -36,6 +36,6 @@ interface IJB721Checkpoints is IERC5805 {
     /// Auto-self-delegates on first receive so checkpoints work without manual delegation.
     /// @param from The previous owner (address(0) on mint).
     /// @param to The new owner (address(0) on burn).
-    /// @param tokenId The token ID being transferred (used to look up tier voting units).
+    /// @param tokenId The token ID to transfer (used to look up tier voting units).
     function onTransfer(address from, address to, uint256 tokenId) external;
 }

package/src/interfaces/IJB721CheckpointsDeployer.sol

@@ -6,9 +6,6 @@ import {IJB721TiersHookStore} from "./IJB721TiersHookStore.sol";
 
 /// @notice Deploys JB721Checkpoints clones for JB721TiersHook instances.
 interface IJB721CheckpointsDeployer {
-    /// @notice Thrown when the caller is not the hook that the checkpoint module is being deployed for.
-    error JB721CheckpointsDeployer_Unauthorized();
-
     /// @notice The implementation contract that clones are based on.
     /// @return The implementation address.
     // forge-lint: disable-next-line(mixed-case-function)

package/src/interfaces/IJB721TiersHook.sol

@@ -18,14 +18,6 @@ import {JB721TiersSetDiscountPercentConfig} from "../structs/JB721TiersSetDiscou
 
 /// @notice A 721 tiers hook that mints tiered NFTs for payments and tracks their cash out weight.
 interface IJB721TiersHook is IJB721Hook {
-    /// @notice Emitted when an `addToBalanceOf` call reverts during leftover distribution. The funds remain
-    /// stranded in the hook contract.
-    /// @param projectId The project ID whose terminal reverted.
-    /// @param token The token being sent.
-    /// @param amount The amount that failed to send.
-    /// @param reason The revert reason bytes.
-    event AddToBalanceReverted(uint256 indexed projectId, address token, uint256 amount, bytes reason);
-
     /// @notice Emitted when pay credits are added for an account.
     /// @param amount The amount of credits added.
     /// @param newTotalCredits The new total credits balance for the account.
@@ -108,7 +100,7 @@ interface IJB721TiersHook is IJB721Hook {
     /// project's balance.
     /// @param projectId The project ID the split belongs to.
     /// @param split The split that reverted.
-    /// @param amount The amount that was being paid out.
+    /// @param amount The amount that was paid out.
     /// @param reason The revert reason bytes.
     /// @param caller The address that called the function.
     event SplitPayoutReverted(uint256 indexed projectId, JBSplit split, uint256 amount, bytes reason, address caller);
@@ -142,7 +134,7 @@ interface IJB721TiersHook is IJB721Hook {
 
     /// @notice Context for the pricing of this hook's tiers.
     /// @return currency The currency used for tier prices.
-    /// @return decimals The amount of decimals being used in tier prices.
+    /// @return decimals The number of decimals used in tier prices.
     function pricingContext() external view returns (uint256 currency, uint256 decimals);
 
     /// @notice The checkpoint module that manages IVotes-compatible checkpointed voting power for this hook's NFTs.

package/src/interfaces/IJB721TiersHookProjectDeployer.sol

@@ -40,7 +40,7 @@ interface IJB721TiersHookProjectDeployer {
         returns (uint256 projectId, IJB721TiersHook hook);
 
     /// @notice Launches rulesets for a project with an attached 721 tiers hook.
-    /// @param projectId The ID of the project that rulesets are being launched for.
+    /// @param projectId The ID of the project to launch rulesets for.
     /// @param deployTiersHookConfig Configuration which dictates the behavior of the 721 tiers hook.
     /// @param launchRulesetsConfig Configuration which dictates the project's new rulesets.
     /// @param projectUri Metadata URI to associate with the project. Pass an empty string to leave it unchanged.
@@ -60,7 +60,7 @@ interface IJB721TiersHookProjectDeployer {
         returns (uint256 rulesetId, IJB721TiersHook hook);
 
     /// @notice Queues rulesets for a project with an attached 721 tiers hook.
-    /// @param projectId The ID of the project that rulesets are being queued for.
+    /// @param projectId The ID of the project to queue rulesets for.
     /// @param deployTiersHookConfig Configuration which dictates the behavior of the 721 tiers hook.
     /// @param queueRulesetsConfig Configuration which dictates the project's newly queued rulesets.
     /// @param controller The controller that the project's rulesets will be queued with.

package/src/interfaces/IJB721TiersHookStore.sol

@@ -203,19 +203,19 @@ interface IJB721TiersHookStore {
 
     /// @notice Record newly added tiers.
     /// @param tiersToAdd The tiers to add.
-    /// @return tierIds The IDs of the tiers being added.
+    /// @return tierIds The IDs of the tiers added.
     function recordAddTiers(JB721TierConfig[] calldata tiersToAdd) external returns (uint256[] memory tierIds);
 
-    /// @notice Record 721 burns.
+    /// @notice Records the burning of tiered 721 tokens, updating supply tracking for the affected tiers.
     /// @param tokenIds The token IDs of the NFTs to burn.
     function recordBurn(uint256[] calldata tokenIds) external;
 
-    /// @notice Record newly set flags.
+    /// @notice Stores updated ruleset metadata flags that control minting, transferring, and tier behavior.
     /// @param flags The flags to set.
     function recordFlags(JB721TiersHookFlags calldata flags) external;
 
     /// @notice Record 721 mints from the provided tiers.
-    /// @param amount The amount being spent on NFTs.
+    /// @param amount The amount to spend on NFTs.
     /// @param tierIds The IDs of the tiers to mint from.
     /// @param isOwnerMint Whether this is a direct owner mint.
     /// @return tokenIds The token IDs of the NFTs which were minted.
@@ -235,13 +235,13 @@ interface IJB721TiersHookStore {
     /// @return tokenIds The token IDs of the reserve NFTs which were minted.
     function recordMintReservesFor(uint256 tierId, uint256 count) external returns (uint256[] memory tokenIds);
 
-    /// @notice Record tiers being removed.
-    /// @param tierIds The IDs of the tiers being removed.
+    /// @notice Record tiers to remove.
+    /// @param tierIds The IDs of the tiers to remove.
     function recordRemoveTierIds(uint256[] calldata tierIds) external;
 
     /// @notice Record the setting of a discount for a tier.
     /// @param tierId The ID of the tier to set the discount of.
-    /// @param discountPercent The new discount percent being applied.
+    /// @param discountPercent The new discount percent to apply.
     function recordSetDiscountPercentOf(uint256 tierId, uint256 discountPercent) external;
 
     /// @notice Record a new encoded IPFS URI for a tier.
@@ -254,9 +254,9 @@ interface IJB721TiersHookStore {
     /// @param resolver The resolver to set.
     function recordSetTokenUriResolver(IJB721TokenUriResolver resolver) external;
 
-    /// @notice Record an 721 transfer.
-    /// @param tierId The ID of the tier that the 721 being transferred belongs to.
-    /// @param from The address that the 721 is being transferred from.
-    /// @param to The address that the 721 is being transferred to.
+    /// @notice Records a 721 token transfer, updating the first-owner tracking for the receiving address.
+    /// @param tierId The ID of the tier that the 721 to transfer belongs to.
+    /// @param from The address to transfer the 721 from.
+    /// @param to The address to transfer the 721 to.
     function recordTransferForTier(uint256 tierId, address from, address to) external;
 }

package/src/libraries/JB721Constants.sol

@@ -3,6 +3,7 @@ pragma solidity 0.8.28;
 
 /// @notice Global constants used across 721 hook contracts.
 library JB721Constants {
+    /// @notice The denominator used when applying tier discount percentages.
     uint16 public constant DISCOUNT_DENOMINATOR = 200;
 
     /// @notice The metadata ID used to identify the 721 beneficiary entry in payment metadata.

package/src/libraries/JB721TiersHookLib.sol

@@ -31,7 +31,7 @@ library JB721TiersHookLib {
     // --------------------------- custom errors ------------------------- //
     //*********************************************************************//
 
-    error JB721TiersHook_CantBuyWithCredits();
+    error JB721TiersHook_CantBuyWithCredits(uint256 restrictedCost, uint256 freshValue);
     error JB721TiersHook_Overspending(uint256 leftoverAmount);
     error JB721TiersHookLib_NoTerminalForLeftover(uint256 projectId, address token, uint256 leftoverAmount);
     error JB721TiersHookLib_SplitFallbackFailed(uint256 projectId, address token, uint256 amount, bytes reason);
@@ -79,7 +79,6 @@ library JB721TiersHookLib {
                     ++i;
                 }
             }
-            // slither-disable-next-line reentrancy-events
             store.recordRemoveTierIds(tierIdsToRemove);
         }
 
@@ -87,7 +86,6 @@ library JB721TiersHookLib {
         if (tiersToAdd.length != 0) {
             uint256[] memory tierIdsAdded = store.recordAddTiers(tiersToAdd);
 
-            // slither-disable-next-line reentrancy-events
             for (uint256 i; i < tiersToAdd.length;) {
                 emit AddTier({tierId: tierIdsAdded[i], tier: tiersToAdd[i], caller: caller});
 
@@ -113,7 +111,7 @@ library JB721TiersHookLib {
     /// @param splits The splits contract to read tier split groups from.
     /// @param projectId The project ID of the hook.
     /// @param hookAddress The hook address (for computing split group IDs).
-    /// @param token The token being distributed.
+    /// @param token The token to distribute.
     /// @param amount The total amount to distribute.
     /// @param decimals The token decimals.
     /// @param encodedSplitData The encoded per-tier breakdown from hookMetadata.
@@ -135,7 +133,9 @@ library JB721TiersHookLib {
             SafeERC20.safeTransferFrom({token: IERC20(token), from: msg.sender, to: address(this), value: amount});
             uint256 receivedAmount = IERC20(token).balanceOf(address(this)) - balanceBefore;
             if (receivedAmount != amount) {
-                revert JB721TiersHookLib_TokenTransferAmountMismatch(amount, receivedAmount);
+                revert JB721TiersHookLib_TokenTransferAmountMismatch({
+                    expectedAmount: amount, receivedAmount: receivedAmount
+                });
             }
         }
 
@@ -223,16 +223,19 @@ library JB721TiersHookLib {
         if (tierIdsToMint.length != 0) {
             uint256 restrictedCost;
 
-            // slither-disable-next-line reentrancy-events,reentrancy-no-eth
             (tokenIds, leftoverAmount, restrictedCost) =
                 store.recordMint({amount: leftoverAmount, tierIds: tierIdsToMint, isOwnerMint: false});
 
             // Credit-restricted tiers must be fully covered by fresh payment (not stored credits).
-            if (restrictedCost > value) revert JB721TiersHook_CantBuyWithCredits();
+            if (restrictedCost > value) {
+                revert JB721TiersHook_CantBuyWithCredits({restrictedCost: restrictedCost, freshValue: value});
+            }
         }
 
         // If overspending isn't allowed, revert.
-        if (leftoverAmount != 0 && !allowOverspending) revert JB721TiersHook_Overspending(leftoverAmount);
+        if (leftoverAmount != 0 && !allowOverspending) {
+            revert JB721TiersHook_Overspending({leftoverAmount: leftoverAmount});
+        }
 
         // Compute the new pay credits balance: leftover + unused credits (held in newPayCredits).
         newPayCredits = leftoverAmount + newPayCredits;
@@ -259,7 +262,6 @@ library JB721TiersHookLib {
         uint256[] memory tierIdsAdded = store.recordAddTiers(tiersToAdd);
 
         for (uint256 i; i < tiersToAdd.length;) {
-            // slither-disable-next-line reentrancy-events
             emit AddTier({tierId: tierIdsAdded[i], tier: tiersToAdd[i], caller: caller});
 
             unchecked {
@@ -489,7 +491,6 @@ library JB721TiersHookLib {
 
         for (uint256 i; i < tierIdsToMint.length;) {
             // Get only the pricing fields (lightweight — avoids full struct construction).
-            // slither-disable-next-line calls-loop
             (uint104 tierPrice, uint32 tierSplitPercent, uint8 tierDiscountPercent) =
                 store.tierPricingOf({hook: hook, id: tierIdsToMint[i]});
             if (tierSplitPercent != 0) {
@@ -707,7 +708,6 @@ library JB721TiersHookLib {
     )
         private
     {
-        // slither-disable-next-line calls-loop
         JBSplit[] memory tierSplits = splitsContract.splitsOf({projectId: projectId, rulesetId: 0, groupId: groupId});
 
         bool isNativeToken = token == JBConstants.NATIVE_TOKEN;
@@ -725,7 +725,6 @@ library JB721TiersHookLib {
                 // On failure, don't re-add to leftoverAmount — this prevents inflating later recipients.
                 // Failed amounts accumulate as the gap between `amount` and `leftoverAmount + total sent`.
                 // After the loop, we re-add leftoverPercentage-based residual naturally.
-                // slither-disable-next-line calls-loop,reentrancy-no-eth,reentrancy-benign,reentrancy-events
                 if (!_sendPayoutToSplit({
                         directory: directory,
                         split: tierSplits[j],
@@ -752,14 +751,14 @@ library JB721TiersHookLib {
         leftoverAmount += amount;
 
         if (leftoverAmount != 0) {
-            // slither-disable-next-line calls-loop
             IJBTerminal terminal = directory.primaryTerminalOf({projectId: projectId, token: token});
             // Revert if there are leftover funds but no terminal to route them to.
             if (address(terminal) == address(0)) {
-                revert JB721TiersHookLib_NoTerminalForLeftover(projectId, token, leftoverAmount);
+                revert JB721TiersHookLib_NoTerminalForLeftover({
+                    projectId: projectId, token: token, leftoverAmount: leftoverAmount
+                });
             }
             if (isNativeToken) {
-                // slither-disable-next-line arbitrary-send-eth,calls-loop
                 try terminal.addToBalanceOf{value: leftoverAmount}({
                     projectId: projectId,
                     token: token,
@@ -769,11 +768,12 @@ library JB721TiersHookLib {
                     metadata: bytes("")
                 }) {}
                 catch (bytes memory reason) {
-                    revert JB721TiersHookLib_SplitFallbackFailed(projectId, token, leftoverAmount, reason);
+                    revert JB721TiersHookLib_SplitFallbackFailed({
+                        projectId: projectId, token: token, amount: leftoverAmount, reason: reason
+                    });
                 }
             } else {
                 SafeERC20.forceApprove({token: IERC20(token), spender: address(terminal), value: leftoverAmount});
-                // slither-disable-next-line calls-loop
                 try terminal.addToBalanceOf({
                     projectId: projectId,
                     token: token,
@@ -785,7 +785,9 @@ library JB721TiersHookLib {
                 catch (bytes memory reason) {
                     // Reset approval on failure.
                     SafeERC20.forceApprove({token: IERC20(token), spender: address(terminal), value: 0});
-                    revert JB721TiersHookLib_SplitFallbackFailed(projectId, token, leftoverAmount, reason);
+                    revert JB721TiersHookLib_SplitFallbackFailed({
+                        projectId: projectId, token: token, amount: leftoverAmount, reason: reason
+                    });
                 }
             }
         }
@@ -817,11 +819,9 @@ library JB721TiersHookLib {
             if (isNativeToken) {
                 // Wrap in try-catch so a reverting hook doesn't brick all project payments.
                 // On revert, ETH stays with the caller and we return false.
-                // slither-disable-next-line calls-loop,reentrancy-no-eth,reentrancy-events
                 try split.hook.processSplitWith{value: amount}(context) {
                     return true;
                 } catch (bytes memory reason) {
-                    // slither-disable-next-line reentrancy-events
                     emit SplitPayoutReverted({
                         projectId: projectId, split: split, amount: amount, reason: reason, caller: msg.sender
                     });
@@ -834,10 +834,8 @@ library JB721TiersHookLib {
                 // cause the caller to skip subtracting this amount from leftoverAmount, leading
                 // to a double-spend when the leftover is later sent to the project's balance.
                 SafeERC20.safeTransfer({token: IERC20(token), to: address(split.hook), value: amount});
-                // slither-disable-next-line calls-loop,reentrancy-no-eth,reentrancy-events
                 try split.hook.processSplitWith(context) {}
                 catch (bytes memory reason) {
-                    // slither-disable-next-line reentrancy-events
                     emit SplitPayoutReverted({
                         projectId: projectId, split: split, amount: amount, reason: reason, caller: msg.sender
                     });
@@ -845,14 +843,12 @@ library JB721TiersHookLib {
                 return true;
             }
         } else if (split.projectId != 0) {
-            // slither-disable-next-line calls-loop
             IJBTerminal terminal = directory.primaryTerminalOf({projectId: split.projectId, token: token});
             if (address(terminal) == address(0)) return false;
 
             // Wrap terminal calls in try-catch to prevent a failing terminal from bricking payments.
             if (split.preferAddToBalance) {
                 if (isNativeToken) {
-                    // slither-disable-next-line arbitrary-send-eth,calls-loop,reentrancy-no-eth,reentrancy-events
                     try terminal.addToBalanceOf{value: amount}({
                         projectId: split.projectId,
                         token: token,
@@ -863,7 +859,6 @@ library JB721TiersHookLib {
                     }) {
                         return true;
                     } catch (bytes memory reason) {
-                        // slither-disable-next-line reentrancy-events
                         emit SplitPayoutReverted({
                             projectId: projectId, split: split, amount: amount, reason: reason, caller: msg.sender
                         });
@@ -871,7 +866,6 @@ library JB721TiersHookLib {
                     }
                 } else {
                     SafeERC20.forceApprove({token: IERC20(token), spender: address(terminal), value: amount});
-                    // slither-disable-next-line calls-loop,reentrancy-no-eth,reentrancy-events
                     try terminal.addToBalanceOf({
                         projectId: split.projectId,
                         token: token,
@@ -884,7 +878,6 @@ library JB721TiersHookLib {
                     } catch (bytes memory reason) {
                         // Reset approval on failure so tokens aren't left approved to the terminal.
                         SafeERC20.forceApprove({token: IERC20(token), spender: address(terminal), value: 0});
-                        // slither-disable-next-line reentrancy-events
                         emit SplitPayoutReverted({
                             projectId: projectId, split: split, amount: amount, reason: reason, caller: msg.sender
                         });
@@ -893,7 +886,6 @@ library JB721TiersHookLib {
                 }
             } else {
                 if (isNativeToken) {
-                    // slither-disable-next-line arbitrary-send-eth,unused-return,calls-loop,reentrancy-events
                     try terminal.pay{value: amount}({
                         projectId: split.projectId,
                         token: token,
@@ -905,7 +897,6 @@ library JB721TiersHookLib {
                     }) {
                         return true;
                     } catch (bytes memory reason) {
-                        // slither-disable-next-line reentrancy-events
                         emit SplitPayoutReverted({
                             projectId: projectId, split: split, amount: amount, reason: reason, caller: msg.sender
                         });
@@ -913,7 +904,6 @@ library JB721TiersHookLib {
                     }
                 } else {
                     SafeERC20.forceApprove({token: IERC20(token), spender: address(terminal), value: amount});
-                    // slither-disable-next-line unused-return,calls-loop,reentrancy-no-eth,reentrancy-events
                     try terminal.pay({
                         projectId: split.projectId,
                         token: token,
@@ -927,7 +917,6 @@ library JB721TiersHookLib {
                     } catch (bytes memory reason) {
                         // Reset approval on failure so tokens aren't left approved to the terminal.
                         SafeERC20.forceApprove({token: IERC20(token), spender: address(terminal), value: 0});
-                        // slither-disable-next-line reentrancy-events
                         emit SplitPayoutReverted({
                             projectId: projectId, split: split, amount: amount, reason: reason, caller: msg.sender
                         });
@@ -937,7 +926,6 @@ library JB721TiersHookLib {
             }
         } else if (split.beneficiary != address(0)) {
             if (isNativeToken) {
-                // slither-disable-next-line arbitrary-send-eth,calls-loop
                 (bool success,) = split.beneficiary.call{value: amount}("");
                 if (!success) return false;
             } else {
@@ -945,7 +933,6 @@ library JB721TiersHookLib {
                 // false on failure instead of reverting. This handles non-standard tokens (e.g. USDT)
                 // that return void, while routing failed transfers to the project's balance instead
                 // of bricking all payments.
-                // slither-disable-next-line calls-loop
                 (bool callSuccess, bytes memory returndata) =
                     address(token).call(abi.encodeCall(IERC20.transfer, (split.beneficiary, amount)));
                 if (!callSuccess || (returndata.length != 0 && !abi.decode(returndata, (bool)))) return false;

package/src/libraries/JBBitmap.sol

@@ -32,7 +32,7 @@ library JBBitmap {
     /// @dev The `index` is the index that the bit would have if the bitmap were reshaped to a 1*n matrix.
     function isTierIdRemoved(mapping(uint256 => uint256) storage self, uint256 index) internal view returns (bool) {
         uint256 depth = _retrieveDepth(index);
-        return isTierIdRemoved(JBBitmapWord({currentWord: self[depth], currentDepth: depth}), index);
+        return isTierIdRemoved({self: JBBitmapWord({currentWord: self[depth], currentDepth: depth}), index: index});
     }
 
     /// @notice Set the bit at the given index to true, indicating that the corresponding tier has been removed.

package/src/structs/JB721TiersHookFlags.sol

@@ -8,7 +8,7 @@ pragma solidity ^0.8.0;
 /// @custom:member noNewTiersWithOwnerMinting A boolean indicating whether attempts to add new tiers with
 /// `allowOwnerMint` set to true will revert.
 /// @custom:member preventOverspending A boolean indicating whether payments attempting to spend more than the price of
-/// the NFTs being minted will revert.
+/// the NFTs to mint will revert.
 /// @custom:member issueTokensForSplits A boolean indicating whether payers receive token credit for the portion of
 /// their payment that is routed to tier splits. When false (default), weight is reduced proportionally.
 struct JB721TiersHookFlags {