@bananapus/721-hook-v6 0.0.52 → 0.0.54

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bananapus/721-hook-v6",
-  "version": "0.0.52",
+  "version": "0.0.54",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -28,10 +28,10 @@
     "artifacts": "source ./.env && npx sphinx artifacts --org-id 'ea165b21-7cdc-4d7b-be59-ecdd4c26bee4' --project-name 'nana-721-hook-v6'"
   },
   "dependencies": {
-    "@bananapus/address-registry-v6": "^0.0.25",
-    "@bananapus/core-v6": "^0.0.54",
-    "@bananapus/ownable-v6": "^0.0.25",
-    "@bananapus/permission-ids-v6": "^0.0.25",
+    "@bananapus/address-registry-v6": "^0.0.26",
+    "@bananapus/core-v6": "^0.0.57",
+    "@bananapus/ownable-v6": "^0.0.27",
+    "@bananapus/permission-ids-v6": "^0.0.26",
     "@openzeppelin/contracts": "5.6.1",
     "@prb/math": "4.1.1",
     "solady": "0.1.26"

package/src/JB721TiersHook.sol

@@ -44,6 +44,7 @@ contract JB721TiersHook is JBOwnable, ERC2771Context, JB721Hook, IJB721TiersHook
     error JB721TiersHook_AlreadyInitialized(uint256 projectId);
     error JB721TiersHook_InvalidPricingDecimals(uint256 decimals);
     error JB721TiersHook_MintReserveNftsPaused(uint256 projectId, uint256 tierId);
+    error JB721TiersHook_MissingSplitMetadata();
     error JB721TiersHook_NoProjectId(uint256 projectId);
     error JB721TiersHook_TierTransfersPaused(uint256 projectId, uint256 tokenId, address from, address to);
 
@@ -715,7 +716,11 @@ contract JB721TiersHook is JBOwnable, ERC2771Context, JB721Hook, IJB721TiersHook
         });
 
         // Distribute any forwarded funds to tier split groups.
-        if (splitData.length != 0 && context.forwardedAmount.value != 0) {
+        if (context.forwardedAmount.value != 0) {
+            if (splitData.length == 0) {
+                revert JB721TiersHook_MissingSplitMetadata();
+            }
+
             JB721TiersHookLib.distributeAll({
                 directory: DIRECTORY,
                 splits: SPLITS,

package/src/JB721TiersHookStore.sol

@@ -879,6 +879,20 @@ contract JB721TiersHookStore is IJB721TiersHookStore {
             currentSortedTierId = _nextSortedTierIdOf({hook: hook, id: currentSortedTierId, max: lastSortedTierId});
         }
 
+        if (previousSortedTierId != 0 && previousSortedTierId != lastSortedTierId) {
+            // All sorted IDs after `previousSortedTierId` were removed. Make the last active tier the traversal end so
+            // view functions do not keep walking a removed trailing suffix after cleanup.
+            if (_tierIdAfter[hook][previousSortedTierId] != 0) _tierIdAfter[hook][previousSortedTierId] = 0;
+
+            // Track the compacted end only when it is not the natural max tier ID. A zero value means
+            // `_lastSortedTierIdOf` can keep using `maxTierIdOf` as the implicit end.
+            uint256 maxTierId = maxTierIdOf[hook];
+            uint256 newLastTrackedSortedTierId = previousSortedTierId == maxTierId ? 0 : previousSortedTierId;
+            if (_lastTrackedSortedTierIdOf[hook] != newLastTrackedSortedTierId) {
+                _lastTrackedSortedTierIdOf[hook] = newLastTrackedSortedTierId;
+            }
+        }
+
         emit CleanTiers({hook: hook, caller: msg.sender});
     }
 
@@ -958,9 +972,8 @@ contract JB721TiersHookStore is IJB721TiersHookStore {
                 revert JB721TiersHookStore_VotingUnitsNotAllowed({tierId: tierId});
             }
 
-            // Make sure the new tier doesn't have a reserve frequency if the 721 contract's flags don't allow it to,
-            // OR if manual minting is allowed.
-            if ((flags.noNewTiersWithReserves || tierToAdd.flags.allowOwnerMint) && tierToAdd.reserveFrequency != 0) {
+            // Make sure the new tier doesn't have a reserve frequency if the 721 contract's flags don't allow it to.
+            if (flags.noNewTiersWithReserves && tierToAdd.reserveFrequency != 0) {
                 revert JB721TiersHookStore_ReserveFrequencyNotAllowed({tierId: tierId});
             }
 
@@ -1027,7 +1040,9 @@ contract JB721TiersHookStore is IJB721TiersHookStore {
                 _tierVotingUnitsOf[msg.sender][tierId] = uint32(tierToAdd.votingUnits);
             }
 
-            // If this is the first tier in a new category, store it as the first tier in that category.
+            // If this is the first tier in a category within this batch, store it as that category's traversal start.
+            // Same-category additions are inserted before older tiers in the category-sorted linked list, so a later
+            // batch must overwrite the previous start pointer to keep category-filtered `tiersOf` queries complete.
             // The `_startingTierIdOfCategory` of the category "0" will always be the same as the `_tierIdAfter` the 0th
             // tier.
             // Access the previous tier's category directly from calldata (0 when i == 0, matching the old

package/src/abstract/JB721Hook.sol

@@ -6,6 +6,7 @@ import {IJBDirectory} from "@bananapus/core-v6/src/interfaces/IJBDirectory.sol";
 import {IJBPayHook} from "@bananapus/core-v6/src/interfaces/IJBPayHook.sol";
 import {IJBRulesetDataHook} from "@bananapus/core-v6/src/interfaces/IJBRulesetDataHook.sol";
 import {IJBTerminal} from "@bananapus/core-v6/src/interfaces/IJBTerminal.sol";
+import {JBConstants} from "@bananapus/core-v6/src/libraries/JBConstants.sol";
 import {JBMetadataResolver} from "@bananapus/core-v6/src/libraries/JBMetadataResolver.sol";
 import {JBAfterCashOutRecordedContext} from "@bananapus/core-v6/src/structs/JBAfterCashOutRecordedContext.sol";
 import {JBAfterPayRecordedContext} from "@bananapus/core-v6/src/structs/JBAfterPayRecordedContext.sol";
@@ -32,6 +33,7 @@ abstract contract JB721Hook is ERC721, IJB721Hook {
 
     error JB721Hook_InvalidCashOut(address caller, uint256 contextProjectId, uint256 projectId, uint256 msgValue);
     error JB721Hook_InvalidPay(address caller, uint256 contextProjectId, uint256 projectId);
+    error JB721Hook_InvalidPayValue(address token, uint256 msgValue, uint256 forwardedValue);
     error JB721Hook_UnauthorizedToken(uint256 tokenId, address holder);
     error JB721Hook_UnexpectedTokenCashedOut(uint256 cashOutCount);
 
@@ -256,6 +258,17 @@ abstract contract JB721Hook is ERC721, IJB721Hook {
             });
         }
 
+        // Native-token payments must arrive as ETH on this hook call. ERC-20 payments are already held/forwarded by
+        // the terminal, so any ETH sent alongside an ERC-20 context would be accidental value trapped in the hook.
+        uint256 expectedMsgValue =
+            context.forwardedAmount.token == JBConstants.NATIVE_TOKEN ? context.forwardedAmount.value : 0;
+        // Keep the terminal-reported forwarded amount and the actual ETH attached to the callback in lockstep.
+        if (msg.value != expectedMsgValue) {
+            revert JB721Hook_InvalidPayValue({
+                token: context.forwardedAmount.token, msgValue: msg.value, forwardedValue: context.forwardedAmount.value
+            });
+        }
+
         // Process the payment.
         _processPayment(context);
     }

package/src/libraries/JB721TiersHookLib.sol

@@ -34,7 +34,9 @@ library JB721TiersHookLib {
     error JB721TiersHook_CantBuyWithCredits(uint256 restrictedCost, uint256 freshValue);
     error JB721TiersHook_Overspending(uint256 leftoverAmount);
     error JB721TiersHookLib_NoTerminalForLeftover(uint256 projectId, address token, uint256 leftoverAmount);
+    error JB721TiersHookLib_SplitAmountMismatch(uint256 expectedAmount, uint256 actualAmount);
     error JB721TiersHookLib_SplitFallbackFailed(uint256 projectId, address token, uint256 amount, bytes reason);
+    error JB721TiersHookLib_SplitMetadataLengthMismatch(uint256 tierIdCount, uint256 amountCount);
     error JB721TiersHookLib_TokenTransferAmountMismatch(uint256 expectedAmount, uint256 receivedAmount);
 
     //*********************************************************************//
@@ -127,6 +129,29 @@ library JB721TiersHookLib {
     )
         external
     {
+        // `encodedSplitData` is terminal-forwarded hook metadata. Each tier ID must have exactly one explicit amount so
+        // later split-group routing cannot pair a tier with the wrong value or silently ignore trailing data.
+        (uint16[] memory tierIds, uint256[] memory amounts) = abi.decode(encodedSplitData, (uint16[], uint256[]));
+        if (tierIds.length != amounts.length) {
+            revert JB721TiersHookLib_SplitMetadataLengthMismatch({
+                tierIdCount: tierIds.length, amountCount: amounts.length
+            });
+        }
+
+        // The terminal tells the hook how much value was forwarded. Require the per-tier split metadata to account for
+        // all of it before any transfers happen, otherwise malformed metadata could over-distribute, under-distribute,
+        // or leave funds stuck in the hook.
+        uint256 totalAmount;
+        for (uint256 i; i < amounts.length;) {
+            totalAmount += amounts[i];
+            unchecked {
+                ++i;
+            }
+        }
+        if (totalAmount != amount) {
+            revert JB721TiersHookLib_SplitAmountMismatch({expectedAmount: amount, actualAmount: totalAmount});
+        }
+
         // For ERC20 tokens, pull from terminal using the allowance it granted via _beforeTransferTo.
         if (token != JBConstants.NATIVE_TOKEN) {
             uint256 balanceBefore = IERC20(token).balanceOf(address(this));
@@ -139,8 +164,6 @@ library JB721TiersHookLib {
             }
         }
 
-        (uint16[] memory tierIds, uint256[] memory amounts) = abi.decode(encodedSplitData, (uint16[], uint256[]));
-
         for (uint256 i; i < tierIds.length;) {
             if (amounts[i] == 0) {
                 unchecked {

package/src/libraries/JB721TiersRulesetMetadataResolver.sol

@@ -7,11 +7,14 @@ import {JB721TiersRulesetMetadata} from "../structs/JB721TiersRulesetMetadata.so
 /// @notice Utility library to parse and store ruleset metadata associated for the tiered 721 hook.
 /// @dev This library parses the `metadata` member of the `JBRulesetMetadata` struct.
 library JB721TiersRulesetMetadataResolver {
-    /// @notice Check whether transfers are paused based on the packed ruleset metadata.
-    /// @param data The packed metadata to check.
-    /// @return Whether transfers are paused (bit 0).
-    function transfersPaused(uint256 data) internal pure returns (bool) {
-        return (data & 1) == 1;
+    /// @notice Expand packed ruleset metadata for the 721 hook.
+    /// @param packedMetadata The packed metadata to expand.
+    /// @return metadata The metadata as a `JB721TiersRulesetMetadata` struct.
+    function expandMetadata(uint16 packedMetadata) internal pure returns (JB721TiersRulesetMetadata memory metadata) {
+        return JB721TiersRulesetMetadata({
+            pauseTransfers: transfersPaused(packedMetadata),
+            pauseMintPendingReserves: mintPendingReservesPaused(packedMetadata)
+        });
     }
 
     /// @notice Check whether minting pending reserves is paused based on the packed ruleset metadata.
@@ -35,13 +38,10 @@ library JB721TiersRulesetMetadataResolver {
         if (metadata.pauseMintPendingReserves) packed |= 1 << 1;
     }
 
-    /// @notice Expand packed ruleset metadata for the 721 hook.
-    /// @param packedMetadata The packed metadata to expand.
-    /// @return metadata The metadata as a `JB721TiersRulesetMetadata` struct.
-    function expandMetadata(uint16 packedMetadata) internal pure returns (JB721TiersRulesetMetadata memory metadata) {
-        return JB721TiersRulesetMetadata({
-            pauseTransfers: transfersPaused(packedMetadata),
-            pauseMintPendingReserves: mintPendingReservesPaused(packedMetadata)
-        });
+    /// @notice Check whether transfers are paused based on the packed ruleset metadata.
+    /// @param data The packed metadata to check.
+    /// @return Whether transfers are paused (bit 0).
+    function transfersPaused(uint256 data) internal pure returns (bool) {
+        return (data & 1) == 1;
     }
 }

package/src/libraries/JBBitmap.sol

@@ -6,20 +6,6 @@ import {JBBitmapWord} from "../structs/JBBitmapWord.sol";
 /// @title JBBitmap
 /// @notice Utilities to manage a bool bitmap. Used for storing inactive tiers.
 library JBBitmap {
-    /// @notice Initialize a `JBBitmapWord` struct based on a mapping storage pointer and an index.
-    function readId(
-        mapping(uint256 => uint256) storage self,
-        uint256 index
-    )
-        internal
-        view
-        returns (JBBitmapWord memory)
-    {
-        uint256 depth = _retrieveDepth(index);
-
-        return JBBitmapWord({currentWord: self[depth], currentDepth: depth});
-    }
-
     /// @notice Get the status of the specified bit within the `JBBitmapWord` struct.
     /// @dev The `index` is the index that the bit would have if the bitmap were reshaped to a 1*n matrix.
     /// @return The boolean value at the specified index, which indicates whether the corresponding tier has been
@@ -35,12 +21,18 @@ library JBBitmap {
         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.
-    /// @dev This is a one-way operation.
-    function removeTier(mapping(uint256 => uint256) storage self, uint256 index) internal {
+    /// @notice Initialize a `JBBitmapWord` struct based on a mapping storage pointer and an index.
+    function readId(
+        mapping(uint256 => uint256) storage self,
+        uint256 index
+    )
+        internal
+        view
+        returns (JBBitmapWord memory)
+    {
         uint256 depth = _retrieveDepth(index);
-        // forge-lint: disable-next-line(incorrect-shift)
-        self[depth] |= uint256(1 << (index % 256));
+
+        return JBBitmapWord({currentWord: self[depth], currentDepth: depth});
     }
 
     /// @notice Check if the specified index is at a different depth than the current depth of the `JBBitmapWord`
@@ -51,6 +43,14 @@ library JBBitmap {
         return _retrieveDepth(index) != self.currentDepth;
     }
 
+    /// @notice Set the bit at the given index to true, indicating that the corresponding tier has been removed.
+    /// @dev This is a one-way operation.
+    function removeTier(mapping(uint256 => uint256) storage self, uint256 index) internal {
+        uint256 depth = _retrieveDepth(index);
+        // forge-lint: disable-next-line(incorrect-shift)
+        self[depth] |= uint256(1 << (index % 256));
+    }
+
     /// @notice Return the line number (depth) of a given index within the bitmap matrix.
     function _retrieveDepth(uint256 index) internal pure returns (uint256) {
         return index >> 8; // div by 256

package/src/libraries/JBIpfsDecoder.sol

@@ -29,8 +29,48 @@ library JBIpfsDecoder {
         return string(abi.encodePacked(baseUri, ipfsHash));
     }
 
-    /// @notice Convert a hex string to base58
-    /// @notice Written by Martin Ludfall - Licence: MIT
+    /// @notice Return a new array containing the elements of `input` in reverse order.
+    /// @dev Used by `_toBase58` after the base-58 digit accumulator is finalised — the conversion algorithm
+    /// emits least-significant digits first, but base-58 strings are read most-significant first.
+    /// @param input The array to reverse.
+    /// @return output A new array of the same length with elements in reverse order.
+    function _reverse(uint8[] memory input) private pure returns (uint8[] memory) {
+        uint256 inputLength = input.length;
+        uint8[] memory output = new uint8[](inputLength);
+        for (uint256 i; i < inputLength;) {
+            unchecked {
+                // Read from the tail of `input` and write to the head of `output`.
+                output[i] = input[input.length - 1 - i];
+                ++i;
+            }
+        }
+        return output;
+    }
+
+    /// @notice Map each base-58 digit (0–57) to its corresponding character in `ALPHABET`.
+    /// @dev Final stage of `_toBase58`: turns the numeric digit array into the canonical base-58 string bytes.
+    /// @param indices Each element must satisfy `0 <= indices[i] < 58`; out-of-range values revert via index OOB.
+    /// @return output ASCII bytes with `output[i] = ALPHABET[indices[i]]`.
+    function _toAlphabet(uint8[] memory indices) private pure returns (bytes memory) {
+        uint256 indicesLength = indices.length;
+        bytes memory output = new bytes(indicesLength);
+        for (uint256 i; i < indicesLength;) {
+            output[i] = ALPHABET[indices[i]];
+
+            unchecked {
+                ++i;
+            }
+        }
+        return output;
+    }
+
+    /// @notice Convert a hex byte string to its base-58 string representation.
+    /// @notice Written by Martin Ludfall — Licence: MIT.
+    /// @dev Classic "long division by 58" base conversion: iterate the source bytes high-to-low, carrying remainders
+    /// through the digit accumulator. After the loop, `digits[0..digitlength)` holds the base-58 representation in
+    /// little-endian order; the final composition reverses and maps to ASCII via `_toAlphabet(_reverse(...))`.
+    /// @param source The source bytes to convert (multibase-prefixed IPFS hash, in this library's usage).
+    /// @return The base-58 encoded string.
     function _toBase58(bytes memory source) private pure returns (string memory) {
         if (source.length == 0) return new string(0);
 
@@ -72,6 +112,12 @@ library JBIpfsDecoder {
         return string(_toAlphabet(_reverse(_truncate({array: digits, length: digitlength}))));
     }
 
+    /// @notice Copy the first `length` elements of `array` into a new, exactly-sized array.
+    /// @dev `_toBase58` allocates a fixed 46-byte scratch buffer but only fills `digitlength` of it; this trims the
+    /// trailing zeros so downstream stages (`_reverse`, `_toAlphabet`) see only the meaningful digits.
+    /// @param array The source array. Must have `array.length >= length`.
+    /// @param length Number of leading elements to copy.
+    /// @return output A new array of exactly `length` elements containing the prefix of `array`.
     function _truncate(uint8[] memory array, uint8 length) private pure returns (uint8[] memory) {
         uint8[] memory output = new uint8[](length);
         for (uint256 i; i < length;) {
@@ -83,29 +129,4 @@ library JBIpfsDecoder {
         }
         return output;
     }
-
-    function _reverse(uint8[] memory input) private pure returns (uint8[] memory) {
-        uint256 inputLength = input.length;
-        uint8[] memory output = new uint8[](inputLength);
-        for (uint256 i; i < inputLength;) {
-            unchecked {
-                output[i] = input[input.length - 1 - i];
-                ++i;
-            }
-        }
-        return output;
-    }
-
-    function _toAlphabet(uint8[] memory indices) private pure returns (bytes memory) {
-        uint256 indicesLength = indices.length;
-        bytes memory output = new bytes(indicesLength);
-        for (uint256 i; i < indicesLength;) {
-            output[i] = ALPHABET[indices[i]];
-
-            unchecked {
-                ++i;
-            }
-        }
-        return output;
-    }
 }

package/test/utils/ForTest_JB721TiersHook.sol

@@ -32,6 +32,8 @@ interface IJB721TiersHookStore_ForTest is IJB721TiersHookStore {
     // forge-lint: disable-next-line(mixed-case-function)
     function ForTest_dumpTiersList(address nft) external view returns (JB721Tier[] memory tiers);
     // forge-lint: disable-next-line(mixed-case-function)
+    function ForTest_lastSortedTierIdOf(address nft) external view returns (uint256 tierId);
+    // forge-lint: disable-next-line(mixed-case-function)
     function ForTest_setTier(address hook, uint256 index, JBStored721Tier calldata newTier) external;
     // forge-lint: disable-next-line(mixed-case-function)
     function ForTest_setTierVotingUnits(address hook, uint256 tierId, uint32 votingUnits) external;
@@ -191,6 +193,11 @@ contract ForTest_JB721TiersHookStore is JB721TiersHookStore, IJB721TiersHookStor
         }
     }
 
+    // forge-lint: disable-next-line(mixed-case-function)
+    function ForTest_lastSortedTierIdOf(address nft) public view override returns (uint256 tierId) {
+        tierId = _lastSortedTierIdOf(nft);
+    }
+
     // forge-lint: disable-next-line(mixed-case-function)
     function ForTest_setTier(address hook, uint256 index, JBStored721Tier calldata newTier) public override {
         _storedTierOf[address(hook)][index] = newTier;