@bananapus/721-hook-v6 0.0.1

package/test/invariants/TierLifecycleInvariant.t.sol

@@ -0,0 +1,187 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import "forge-std/StdInvariant.sol";
+import "../utils/UnitTestSetup.sol";
+import "./handlers/TierLifecycleHandler.sol";
+
+/// @title TierLifecycleInvariant
+/// @notice State machine fuzzing for 721 tier lifecycle.
+///         6 invariants covering supply, cash out weight, credits, reserves, removal, and discounts.
+contract TierLifecycleInvariant_Local is StdInvariant, UnitTestSetup {
+    TierLifecycleHandler public handler;
+
+    function setUp() public override {
+        super.setUp();
+
+        handler = new TierLifecycleHandler(hook, store, owner, mockJBController);
+
+        bytes4[] memory selectors = new bytes4[](10);
+        selectors[0] = TierLifecycleHandler.payAndMintNFT.selector;
+        selectors[1] = TierLifecycleHandler.cashOutNFT.selector;
+        selectors[2] = TierLifecycleHandler.addTier.selector;
+        selectors[3] = TierLifecycleHandler.removeTier.selector;
+        selectors[4] = TierLifecycleHandler.mintReserves.selector;
+        selectors[5] = TierLifecycleHandler.setDiscount.selector;
+        selectors[6] = TierLifecycleHandler.ownerMint.selector;
+        selectors[7] = TierLifecycleHandler.advanceTime.selector;
+        // Double-weight common operations
+        selectors[8] = TierLifecycleHandler.payAndMintNFT.selector;
+        selectors[9] = TierLifecycleHandler.payAndMintNFT.selector;
+
+        targetSelector(FuzzSelector({addr: address(handler), selectors: selectors}));
+        targetContract(address(handler));
+    }
+
+    // =========================================================================
+    // INV-721-1: Per-tier supply accounting
+    // =========================================================================
+    /// @notice For each active tier: remaining + minted == initialSupply.
+    ///         minted = initialSupply - remaining (from store), should match ghost tracking.
+    function invariant_721_1_perTierSupplyAccounting() public {
+        uint256 maxTierId = store.maxTierIdOf(address(hook));
+
+        for (uint256 tierId = 1; tierId <= maxTierId; tierId++) {
+            // Get tier info
+            uint256[] memory categories = new uint256[](0);
+            JB721Tier[] memory allTiers = store.tiersOf(address(hook), categories, false, 0, 100);
+
+            for (uint256 i = 0; i < allTiers.length; i++) {
+                if (allTiers[i].id == tierId) {
+                    uint256 initial = allTiers[i].initialSupply;
+                    uint256 remaining = allTiers[i].remainingSupply;
+                    uint256 burned = store.numberOfBurnedFor(address(hook), tierId);
+
+                    // remaining + (minted including burned) should relate to initial
+                    // minted = initial - remaining (total ever minted)
+                    uint256 totalMinted = initial - remaining;
+                    // totalMinted >= burned (can't burn more than minted)
+                    assertGe(totalMinted, burned, "INV-721-1: Cannot burn more NFTs than were minted from tier");
+
+                    // Outstanding = totalMinted - burned
+                    uint256 outstanding = totalMinted - burned;
+
+                    // Verify: remaining + outstanding + burned == initial
+                    assertEq(remaining + outstanding + burned, initial, "INV-721-1: Supply accounting mismatch");
+                    break;
+                }
+            }
+        }
+    }
+
+    // =========================================================================
+    // INV-721-2: Total cash out weight consistency
+    // =========================================================================
+    /// @notice totalCashOutWeight should equal sum(tier.price * outstanding) for all tiers.
+    function invariant_721_2_totalCashOutWeightConsistency() public {
+        uint256 totalWeight = store.totalCashOutWeight(address(hook));
+
+        uint256 maxTierId = store.maxTierIdOf(address(hook));
+        uint256 computedWeight = 0;
+
+        uint256[] memory categories = new uint256[](0);
+        JB721Tier[] memory allTiers = store.tiersOf(address(hook), categories, false, 0, 100);
+
+        for (uint256 i = 0; i < allTiers.length; i++) {
+            uint256 tierId = allTiers[i].id;
+            uint256 initial = allTiers[i].initialSupply;
+            uint256 remaining = allTiers[i].remainingSupply;
+            uint256 burned = store.numberOfBurnedFor(address(hook), tierId);
+            uint256 price = allTiers[i].price;
+
+            // Outstanding = minted - burned
+            uint256 minted = initial - remaining;
+            uint256 outstanding = minted > burned ? minted - burned : 0;
+
+            // Pending reserves are also counted in totalCashOutWeight
+            // (included in the store's calculation)
+            computedWeight += price * outstanding;
+        }
+
+        // totalWeight >= computedWeight (it also includes pending reserves)
+        assertGe(totalWeight, computedWeight, "INV-721-2: totalCashOutWeight must >= sum(price * outstanding)");
+    }
+
+    // =========================================================================
+    // INV-721-3: Pay credits non-negative
+    // =========================================================================
+    /// @notice Pay credits for each actor should be >= 0 (trivially true for uint,
+    ///         but verifies no underflow/corruption).
+    function invariant_721_3_payCreditsNonNegative() public {
+        for (uint256 i = 0; i < handler.NUM_ACTORS(); i++) {
+            address actor = handler.getActor(i);
+            uint256 credits = hook.payCreditsOf(actor);
+            // uint256 is always >= 0, but this validates the slot isn't corrupted
+            assertGe(credits, 0, "INV-721-3: Pay credits should be non-negative");
+        }
+    }
+
+    // =========================================================================
+    // INV-721-4: Reserve mints bounded by frequency
+    // =========================================================================
+    /// @notice For each tier with reserve frequency > 0:
+    ///         reservesMinted <= ceil(totalMinted / reserveFrequency).
+    function invariant_721_4_reserveMintsBounded() public {
+        uint256[] memory categories = new uint256[](0);
+        JB721Tier[] memory allTiers = store.tiersOf(address(hook), categories, false, 0, 100);
+
+        for (uint256 i = 0; i < allTiers.length; i++) {
+            uint256 tierId = allTiers[i].id;
+            uint16 reserveFreq = allTiers[i].reserveFrequency;
+
+            if (reserveFreq == 0) continue;
+
+            uint256 reservesMinted = store.numberOfReservesMintedFor(address(hook), tierId);
+            uint256 initial = allTiers[i].initialSupply;
+            uint256 remaining = allTiers[i].remainingSupply;
+            uint256 totalMinted = initial - remaining;
+
+            // Non-reserve mints = totalMinted - reservesMinted
+            uint256 nonReserveMints = totalMinted > reservesMinted ? totalMinted - reservesMinted : 0;
+
+            // Max allowed reserves = ceil(nonReserveMints / reserveFrequency)
+            uint256 maxReserves = 0;
+            if (nonReserveMints > 0) {
+                maxReserves = (nonReserveMints + reserveFreq - 1) / reserveFreq;
+            }
+
+            assertLe(reservesMinted, maxReserves, "INV-721-4: Reserve mints exceed allowed maximum");
+        }
+    }
+
+    // =========================================================================
+    // INV-721-5: Removed tiers tracked correctly
+    // =========================================================================
+    /// @notice Removed tiers should not appear in tiersOf() listing.
+    function invariant_721_5_removedTiersExcluded() public {
+        uint256[] memory categories = new uint256[](0);
+        JB721Tier[] memory activeTiers = store.tiersOf(address(hook), categories, false, 0, 200);
+
+        for (uint256 i = 0; i < activeTiers.length; i++) {
+            // If handler tracked this tier as removed, it should NOT appear in active list
+            assertFalse(
+                handler.ghost_tierRemoved(activeTiers[i].id),
+                "INV-721-5: Removed tier should not appear in active tiers list"
+            );
+        }
+    }
+
+    // =========================================================================
+    // INV-721-6: Cash out weight bounded after discount
+    // =========================================================================
+    /// @notice After setDiscount, the per-token cash out weight should be <= original price.
+    function invariant_721_6_cashOutWeightBoundedByPrice() public {
+        uint256[] memory categories = new uint256[](0);
+        JB721Tier[] memory allTiers = store.tiersOf(address(hook), categories, false, 0, 100);
+
+        for (uint256 i = 0; i < allTiers.length; i++) {
+            uint256 tierId = allTiers[i].id;
+            uint256 price = allTiers[i].price;
+
+            // Cash out weight per token for this tier is just `price` (from the store)
+            // The discount only affects the mint price, not the cash out weight
+            // But verify the store returns a non-corrupt price
+            assertGt(price, 0, "INV-721-6: Tier price should be > 0 for active tiers");
+        }
+    }
+}

package/test/invariants/TieredHookStoreInvariant.t.sol

@@ -0,0 +1,81 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import "forge-std/Test.sol";
+
+import {JB721TiersHookStore} from "../../src/JB721TiersHookStore.sol";
+import {JB721TierConfig} from "../../src/structs/JB721TierConfig.sol";
+import {JBStored721Tier} from "../../src/structs/JBStored721Tier.sol";
+import {JB721TiersHookFlags} from "../../src/structs/JB721TiersHookFlags.sol";
+import {JBBitmapWord} from "../../src/structs/JBBitmapWord.sol";
+import {JB721Tier} from "../../src/structs/JB721Tier.sol";
+import {TierStoreHandler} from "./handlers/TierStoreHandler.sol";
+
+/// @notice Invariant tests for `JB721TiersHookStore` tier supply tracking.
+contract TestTieredHookStoreInvariant is Test {
+    JB721TiersHookStore store;
+    TierStoreHandler handler;
+
+    function setUp() public {
+        store = new JB721TiersHookStore();
+        handler = new TierStoreHandler(store);
+        targetContract(address(handler));
+
+        // Exclude internal wrapper functions from fuzzing — they bypass handler safety checks.
+        bytes4[] memory selectors = new bytes4[](4);
+        selectors[0] = TierStoreHandler._doAddTiers.selector;
+        selectors[1] = TierStoreHandler._doRemoveTiers.selector;
+        selectors[2] = TierStoreHandler._doMint.selector;
+        selectors[3] = TierStoreHandler._doBurn.selector;
+
+        targetSelector(FuzzSelector({addr: address(handler), selectors: _handlerSelectors()}));
+    }
+
+    function _handlerSelectors() internal pure returns (bytes4[] memory selectors) {
+        selectors = new bytes4[](4);
+        selectors[0] = TierStoreHandler.addTier.selector;
+        selectors[1] = TierStoreHandler.removeTier.selector;
+        selectors[2] = TierStoreHandler.mint.selector;
+        selectors[3] = TierStoreHandler.burn.selector;
+    }
+
+    /// @notice INV-721-1: For any tier, remaining + burned <= initial supply.
+    function invariant_supplyConservation() public {
+        address hook = handler.HOOK();
+        uint256 maxTier = store.maxTierIdOf(hook);
+
+        for (uint256 i = 1; i <= maxTier; i++) {
+            JB721Tier memory tier = store.tierOf(hook, i, false);
+            if (tier.initialSupply == 0) continue; // Tier doesn't exist.
+
+            uint256 burned = store.numberOfBurnedFor(hook, i);
+            // remaining + burned <= initial (remaining = initial - minted, but minted >= burned)
+            assertTrue(
+                tier.remainingSupply + burned <= tier.initialSupply, "remaining + burned must not exceed initial supply"
+            );
+        }
+    }
+
+    /// @notice INV-721-2: Reserve mints never exceed the proportional reserve allocation.
+    function invariant_reserveMintBounds() public {
+        address hook = handler.HOOK();
+        uint256 maxTier = store.maxTierIdOf(hook);
+
+        for (uint256 i = 1; i <= maxTier; i++) {
+            JB721Tier memory tier = store.tierOf(hook, i, false);
+            if (tier.initialSupply == 0) continue;
+
+            uint256 reservesMinted = store.numberOfReservesMintedFor(hook, i);
+            if (tier.reserveFrequency == 0) {
+                assertEq(reservesMinted, 0, "no reserves without reserveFrequency");
+            }
+        }
+    }
+
+    /// @notice INV-721-3: maxTierIdOf is monotonically increasing (never decreases).
+    function invariant_maxTierIdMonotonic() public {
+        address hook = handler.HOOK();
+        uint256 currentMax = store.maxTierIdOf(hook);
+        assertTrue(currentMax >= handler.lowestMaxTierIdSeen(), "maxTierIdOf should never decrease");
+    }
+}

package/test/invariants/handlers/TierLifecycleHandler.sol

@@ -0,0 +1,262 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import "forge-std/Test.sol";
+import "../../../src/JB721TiersHook.sol";
+import "../../../src/JB721TiersHookStore.sol";
+import "../../../src/structs/JB721TierConfig.sol";
+import "../../../src/structs/JB721Tier.sol";
+import "../../../src/interfaces/IJB721TiersHookStore.sol";
+import "@bananapus/core-v6/src/libraries/JBConstants.sol";
+import "@bananapus/core-v6/src/structs/JBAfterPayRecordedContext.sol";
+import "@bananapus/core-v6/src/structs/JBTokenAmount.sol";
+
+/// @title TierLifecycleHandler
+/// @notice Handler for 721 tier lifecycle invariant testing.
+///         8 operations: payAndMintNFT, cashOutNFT, addTier, removeTier,
+///         mintReserves, setDiscount, ownerMint, advanceTime.
+contract TierLifecycleHandler is Test {
+    JB721TiersHook public hook;
+    JB721TiersHookStore public store;
+    address public hookAddress;
+    address public owner;
+    address public mockController;
+
+    uint256 public constant PROJECT_ID = 69;
+    uint256 public constant NUM_ACTORS = 5;
+    address[] public actors;
+
+    // Ghost variables for supply tracking
+    mapping(uint256 => uint256) public ghost_mintedPerTier; // tierId => minted count
+    mapping(uint256 => uint256) public ghost_burnedPerTier; // tierId => burned count
+    mapping(uint256 => uint256) public ghost_reservesMintedPerTier; // tierId => reserves minted
+    uint256 public ghost_totalPayCredits;
+    mapping(address => uint256) public ghost_actorCredits; // actor => credit balance
+    uint256 public ghost_tiersAdded;
+    uint256 public ghost_tiersRemoved;
+
+    // Track token IDs per actor for cash outs
+    mapping(address => uint256[]) internal _actorTokenIds;
+
+    // Track removed tier IDs
+    mapping(uint256 => bool) public ghost_tierRemoved;
+
+    // Operation counters
+    uint256 public callCount_payAndMint;
+    uint256 public callCount_cashOut;
+    uint256 public callCount_addTier;
+    uint256 public callCount_removeTier;
+    uint256 public callCount_mintReserves;
+    uint256 public callCount_setDiscount;
+    uint256 public callCount_ownerMint;
+    uint256 public callCount_advanceTime;
+
+    constructor(JB721TiersHook _hook, JB721TiersHookStore _store, address _owner, address _mockController) {
+        hook = _hook;
+        store = _store;
+        hookAddress = address(_hook);
+        owner = _owner;
+        mockController = _mockController;
+
+        for (uint256 i = 0; i < NUM_ACTORS; i++) {
+            address actor = address(uint160(0x6000 + i));
+            actors.push(actor);
+        }
+    }
+
+    function _getActor(uint256 seed) internal view returns (address) {
+        return actors[seed % actors.length];
+    }
+
+    /// @notice Simulate a payment that mints NFTs by directly calling store.recordMint.
+    function payAndMintNFT(uint256 seed) external {
+        address actor = _getActor(seed);
+
+        // Get max tier ID to pick a valid tier
+        uint256 maxTierId = store.maxTierIdOf(hookAddress);
+        if (maxTierId == 0) return;
+
+        // Pick a tier (1-indexed)
+        uint256 tierId = (seed % maxTierId) + 1;
+
+        // Check if tier is removed
+        if (ghost_tierRemoved[tierId]) return;
+
+        // Get tier info
+        uint256[] memory categories = new uint256[](0);
+        JB721Tier[] memory tierInfo = store.tiersOf(hookAddress, categories, false, 0, 100);
+
+        // Find the target tier
+        uint104 tierPrice = 0;
+        for (uint256 i = 0; i < tierInfo.length; i++) {
+            if (tierInfo[i].id == tierId) {
+                tierPrice = tierInfo[i].price;
+                break;
+            }
+        }
+        if (tierPrice == 0) return;
+
+        // Call recordMint as the hook
+        uint16[] memory tierIds = new uint16[](1);
+        tierIds[0] = uint16(tierId);
+
+        vm.prank(hookAddress);
+        try store.recordMint(tierPrice, tierIds, false) returns (uint256[] memory tokenIds, uint256) {
+            // Track minted tokens
+            for (uint256 i = 0; i < tokenIds.length; i++) {
+                _actorTokenIds[actor].push(tokenIds[i]);
+            }
+            ghost_mintedPerTier[tierId]++;
+            callCount_payAndMint++;
+        } catch {}
+    }
+
+    /// @notice Simulate a cash out by burning an NFT.
+    function cashOutNFT(uint256 seed) external {
+        address actor = _getActor(seed);
+
+        // Check if actor has any tokens
+        if (_actorTokenIds[actor].length == 0) return;
+
+        // Pick a token to burn
+        uint256 tokenIndex = seed % _actorTokenIds[actor].length;
+        uint256 tokenId = _actorTokenIds[actor][tokenIndex];
+
+        uint256 tierId = store.tierIdOfToken(tokenId);
+
+        // Call recordBurn as the hook
+        uint256[] memory tokenIds = new uint256[](1);
+        tokenIds[0] = tokenId;
+
+        vm.prank(hookAddress);
+        try store.recordBurn(tokenIds) {
+            ghost_burnedPerTier[tierId]++;
+
+            // Remove token from actor's list (swap and pop)
+            uint256 lastIndex = _actorTokenIds[actor].length - 1;
+            if (tokenIndex != lastIndex) {
+                _actorTokenIds[actor][tokenIndex] = _actorTokenIds[actor][lastIndex];
+            }
+            _actorTokenIds[actor].pop();
+
+            callCount_cashOut++;
+        } catch {}
+    }
+
+    /// @notice Add a new tier.
+    function addTier(uint256 seed) external {
+        uint256 price = bound(seed, 1, 1000);
+        uint256 supply = bound(seed >> 8, 10, 500);
+
+        JB721TierConfig[] memory newTiers = new JB721TierConfig[](1);
+        newTiers[0] = JB721TierConfig({
+            price: uint104(price),
+            initialSupply: uint32(supply),
+            votingUnits: 0,
+            reserveFrequency: 0,
+            reserveBeneficiary: address(0),
+            encodedIPFSUri: bytes32(0),
+            category: uint24(100),
+            discountPercent: 0,
+            allowOwnerMint: true,
+            useReserveBeneficiaryAsDefault: false,
+            transfersPausable: false,
+            useVotingUnits: false,
+            cannotBeRemoved: false,
+            cannotIncreaseDiscountPercent: false
+        });
+
+        vm.prank(hookAddress);
+        try store.recordAddTiers(newTiers) returns (uint256[] memory tierIds) {
+            ghost_tiersAdded += tierIds.length;
+            callCount_addTier++;
+        } catch {}
+    }
+
+    /// @notice Remove a tier.
+    function removeTier(uint256 seed) external {
+        uint256 maxTierId = store.maxTierIdOf(hookAddress);
+        if (maxTierId == 0) return;
+
+        uint256 tierId = (seed % maxTierId) + 1;
+        if (ghost_tierRemoved[tierId]) return;
+
+        uint256[] memory tierIds = new uint256[](1);
+        tierIds[0] = tierId;
+
+        vm.prank(hookAddress);
+        try store.recordRemoveTierIds(tierIds) {
+            ghost_tierRemoved[tierId] = true;
+            ghost_tiersRemoved++;
+            callCount_removeTier++;
+        } catch {}
+    }
+
+    /// @notice Mint reserves for a tier.
+    function mintReserves(uint256 seed) external {
+        uint256 maxTierId = store.maxTierIdOf(hookAddress);
+        if (maxTierId == 0) return;
+
+        uint256 tierId = (seed % maxTierId) + 1;
+        if (ghost_tierRemoved[tierId]) return;
+
+        // Try to mint 1 reserve
+        vm.prank(hookAddress);
+        try store.recordMintReservesFor(tierId, 1) returns (uint256[] memory tokenIds) {
+            ghost_reservesMintedPerTier[tierId] += tokenIds.length;
+            callCount_mintReserves++;
+        } catch {}
+    }
+
+    /// @notice Set discount for a tier.
+    function setDiscount(uint256 seed) external {
+        uint256 maxTierId = store.maxTierIdOf(hookAddress);
+        if (maxTierId == 0) return;
+
+        uint256 tierId = (seed % maxTierId) + 1;
+        uint256 discount = bound(seed >> 8, 0, 100); // 0-100%
+
+        vm.prank(hookAddress);
+        try store.recordSetDiscountPercentOf(tierId, discount) {
+            callCount_setDiscount++;
+        } catch {}
+    }
+
+    /// @notice Owner mint (direct mint with isOwnerMint=true).
+    function ownerMint(uint256 seed) external {
+        uint256 maxTierId = store.maxTierIdOf(hookAddress);
+        if (maxTierId == 0) return;
+
+        uint256 tierId = (seed % maxTierId) + 1;
+        if (ghost_tierRemoved[tierId]) return;
+
+        uint16[] memory tierIds = new uint16[](1);
+        tierIds[0] = uint16(tierId);
+
+        vm.prank(hookAddress);
+        try store.recordMint(0, tierIds, true) returns (uint256[] memory tokenIds, uint256) {
+            address actor = _getActor(seed);
+            for (uint256 i = 0; i < tokenIds.length; i++) {
+                _actorTokenIds[actor].push(tokenIds[i]);
+            }
+            ghost_mintedPerTier[tierId]++;
+            callCount_ownerMint++;
+        } catch {}
+    }
+
+    /// @notice Advance time.
+    function advanceTime(uint256 seed) external {
+        uint256 delta = bound(seed, 1 hours, 30 days);
+        vm.warp(block.timestamp + delta);
+        callCount_advanceTime++;
+    }
+
+    // View helpers
+    function getActor(uint256 index) external view returns (address) {
+        return actors[index];
+    }
+
+    function getActorTokenCount(address actor) external view returns (uint256) {
+        return _actorTokenIds[actor].length;
+    }
+}

package/test/invariants/handlers/TierStoreHandler.sol

@@ -0,0 +1,155 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import {CommonBase} from "forge-std/Base.sol";
+import {StdCheats} from "forge-std/StdCheats.sol";
+import {StdUtils} from "forge-std/StdUtils.sol";
+
+import {JB721TiersHookStore} from "../../../src/JB721TiersHookStore.sol";
+import {JB721TierConfig} from "../../../src/structs/JB721TierConfig.sol";
+import {JB721TiersHookFlags} from "../../../src/structs/JB721TiersHookFlags.sol";
+
+/// @notice Handler for JB721TiersHookStore invariant tests.
+/// @dev Acts as the "hook" address itself, so msg.sender (this) == hook in the store.
+contract TierStoreHandler is CommonBase, StdCheats, StdUtils {
+    JB721TiersHookStore public immutable STORE;
+
+    // This contract acts as the hook.
+    address public HOOK;
+
+    // Ghost variable tracking the max tier ID seen.
+    uint256 public lowestMaxTierIdSeen;
+
+    // Track how many tiers we've added.
+    uint256 public tiersAdded;
+
+    // Track minted token IDs so we can only burn minted tokens.
+    uint256[] public mintedTokenIds;
+
+    // Track burned token IDs to avoid double-burn.
+    mapping(uint256 => bool) public wasBurned;
+
+    constructor(JB721TiersHookStore store) {
+        STORE = store;
+        HOOK = address(this);
+    }
+
+    /// @notice Add a new tier.
+    function addTier(uint104 price, uint32 initialSupply, uint16 reserveFrequency, uint24 category) public {
+        // Bound inputs to valid ranges.
+        initialSupply = uint32(bound(initialSupply, 1, 1_000_000));
+        price = uint104(bound(price, 1, type(uint104).max));
+        category = uint24(bound(category, 0, 100));
+
+        // Reserve frequency must be <= initialSupply if non-zero.
+        if (reserveFrequency > 0) {
+            reserveFrequency = uint16(bound(reserveFrequency, 1, 200));
+        }
+
+        JB721TierConfig[] memory configs = new JB721TierConfig[](1);
+        configs[0] = JB721TierConfig({
+            price: price,
+            initialSupply: initialSupply,
+            votingUnits: 0,
+            reserveFrequency: reserveFrequency,
+            reserveBeneficiary: address(0),
+            encodedIPFSUri: bytes32(0),
+            category: category,
+            discountPercent: 0,
+            allowOwnerMint: true,
+            useReserveBeneficiaryAsDefault: false,
+            transfersPausable: false,
+            useVotingUnits: false,
+            cannotBeRemoved: false,
+            cannotIncreaseDiscountPercent: false
+        });
+
+        try this._doAddTiers(configs) {
+            tiersAdded++;
+            _updateMaxTierIdSeen();
+        } catch {}
+    }
+
+    /// @dev External wrapper so calldata encoding is correct for the store.
+    function _doAddTiers(JB721TierConfig[] calldata configs) external {
+        STORE.recordAddTiers(configs);
+    }
+
+    /// @notice Remove a tier.
+    function removeTier(uint256 tierId) public {
+        uint256 maxId = STORE.maxTierIdOf(HOOK);
+        if (maxId == 0) return;
+
+        tierId = bound(tierId, 1, maxId);
+
+        uint256[] memory ids = new uint256[](1);
+        ids[0] = tierId;
+
+        try this._doRemoveTiers(ids) {} catch {}
+    }
+
+    /// @dev External wrapper for calldata.
+    function _doRemoveTiers(uint256[] calldata ids) external {
+        STORE.recordRemoveTierIds(ids);
+    }
+
+    /// @notice Mint from a tier (simulates store recording a mint).
+    function mint(uint256 tierId) public {
+        uint256 maxId = STORE.maxTierIdOf(HOOK);
+        if (maxId == 0) return;
+
+        tierId = bound(tierId, 1, maxId);
+
+        uint16[] memory tierIds = new uint16[](1);
+        tierIds[0] = uint16(tierId);
+
+        try this._doMint(type(uint256).max, tierIds) returns (uint256[] memory tokenIds) {
+            for (uint256 i; i < tokenIds.length; i++) {
+                if (tokenIds[i] != 0) {
+                    mintedTokenIds.push(tokenIds[i]);
+                }
+            }
+        } catch {}
+
+        _updateMaxTierIdSeen();
+    }
+
+    /// @dev External wrapper for calldata.
+    function _doMint(uint256 amount, uint16[] calldata tierIds) external returns (uint256[] memory tokenIds) {
+        (tokenIds,) = STORE.recordMint(amount, tierIds, true);
+    }
+
+    /// @notice Burn a minted token.
+    function burn(uint256 indexSeed) public {
+        if (mintedTokenIds.length == 0) return;
+
+        uint256 index = bound(indexSeed, 0, mintedTokenIds.length - 1);
+        uint256 tokenId = mintedTokenIds[index];
+
+        // Skip if already burned.
+        if (wasBurned[tokenId]) return;
+
+        uint256[] memory tokenIds = new uint256[](1);
+        tokenIds[0] = tokenId;
+
+        try this._doBurn(tokenIds) {
+            wasBurned[tokenId] = true;
+        } catch {}
+    }
+
+    /// @dev External wrapper for calldata.
+    function _doBurn(uint256[] calldata tokenIds) external {
+        STORE.recordBurn(tokenIds);
+    }
+
+    function mintedTokenCount() external view returns (uint256) {
+        return mintedTokenIds.length;
+    }
+
+    function _updateMaxTierIdSeen() internal {
+        uint256 current = STORE.maxTierIdOf(HOOK);
+        if (lowestMaxTierIdSeen == 0 || current > lowestMaxTierIdSeen) {
+            lowestMaxTierIdSeen = current;
+        }
+    }
+}