@bananapus/721-hook-v6 0.0.42 → 0.0.45

package/test/invariants/TierLifecycleInvariant.t.sol

@@ -1,188 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity 0.8.28;
-
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "forge-std/StdInvariant.sol";
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "../utils/UnitTestSetup.sol";
-// forge-lint: disable-next-line(unaliased-plain-import)
-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 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 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

@@ -1,86 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity 0.8.28;
-
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "forge-std/Test.sol";
-
-import {JB721TiersHookStore} from "../../src/JB721TiersHookStore.sol";
-// forge-lint: disable-next-line(unused-import)
-import {JB721TierConfig} from "../../src/structs/JB721TierConfig.sol";
-// forge-lint: disable-next-line(unused-import)
-import {JBStored721Tier} from "../../src/structs/JBStored721Tier.sol";
-// forge-lint: disable-next-line(unused-import)
-import {JB721TiersHookFlags} from "../../src/structs/JB721TiersHookFlags.sol";
-// forge-lint: disable-next-line(unused-import)
-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

@@ -1,300 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity 0.8.28;
-
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "forge-std/Test.sol";
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "../../../src/JB721TiersHook.sol";
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "../../../src/JB721TiersHookStore.sol";
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "../../../src/structs/JB721TierConfig.sol";
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "../../../src/structs/JB721Tier.sol";
-import {JB721TierConfigFlags} from "../../../src/structs/JB721TierConfigFlags.sol";
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "../../../src/interfaces/IJB721TiersHookStore.sol";
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "@bananapus/core-v6/src/libraries/JBConstants.sol";
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "@bananapus/core-v6/src/structs/JBAfterPayRecordedContext.sol";
-// forge-lint: disable-next-line(unaliased-plain-import)
-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
-    // forge-lint: disable-next-line(mixed-case-variable)
-    mapping(uint256 => uint256) public ghost_mintedPerTier; // tierId => minted count
-    // forge-lint: disable-next-line(mixed-case-variable)
-    mapping(uint256 => uint256) public ghost_burnedPerTier; // tierId => burned count
-    // forge-lint: disable-next-line(mixed-case-variable)
-    mapping(uint256 => uint256) public ghost_reservesMintedPerTier; // tierId => reserves minted
-    // forge-lint: disable-next-line(mixed-case-variable)
-    uint256 public ghost_totalPayCredits;
-    // forge-lint: disable-next-line(mixed-case-variable)
-    mapping(address => uint256) public ghost_actorCredits; // actor => credit balance
-    // forge-lint: disable-next-line(mixed-case-variable)
-    uint256 public ghost_tiersAdded;
-    // forge-lint: disable-next-line(mixed-case-variable)
-    uint256 public ghost_tiersRemoved;
-
-    // Track token IDs per actor for cash outs
-    mapping(address => uint256[]) internal _actorTokenIds;
-
-    // Track removed tier IDs
-    // forge-lint: disable-next-line(mixed-case-variable)
-    mapping(uint256 => bool) public ghost_tierRemoved;
-
-    // Operation counters
-    // forge-lint: disable-next-line(mixed-case-variable)
-    uint256 public callCount_payAndMint;
-    // forge-lint: disable-next-line(mixed-case-variable)
-    uint256 public callCount_cashOut;
-    // forge-lint: disable-next-line(mixed-case-variable)
-    uint256 public callCount_addTier;
-    // forge-lint: disable-next-line(mixed-case-variable)
-    uint256 public callCount_removeTier;
-    // forge-lint: disable-next-line(mixed-case-variable)
-    uint256 public callCount_mintReserves;
-    // forge-lint: disable-next-line(mixed-case-variable)
-    uint256 public callCount_setDiscount;
-    // forge-lint: disable-next-line(mixed-case-variable)
-    uint256 public callCount_ownerMint;
-    // forge-lint: disable-next-line(mixed-case-variable)
-    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++) {
-            // forge-lint: disable-next-line(unsafe-typecast)
-            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.
-    // forge-lint: disable-next-line(mixed-case-function)
-    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);
-        // forge-lint: disable-next-line(unsafe-typecast)
-        tierIds[0] = uint16(tierId);
-
-        vm.prank(hookAddress);
-        try store.recordMint(tierPrice, tierIds, false) returns (uint256[] memory tokenIds, uint256, 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.
-    // forge-lint: disable-next-line(mixed-case-function)
-    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({
-            // forge-lint: disable-next-line(unsafe-typecast)
-            price: uint104(price),
-            // forge-lint: disable-next-line(unsafe-typecast)
-            initialSupply: uint32(supply),
-            votingUnits: 0,
-            reserveFrequency: 0,
-            reserveBeneficiary: address(0),
-            encodedIPFSUri: bytes32(0),
-            category: uint24(100),
-            discountPercent: 0,
-            flags: JB721TierConfigFlags({
-                allowOwnerMint: true,
-                useReserveBeneficiaryAsDefault: false,
-                transfersPausable: false,
-                useVotingUnits: false,
-                cantBeRemoved: false,
-                cantIncreaseDiscountPercent: false,
-                cantBuyWithCredits: false
-            }),
-            splitPercent: 0,
-            splits: new JBSplit[](0)
-        });
-
-        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);
-        // forge-lint: disable-next-line(unsafe-typecast)
-        tierIds[0] = uint16(tierId);
-
-        vm.prank(hookAddress);
-        try store.recordMint(0, tierIds, true) returns (uint256[] memory tokenIds, uint256, 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;
-    }
-}