@bananapus/721-hook-v6 0.0.1

package/src/structs/JBLaunchRulesetsConfig.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {JBTerminalConfig} from "@bananapus/core-v6/src/structs/JBTerminalConfig.sol";
+
+import {JBPayDataHookRulesetConfig} from "./JBPayDataHookRulesetConfig.sol";
+
+/// @custom:member projectId The ID of the project to launch rulesets for.
+/// @custom:member rulesetConfigurations The ruleset configurations to queue.
+/// @custom:member terminalConfigurations The terminal configurations to add for the project.
+/// @custom:member memo A memo to pass along to the emitted event.
+struct JBLaunchRulesetsConfig {
+    uint56 projectId;
+    JBPayDataHookRulesetConfig[] rulesetConfigurations;
+    JBTerminalConfig[] terminalConfigurations;
+    string memo;
+}

package/src/structs/JBPayDataHookRulesetConfig.sol

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IJBRulesetApprovalHook} from "@bananapus/core-v6/src/interfaces/IJBRulesetApprovalHook.sol";
+import {JBFundAccessLimitGroup} from "@bananapus/core-v6/src/structs/JBFundAccessLimitGroup.sol";
+import {JBSplitGroup} from "@bananapus/core-v6/src/structs/JBSplitGroup.sol";
+
+import {JBPayDataHookRulesetMetadata} from "./JBPayDataHookRulesetMetadata.sol";
+
+/// @custom:member mustStartAtOrAfter The earliest time the ruleset can start.
+/// @custom:member duration The number of seconds the ruleset lasts for, after which a new ruleset will start. A
+/// duration of 0 means that the ruleset will stay active until the project owner explicitly issues a reconfiguration,
+/// at which point a new ruleset will immediately start with the updated properties. If the duration is greater than 0,
+/// a project owner cannot make changes to a ruleset's parameters while it is active – any proposed changes will apply
+/// to the subsequent ruleset. If no changes are proposed, a ruleset rolls over to another one with the same properties
+/// but new `start` timestamp and a decayed `weight`.
+/// @custom:member weight A fixed point number with 18 decimals that contracts can use to base arbitrary calculations
+/// on. For example, payment terminals can use this to determine how many tokens should be minted when a payment is
+/// received.
+/// @custom:member weightCutPercent A percent by how much the `weight` of the subsequent ruleset should be reduced, if
+/// the
+/// project owner hasn't queued the subsequent ruleset with an explicit `weight`. If it's 0, each ruleset will have
+/// equal weight. If the number is 90%, the next ruleset will have a 10% smaller weight. This weight is out of
+/// `JBConstants.MAX_WEIGHT_CUT_PERCENT`.
+/// @custom:member approvalHook An address of a contract that says whether a proposed ruleset should be accepted or
+/// rejected. It
+/// can be used to create rules around how a project owner can change ruleset parameters over time.
+/// @custom:member metadata Metadata specifying the controller-specific parameters that a ruleset can have. These
+/// properties cannot change until the next ruleset starts.
+/// @custom:member splitGroups An array of splits to use for any number of groups while the ruleset is active.
+/// @custom:member fundAccessLimitGroups An array of structs which dictate the amount of funds a project can access from
+/// its balance in each payment terminal while the ruleset is active. Amounts are fixed point numbers using the same
+/// number of decimals as the corresponding terminal. The `payoutLimit` and `surplusAllowance` parameters must fit in
+/// a `uint232`.
+struct JBPayDataHookRulesetConfig {
+    uint48 mustStartAtOrAfter;
+    uint32 duration;
+    uint112 weight;
+    uint32 weightCutPercent;
+    IJBRulesetApprovalHook approvalHook;
+    JBPayDataHookRulesetMetadata metadata;
+    JBSplitGroup[] splitGroups;
+    JBFundAccessLimitGroup[] fundAccessLimitGroups;
+}

package/src/structs/JBPayDataHookRulesetMetadata.sol

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/// @custom:member reservedPercent The reserved percent of the ruleset. This number is a percentage calculated out of
+/// `JBConstants.MAX_RESERVED_PERCENT`.
+/// @custom:member cashOutTaxRate The cash out tax rate of the ruleset. This number is a percentage calculated out of
+/// `JBConstants.MAX_CASH_OUT_TAX_RATE`.
+/// @custom:member baseCurrency The currency on which to base the ruleset's weight.
+/// @custom:member pausePay A flag indicating if the pay functionality should be paused during the ruleset.
+/// @custom:member pauseCreditTransfers A flag indicating if the project token transfer functionality should be paused
+/// during the funding cycle.
+/// @custom:member allowOwnerMinting A flag indicating if the project owner or an operator with the `MINT_TOKENS`
+/// permission from the owner should be allowed to mint project tokens on demand during this ruleset.
+/// @custom:member allowTerminalMigration A flag indicating if migrating terminals should be allowed during this
+/// ruleset.
+/// @custom:member allowSetTerminals A flag indicating if a project's terminals can be added or removed.
+/// @custom:member allowSetController A flag indicating if a project's controller can be changed.
+/// @custom:member allowAddAccountingContext A flag indicating if a project can add new accounting contexts for its
+/// terminals to use.
+/// @custom:member allowAddPriceFeed A flag indicating if a project can add new price feeds to calculate exchange rates
+/// between its tokens.
+/// @custom:member holdFees A flag indicating if fees should be held during this ruleset.
+/// @custom:member useTotalSurplusForCashOut A flag indicating if cash outs should use the project's balance held
+/// in all terminals instead of the project's local terminal balance from which the cash out is being fulfilled.
+/// @custom:member useDataHookForCashOuts A flag indicating if the data hook should be used for cash out transactions
+/// during
+/// this ruleset.
+/// @custom:member metadata Metadata of the metadata, up to uint8 in size.
+struct JBPayDataHookRulesetMetadata {
+    uint16 reservedPercent;
+    uint16 cashOutTaxRate;
+    uint32 baseCurrency;
+    bool pausePay;
+    bool pauseCreditTransfers;
+    bool allowOwnerMinting;
+    bool allowTerminalMigration;
+    bool allowSetTerminals;
+    bool allowSetController;
+    bool allowAddAccountingContext;
+    bool allowAddPriceFeed;
+    bool ownerMustSendPayouts;
+    bool holdFees;
+    bool useTotalSurplusForCashOuts;
+    bool useDataHookForCashOut;
+    uint16 metadata;
+}

package/src/structs/JBQueueRulesetsConfig.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {JBPayDataHookRulesetConfig} from "./JBPayDataHookRulesetConfig.sol";
+
+/// @custom:member projectId The ID of the project to queue rulesets for.
+/// @custom:member rulesetConfigurations The ruleset configurations to queue.
+/// @custom:member memo A memo to pass along to the emitted event.
+struct JBQueueRulesetsConfig {
+    uint56 projectId;
+    JBPayDataHookRulesetConfig[] rulesetConfigurations;
+    string memo;
+}

package/src/structs/JBStored721Tier.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/// @custom:member price The price to buy an NFT in this tier, in terms of the currency in its `JBInitTiersConfig`.
+/// @custom:member remainingSupply The remaining number of NFTs which can be minted from this tier.
+/// @custom:member initialSupply The total number of NFTs which can be minted from this tier.
+/// @custom:member votingUnits The number of votes that each NFT in this tier gets.
+/// @custom:member category The category that NFTs in this tier belongs to. Used to group NFT tiers.
+/// @custom:member discountPercent The discount that should be applied to the tier.
+/// @custom:member reserveFrequency The frequency at which an extra NFT is minted for the `reserveBeneficiary` from this
+/// tier. With a `reserveFrequency` of 5, an extra NFT will be minted for the `reserveBeneficiary` for every 5 NFTs
+/// purchased.
+/// @custom:member packedBools A packed uint8 containing boolean flags: bit 0 = allowOwnerMint, bit 1 =
+/// transfersPausable, bit 2 = useVotingUnits, bit 3 = cannotBeRemoved, bit 4 = cannotIncreaseDiscountPercent.
+struct JBStored721Tier {
+    uint104 price;
+    uint32 remainingSupply;
+    uint32 initialSupply;
+    uint32 votingUnits;
+    uint24 category;
+    uint8 discountPercent;
+    uint16 reserveFrequency;
+    uint8 packedBools;
+}

package/test/721HookAttacks.t.sol

@@ -0,0 +1,396 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import "./utils/UnitTestSetup.sol";
+
+/// @title 721HookAttacks
+/// @notice Adversarial security tests for JB721TiersHook and JB721TiersHookStore.
+contract NFTHookAttacks is UnitTestSetup {
+    using stdStorage for StdStorage;
+
+    // =========================================================================
+    // Helpers
+    // =========================================================================
+
+    /// @dev Mock the directory to accept `mockTerminalAddress` as a terminal for `projectId`.
+    function _mockTerminalAuth() internal {
+        mockAndExpect(
+            mockJBDirectory,
+            abi.encodeWithSelector(IJBDirectory.isTerminalOf.selector, projectId, mockTerminalAddress),
+            abi.encode(true)
+        );
+    }
+
+    /// @dev Create a pay context that requests minting specific tier IDs.
+    function _buildPayContext(
+        address targetHook,
+        uint256 value,
+        uint16[] memory tierIds
+    )
+        internal
+        view
+        returns (JBAfterPayRecordedContext memory)
+    {
+        bytes[] memory data = new bytes[](1);
+        data[0] = abi.encode(false, tierIds);
+        bytes4[] memory ids = new bytes4[](1);
+        ids[0] = metadataHelper.getId("pay", targetHook);
+        bytes memory hookMetadata = metadataHelper.createMetadata(ids, data);
+
+        return JBAfterPayRecordedContext({
+            payer: beneficiary,
+            projectId: projectId,
+            rulesetId: 0,
+            amount: JBTokenAmount({
+                token: JBConstants.NATIVE_TOKEN,
+                value: value,
+                decimals: 18,
+                currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
+            }),
+            forwardedAmount: JBTokenAmount({
+                token: JBConstants.NATIVE_TOKEN,
+                value: 0,
+                decimals: 18,
+                currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
+            }),
+            weight: 10 ** 18,
+            newlyIssuedTokenCount: 0,
+            beneficiary: beneficiary,
+            hookMetadata: bytes(""),
+            payerMetadata: hookMetadata
+        });
+    }
+
+    // =========================================================================
+    // Test 1: Zero-price tier — can an attacker mint for free?
+    // =========================================================================
+    /// @notice Add a tier with price=0 via adjustTiers. Verify the hook handles it correctly.
+    function test_zeroPriceTier_mintBehavior() public {
+        // Create hook with 1 default tier (price=10).
+        ForTest_JB721TiersHook targetHook = _initializeForTestHook(1);
+
+        // Add a zero-price tier via adjustTiers (tier ID 2).
+        JB721TierConfig[] memory newTiers = new JB721TierConfig[](1);
+        newTiers[0] = JB721TierConfig({
+            price: 0,
+            initialSupply: 100,
+            votingUnits: 0,
+            reserveFrequency: 0,
+            reserveBeneficiary: reserveBeneficiary,
+            encodedIPFSUri: tokenUris[0],
+            category: 2,
+            discountPercent: 0,
+            allowOwnerMint: false,
+            useReserveBeneficiaryAsDefault: false,
+            transfersPausable: false,
+            cannotBeRemoved: false,
+            cannotIncreaseDiscountPercent: false,
+            useVotingUnits: false
+        });
+
+        vm.prank(owner);
+        targetHook.adjustTiers(newTiers, new uint256[](0));
+
+        _mockTerminalAuth();
+
+        // Try to mint tier 2 (price=0) with 0 value.
+        uint16[] memory tierIds = new uint16[](1);
+        tierIds[0] = 2;
+
+        JBAfterPayRecordedContext memory ctx = _buildPayContext(address(targetHook), 0, tierIds);
+
+        vm.prank(mockTerminalAddress);
+        targetHook.afterPayRecordedWith(ctx);
+
+        // Verify the NFT was minted to the beneficiary.
+        assertEq(targetHook.balanceOf(beneficiary), 1, "Should mint 1 NFT at price 0");
+    }
+
+    // =========================================================================
+    // Test 2: Discount percent at maximum — effective price becomes 0
+    // =========================================================================
+    /// @notice Set discount to 100%, verify the effective price for the tier.
+    function test_maxDiscountPercent_effectivePrice() public {
+        defaultTierConfig.discountPercent = 0;
+        defaultTierConfig.cannotIncreaseDiscountPercent = false;
+
+        JB721TiersHook targetHook = _initHookDefaultTiers(1);
+
+        // Owner sets discount to 100%.
+        vm.mockCall(mockJBPermissions, abi.encodeWithSelector(IJBPermissions.hasPermission.selector), abi.encode(true));
+
+        vm.prank(owner);
+        targetHook.setDiscountPercentOf(1, 100);
+
+        // Read the tier and verify the discount was applied.
+        JB721Tier memory tier = store.tierOf(address(targetHook), 1, false);
+        assertEq(tier.discountPercent, 100, "Discount should be 100%");
+    }
+
+    // =========================================================================
+    // Test 3: cannotIncreaseDiscountPercent flag enforcement
+    // =========================================================================
+    /// @notice Try to increase discount when the flag forbids it.
+    function test_cannotIncreaseDiscountPercent_enforcement() public {
+        defaultTierConfig.discountPercent = 10;
+        defaultTierConfig.cannotIncreaseDiscountPercent = true;
+
+        JB721TiersHook targetHook = _initHookDefaultTiers(1);
+
+        vm.mockCall(mockJBPermissions, abi.encodeWithSelector(IJBPermissions.hasPermission.selector), abi.encode(true));
+
+        // Try to increase discount from 10 to 50 — should revert.
+        vm.prank(owner);
+        vm.expectRevert();
+        targetHook.setDiscountPercentOf(1, 50);
+
+        // Decreasing should still work.
+        vm.prank(owner);
+        targetHook.setDiscountPercentOf(1, 5);
+
+        JB721Tier memory tier = store.tierOf(address(targetHook), 1, false);
+        assertEq(tier.discountPercent, 5, "Discount decrease should work");
+    }
+
+    // =========================================================================
+    // Test 4: Reserve minting drain — high reserve frequency
+    // =========================================================================
+    /// @notice With reserveFrequency=1 (reserve on every mint), mint 5 paid NFTs
+    ///         then call mintPendingReservesFor to drain reserves.
+    function test_reserveDrain_highFrequency() public {
+        defaultTierConfig.initialSupply = 100;
+        defaultTierConfig.reserveFrequency = 1; // Reserve 1 per 1 paid mint.
+
+        ForTest_JB721TiersHook targetHook = _initializeForTestHook(1);
+        IJB721TiersHookStore hookStore = targetHook.STORE();
+
+        _mockTerminalAuth();
+
+        // Mint 5 paid NFTs from tier 1 (price=10 each, so value=50).
+        uint16[] memory tierIds = new uint16[](5);
+        for (uint256 i; i < 5; i++) {
+            tierIds[i] = 1;
+        }
+
+        JBAfterPayRecordedContext memory ctx = _buildPayContext(address(targetHook), 50, tierIds);
+
+        vm.prank(mockTerminalAddress);
+        targetHook.afterPayRecordedWith(ctx);
+
+        assertEq(targetHook.balanceOf(beneficiary), 5, "5 paid NFTs minted");
+
+        // Pending reserves should be 5 (1 per paid mint with frequency=1).
+        // With frequency=1: reserveCount = nftsMinted / frequency = 5, plus 1 if remainder > 0.
+        // 5/1 = 5, remainder 0, so pending = 5+1 = 6? Actually the formula is:
+        // numberOfPendingReservesFor = (numberOfMints + frequency - 1) / frequency - processedReserves
+        // Let's just check what the store reports.
+        uint256 pending = hookStore.numberOfPendingReservesFor(address(targetHook), 1);
+        assertTrue(pending > 0, "Should have pending reserves");
+
+        // Mint all pending reserves.
+        vm.prank(owner);
+        targetHook.mintPendingReservesFor(1, pending);
+
+        // After minting, pending should be 0.
+        uint256 pendingAfter = hookStore.numberOfPendingReservesFor(address(targetHook), 1);
+        assertEq(pendingAfter, 0, "No pending reserves after minting");
+
+        // Try to mint more reserves — should revert (nothing pending).
+        vm.prank(owner);
+        vm.expectRevert();
+        targetHook.mintPendingReservesFor(1, 1);
+    }
+
+    // =========================================================================
+    // Test 5: Cash-out weight after tier removal
+    // =========================================================================
+    /// @notice Mint NFTs from a tier, then remove the tier. Verify that
+    ///         totalCashOutWeight still accounts for the minted tokens.
+    function test_cashOutWeight_afterTierRemoval() public {
+        defaultTierConfig.initialSupply = 100;
+        defaultTierConfig.votingUnits = 10;
+        defaultTierConfig.useVotingUnits = true;
+
+        ForTest_JB721TiersHook targetHook = _initializeForTestHook(1);
+        IJB721TiersHookStore hookStore = targetHook.STORE();
+
+        _mockTerminalAuth();
+
+        // Mint 3 NFTs from tier 1 (price=10 each, value=30).
+        uint16[] memory tierIds = new uint16[](3);
+        tierIds[0] = 1;
+        tierIds[1] = 1;
+        tierIds[2] = 1;
+
+        JBAfterPayRecordedContext memory ctx = _buildPayContext(address(targetHook), 30, tierIds);
+
+        vm.prank(mockTerminalAddress);
+        targetHook.afterPayRecordedWith(ctx);
+
+        assertEq(targetHook.balanceOf(beneficiary), 3, "3 NFTs minted");
+
+        // Get total cash-out weight before removal (from the store).
+        uint256 weightBefore = hookStore.totalCashOutWeight(address(targetHook));
+
+        // Remove tier 1.
+        vm.mockCall(mockJBPermissions, abi.encodeWithSelector(IJBPermissions.hasPermission.selector), abi.encode(true));
+
+        uint256[] memory tierIdsToRemove = new uint256[](1);
+        tierIdsToRemove[0] = 1;
+
+        vm.prank(owner);
+        targetHook.adjustTiers(new JB721TierConfig[](0), tierIdsToRemove);
+
+        // Verify the tier is removed.
+        assertTrue(hookStore.isTierRemoved(address(targetHook), 1), "Tier should be removed");
+
+        // Total cash-out weight should still include the minted tokens.
+        uint256 weightAfter = hookStore.totalCashOutWeight(address(targetHook));
+        assertEq(weightAfter, weightBefore, "Cash-out weight should be preserved after removal");
+    }
+
+    // =========================================================================
+    // Test 6: Invalid tier ID in pay metadata — reverts when overspending prevented
+    // =========================================================================
+    /// @notice Pass a tier ID that doesn't exist. With preventOverspending=true, must revert.
+    function test_invalidTierIdInMetadata_reverts() public {
+        // Use preventOverspending=true so invalid tiers cause a revert.
+        JB721TiersHook targetHook = _initHookDefaultTiers(1, true);
+
+        _mockTerminalAuth();
+
+        // Try to mint tier 999 which doesn't exist.
+        uint16[] memory tierIds = new uint16[](1);
+        tierIds[0] = 999;
+
+        JBAfterPayRecordedContext memory ctx = _buildPayContext(address(targetHook), 1 ether, tierIds);
+
+        vm.prank(mockTerminalAddress);
+        vm.expectRevert();
+        targetHook.afterPayRecordedWith(ctx);
+    }
+
+    // =========================================================================
+    // Test 7: Duplicate tier IDs in pay metadata — mints multiple NFTs
+    // =========================================================================
+    /// @notice Pass the same tier ID multiple times. Should mint multiple NFTs
+    ///         from that tier.
+    function test_duplicateTierIdsInMetadata_mintsMultiple() public {
+        defaultTierConfig.initialSupply = 100;
+
+        ForTest_JB721TiersHook targetHook = _initializeForTestHook(1);
+        IJB721TiersHookStore hookStore = targetHook.STORE();
+
+        _mockTerminalAuth();
+
+        // Mint 3 of the same tier (price=10 each, value=30).
+        uint16[] memory tierIds = new uint16[](3);
+        tierIds[0] = 1;
+        tierIds[1] = 1;
+        tierIds[2] = 1;
+
+        JBAfterPayRecordedContext memory ctx = _buildPayContext(address(targetHook), 30, tierIds);
+
+        vm.prank(mockTerminalAddress);
+        targetHook.afterPayRecordedWith(ctx);
+
+        assertEq(targetHook.balanceOf(beneficiary), 3, "3 NFTs minted from same tier");
+
+        // Verify remaining supply decreased.
+        JB721Tier memory tier = hookStore.tierOf(address(targetHook), 1, false);
+        assertEq(tier.remainingSupply, 97, "Supply should decrease by 3");
+    }
+
+    // =========================================================================
+    // Test 8: Supply exhaustion — no additional NFTs minted after supply drained
+    // =========================================================================
+    /// @notice Mint the entire supply of a tier, then verify no more can be minted.
+    function test_supplyExhaustion_noOvermint() public {
+        defaultTierConfig.initialSupply = 3; // Only 3 available.
+        defaultTierConfig.reserveFrequency = 0; // No reserves to keep it simple.
+
+        ForTest_JB721TiersHook targetHook = _initializeForTestHook(1);
+        IJB721TiersHookStore hookStore = targetHook.STORE();
+
+        _mockTerminalAuth();
+
+        // Mint all 3 (price=10 each, value=30).
+        uint16[] memory tierIds = new uint16[](3);
+        tierIds[0] = 1;
+        tierIds[1] = 1;
+        tierIds[2] = 1;
+
+        JBAfterPayRecordedContext memory ctx = _buildPayContext(address(targetHook), 30, tierIds);
+
+        vm.prank(mockTerminalAddress);
+        targetHook.afterPayRecordedWith(ctx);
+
+        assertEq(targetHook.balanceOf(beneficiary), 3, "All 3 minted");
+
+        // Verify supply is exhausted.
+        JB721Tier memory tier = hookStore.tierOf(address(targetHook), 1, false);
+        assertEq(tier.remainingSupply, 0, "No remaining supply");
+
+        // Try to mint one more — store enforces supply limit and reverts.
+        uint16[] memory oneMore = new uint16[](1);
+        oneMore[0] = 1;
+
+        JBAfterPayRecordedContext memory ctx2 = _buildPayContext(address(targetHook), 10, oneMore);
+
+        vm.prank(mockTerminalAddress);
+        vm.expectRevert();
+        targetHook.afterPayRecordedWith(ctx2);
+    }
+
+    // =========================================================================
+    // Test 9: adjustTiers without permission — must revert
+    // =========================================================================
+    /// @notice Non-owner without ADJUST_721_TIERS permission tries to add/remove tiers.
+    function test_adjustTiers_noPermission_reverts() public {
+        JB721TiersHook targetHook = _initHookDefaultTiers(1);
+
+        // Mock permissions to return false.
+        vm.mockCall(mockJBPermissions, abi.encodeWithSelector(IJBPermissions.hasPermission.selector), abi.encode(false));
+
+        address attacker = makeAddr("attacker");
+
+        // Try to add a new tier.
+        JB721TierConfig[] memory newTiers = new JB721TierConfig[](1);
+        newTiers[0] = JB721TierConfig({
+            price: 1,
+            initialSupply: type(uint32).max,
+            votingUnits: 0,
+            reserveFrequency: 0,
+            reserveBeneficiary: attacker,
+            encodedIPFSUri: tokenUris[0],
+            category: 1,
+            discountPercent: 0,
+            allowOwnerMint: true,
+            useReserveBeneficiaryAsDefault: false,
+            transfersPausable: false,
+            cannotBeRemoved: false,
+            cannotIncreaseDiscountPercent: false,
+            useVotingUnits: false
+        });
+
+        vm.prank(attacker);
+        vm.expectRevert();
+        targetHook.adjustTiers(newTiers, new uint256[](0));
+    }
+
+    // =========================================================================
+    // Test 10: Tier with max supply — verify no overflow
+    // =========================================================================
+    /// @notice Add a tier with initialSupply = 999_999_999 (store maximum).
+    ///         Verify it's created correctly and doesn't overflow.
+    function test_maxSupplyTier_noOverflow() public {
+        defaultTierConfig.initialSupply = 999_999_999; // Store maximum
+
+        JB721TiersHook targetHook = _initHookDefaultTiers(1);
+
+        // Read the tier to verify the supply was stored correctly.
+        JB721Tier memory tier = store.tierOf(address(targetHook), 1, false);
+        assertEq(tier.initialSupply, 999_999_999, "Initial supply should be 999_999_999");
+        assertEq(tier.remainingSupply, 999_999_999, "Remaining supply should be 999_999_999");
+    }
+}