@bananapus/core-v6 0.0.1

package/test/invariants/TerminalStoreInvariant.t.sol

@@ -0,0 +1,220 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.6;
+
+import "forge-std/StdInvariant.sol";
+import /* {*} from */ "../helpers/TestBaseWorkflow.sol";
+import {TerminalStoreHandler} from "./handlers/TerminalStoreHandler.sol";
+import {JBAccountingContext} from "../../src/structs/JBAccountingContext.sol";
+
+/// @notice Invariant tests for JBTerminalStore fund conservation.
+/// @dev Verifies that funds cannot be created or destroyed through normal terminal operations.
+contract TerminalStoreInvariant_Local is StdInvariant, TestBaseWorkflow {
+    using JBRulesetMetadataResolver for JBRuleset;
+
+    TerminalStoreHandler public handler;
+
+    uint256 public projectId;
+    address public projectOwner;
+
+    function setUp() public override {
+        super.setUp();
+        projectOwner = multisig();
+
+        // Launch fee collector project (#1)
+        JBRulesetConfig[] memory feeRulesetConfig = new JBRulesetConfig[](1);
+        feeRulesetConfig[0].mustStartAtOrAfter = 0;
+        feeRulesetConfig[0].duration = 0;
+        feeRulesetConfig[0].weight = 1000e18;
+        feeRulesetConfig[0].weightCutPercent = 0;
+        feeRulesetConfig[0].approvalHook = IJBRulesetApprovalHook(address(0));
+        feeRulesetConfig[0].metadata = JBRulesetMetadata({
+            reservedPercent: 0,
+            cashOutTaxRate: 0,
+            baseCurrency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+            pausePay: false,
+            pauseCreditTransfers: false,
+            allowOwnerMinting: false,
+            allowSetCustomToken: false,
+            allowTerminalMigration: false,
+            allowSetTerminals: false,
+            ownerMustSendPayouts: false,
+            allowSetController: false,
+            allowAddAccountingContext: true,
+            allowAddPriceFeed: false,
+            holdFees: false,
+            useTotalSurplusForCashOuts: false,
+            useDataHookForPay: false,
+            useDataHookForCashOut: false,
+            dataHook: address(0),
+            metadata: 0
+        });
+        feeRulesetConfig[0].splitGroups = new JBSplitGroup[](0);
+        feeRulesetConfig[0].fundAccessLimitGroups = new JBFundAccessLimitGroup[](0);
+
+        JBTerminalConfig[] memory terminalConfigurations = new JBTerminalConfig[](1);
+        JBAccountingContext[] memory tokensToAccept = new JBAccountingContext[](1);
+        tokensToAccept[0] = JBAccountingContext({
+            token: JBConstants.NATIVE_TOKEN, decimals: 18, currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
+        });
+        terminalConfigurations[0] =
+            JBTerminalConfig({terminal: jbMultiTerminal(), accountingContextsToAccept: tokensToAccept});
+
+        jbController()
+            .launchProjectFor({
+                owner: address(420),
+                projectUri: "feeCollector",
+                rulesetConfigurations: feeRulesetConfig,
+                terminalConfigurations: terminalConfigurations,
+                memo: ""
+            });
+
+        // Launch the test project (#2) with 50% cash out tax, no payout limit, no reserved rate
+        JBRulesetConfig[] memory rulesetConfig = new JBRulesetConfig[](1);
+        rulesetConfig[0].mustStartAtOrAfter = 0;
+        rulesetConfig[0].duration = 0;
+        rulesetConfig[0].weight = 1000e18;
+        rulesetConfig[0].weightCutPercent = 0;
+        rulesetConfig[0].approvalHook = IJBRulesetApprovalHook(address(0));
+        rulesetConfig[0].metadata = JBRulesetMetadata({
+            reservedPercent: 0,
+            cashOutTaxRate: 5000, // 50% tax
+            baseCurrency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+            pausePay: false,
+            pauseCreditTransfers: false,
+            allowOwnerMinting: true,
+            allowSetCustomToken: true,
+            allowTerminalMigration: false,
+            allowSetTerminals: false,
+            ownerMustSendPayouts: false,
+            allowSetController: false,
+            allowAddAccountingContext: true,
+            allowAddPriceFeed: false,
+            holdFees: false,
+            useTotalSurplusForCashOuts: false,
+            useDataHookForPay: false,
+            useDataHookForCashOut: false,
+            dataHook: address(0),
+            metadata: 0
+        });
+        rulesetConfig[0].splitGroups = new JBSplitGroup[](0);
+        rulesetConfig[0].fundAccessLimitGroups = new JBFundAccessLimitGroup[](0);
+
+        projectId = jbController()
+            .launchProjectFor({
+                owner: projectOwner,
+                projectUri: "testProject",
+                rulesetConfigurations: rulesetConfig,
+                terminalConfigurations: terminalConfigurations,
+                memo: ""
+            });
+
+        // Deploy ERC20 so tokens can be tracked
+        vm.prank(projectOwner);
+        jbController().deployERC20For(projectId, "TestToken", "TT", bytes32(0));
+
+        // Deploy handler
+        handler = new TerminalStoreHandler(
+            jbMultiTerminal(), jbTerminalStore(), jbController(), jbTokens(), projectId, projectOwner
+        );
+
+        // Register handler as target
+        bytes4[] memory selectors = new bytes4[](4);
+        selectors[0] = TerminalStoreHandler.payProject.selector;
+        selectors[1] = TerminalStoreHandler.cashOutTokens.selector;
+        selectors[2] = TerminalStoreHandler.sendPayouts.selector;
+        selectors[3] = TerminalStoreHandler.addToBalance.selector;
+
+        targetContract(address(handler));
+        targetSelector(FuzzSelector({addr: address(handler), selectors: selectors}));
+    }
+
+    /// @notice INV-TS-1: Terminal ETH balance >= sum of recorded balances for this project.
+    /// @dev The terminal's actual ETH balance should always be >= what the store records,
+    ///      because fees from other projects also accumulate in the terminal.
+    function invariant_TS1_terminalBalanceCoversRecordedBalance() public view {
+        uint256 recordedBalance =
+            jbTerminalStore().balanceOf(address(jbMultiTerminal()), projectId, JBConstants.NATIVE_TOKEN);
+        uint256 actualBalance = address(jbMultiTerminal()).balance;
+
+        assertGe(actualBalance, recordedBalance, "INV-TS-1: Terminal ETH balance must be >= recorded project balance");
+    }
+
+    /// @notice INV-TS-2: Reclaimable surplus <= current surplus, always.
+    function invariant_TS2_reclaimableSurplusLeqSurplus() public view {
+        uint256 totalSupply = jbTokens().totalSupplyOf(projectId);
+        if (totalSupply == 0) return; // Skip when no tokens exist
+
+        JBAccountingContext[] memory contexts = new JBAccountingContext[](1);
+        contexts[0] = JBAccountingContext({
+            token: JBConstants.NATIVE_TOKEN, decimals: 18, currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
+        });
+
+        uint256 surplus = jbTerminalStore()
+            .currentSurplusOf({
+                terminal: address(jbMultiTerminal()),
+                projectId: projectId,
+                accountingContexts: contexts,
+                decimals: 18,
+                currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
+            });
+
+        // Check reclaimable for half the supply
+        uint256 halfSupply = totalSupply / 2;
+        if (halfSupply == 0) return;
+
+        uint256 reclaimable = jbTerminalStore()
+            .currentReclaimableSurplusOf({
+                projectId: projectId, cashOutCount: halfSupply, totalSupply: totalSupply, surplus: surplus
+            });
+
+        assertLe(reclaimable, surplus, "INV-TS-2: Reclaimable surplus must not exceed current surplus");
+    }
+
+    /// @notice INV-TS-3: Fee project (project #1) balance in the terminal increases monotonically.
+    /// @dev We can only check that it's >= 0; true monotonicity requires tracking across calls,
+    ///      which the handler ghost variables assist with.
+    function invariant_TS3_feeProjectBalanceNonNegative() public view {
+        uint256 feeProjectBalance = jbTerminalStore().balanceOf(address(jbMultiTerminal()), 1, JBConstants.NATIVE_TOKEN);
+
+        // Fee project balance should be non-negative (always true for uint, but conceptually
+        // this checks that the fee project accumulates fees from cashouts).
+        assertGe(feeProjectBalance, 0, "INV-TS-3: Fee project balance should be non-negative");
+    }
+
+    /// @notice INV-TS-4: Total actual ETH in terminal = recorded balance of all projects.
+    /// @dev The terminal's ETH balance should equal the sum of all project balances recorded in the store.
+    function invariant_TS4_terminalBalanceConservation() public view {
+        uint256 projectBalance =
+            jbTerminalStore().balanceOf(address(jbMultiTerminal()), projectId, JBConstants.NATIVE_TOKEN);
+        uint256 feeProjectBalance = jbTerminalStore().balanceOf(address(jbMultiTerminal()), 1, JBConstants.NATIVE_TOKEN);
+        uint256 actualBalance = address(jbMultiTerminal()).balance;
+
+        // The terminal's actual balance should equal the sum of all recorded project balances.
+        // There should be no "unaccounted" ETH sitting in the terminal.
+        assertEq(
+            actualBalance,
+            projectBalance + feeProjectBalance,
+            "INV-TS-4: Terminal ETH balance must equal sum of all recorded project balances"
+        );
+    }
+
+    /// @notice INV-TS-5: Ghost variable conservation check.
+    /// @dev totalPaidIn + totalAddedToBalance >= totalCashedOut + totalPaidOut + remaining balance.
+    ///      Fees complicate exact equality, so we use >= for the funds-in side.
+    function invariant_TS5_ghostVariableConservation() public view {
+        uint256 totalIn = handler.ghost_totalPaidIn() + handler.ghost_totalAddedToBalance();
+        uint256 totalOut = handler.ghost_totalCashedOut() + handler.ghost_totalPaidOut();
+
+        uint256 projectBalance =
+            jbTerminalStore().balanceOf(address(jbMultiTerminal()), projectId, JBConstants.NATIVE_TOKEN);
+
+        // Everything that went in must be >= everything that went out + what remains.
+        // Strict equality breaks because fees redistribute between projects.
+        assertGe(
+            totalIn,
+            totalOut + projectBalance
+                - jbTerminalStore().balanceOf(address(jbMultiTerminal()), 1, JBConstants.NATIVE_TOKEN),
+            "INV-TS-5: Ghost conservation - funds in >= funds out + project balance (adjusted for fees)"
+        );
+    }
+}

package/test/invariants/TokensInvariant.t.sol

@@ -0,0 +1,184 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.6;
+
+import "forge-std/StdInvariant.sol";
+import /* {*} from */ "../helpers/TestBaseWorkflow.sol";
+import {TokensHandler} from "./handlers/TokensHandler.sol";
+
+/// @notice Invariant tests for JBTokens supply and balance consistency.
+/// @dev Verifies that the dual-balance system (credits + ERC20) maintains exact accounting.
+contract TokensInvariant_Local is StdInvariant, TestBaseWorkflow {
+    using JBRulesetMetadataResolver for JBRuleset;
+
+    TokensHandler public handler;
+
+    uint256 public projectId;
+    address public projectOwner;
+
+    function setUp() public override {
+        super.setUp();
+        projectOwner = multisig();
+
+        // Launch fee collector project (#1)
+        JBRulesetConfig[] memory feeRulesetConfig = new JBRulesetConfig[](1);
+        feeRulesetConfig[0].mustStartAtOrAfter = 0;
+        feeRulesetConfig[0].duration = 0;
+        feeRulesetConfig[0].weight = 1000e18;
+        feeRulesetConfig[0].weightCutPercent = 0;
+        feeRulesetConfig[0].approvalHook = IJBRulesetApprovalHook(address(0));
+        feeRulesetConfig[0].metadata = JBRulesetMetadata({
+            reservedPercent: 0,
+            cashOutTaxRate: 0,
+            baseCurrency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+            pausePay: false,
+            pauseCreditTransfers: false,
+            allowOwnerMinting: false,
+            allowSetCustomToken: false,
+            allowTerminalMigration: false,
+            allowSetTerminals: false,
+            ownerMustSendPayouts: false,
+            allowSetController: false,
+            allowAddAccountingContext: true,
+            allowAddPriceFeed: false,
+            holdFees: false,
+            useTotalSurplusForCashOuts: false,
+            useDataHookForPay: false,
+            useDataHookForCashOut: false,
+            dataHook: address(0),
+            metadata: 0
+        });
+        feeRulesetConfig[0].splitGroups = new JBSplitGroup[](0);
+        feeRulesetConfig[0].fundAccessLimitGroups = new JBFundAccessLimitGroup[](0);
+
+        JBTerminalConfig[] memory terminalConfigurations = new JBTerminalConfig[](1);
+        JBAccountingContext[] memory tokensToAccept = new JBAccountingContext[](1);
+        tokensToAccept[0] = JBAccountingContext({
+            token: JBConstants.NATIVE_TOKEN, decimals: 18, currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
+        });
+        terminalConfigurations[0] =
+            JBTerminalConfig({terminal: jbMultiTerminal(), accountingContextsToAccept: tokensToAccept});
+
+        jbController()
+            .launchProjectFor({
+                owner: address(420),
+                projectUri: "feeCollector",
+                rulesetConfigurations: feeRulesetConfig,
+                terminalConfigurations: terminalConfigurations,
+                memo: ""
+            });
+
+        // Launch the test project with credits (no ERC20 initially, then deploy)
+        JBRulesetConfig[] memory rulesetConfig = new JBRulesetConfig[](1);
+        rulesetConfig[0].mustStartAtOrAfter = 0;
+        rulesetConfig[0].duration = 0;
+        rulesetConfig[0].weight = 1000e18;
+        rulesetConfig[0].weightCutPercent = 0;
+        rulesetConfig[0].approvalHook = IJBRulesetApprovalHook(address(0));
+        rulesetConfig[0].metadata = JBRulesetMetadata({
+            reservedPercent: 0,
+            cashOutTaxRate: 5000,
+            baseCurrency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+            pausePay: false,
+            pauseCreditTransfers: false,
+            allowOwnerMinting: true,
+            allowSetCustomToken: true,
+            allowTerminalMigration: false,
+            allowSetTerminals: false,
+            ownerMustSendPayouts: false,
+            allowSetController: false,
+            allowAddAccountingContext: true,
+            allowAddPriceFeed: false,
+            holdFees: false,
+            useTotalSurplusForCashOuts: false,
+            useDataHookForPay: false,
+            useDataHookForCashOut: false,
+            dataHook: address(0),
+            metadata: 0
+        });
+        rulesetConfig[0].splitGroups = new JBSplitGroup[](0);
+        rulesetConfig[0].fundAccessLimitGroups = new JBFundAccessLimitGroup[](0);
+
+        projectId = jbController()
+            .launchProjectFor({
+                owner: projectOwner,
+                projectUri: "testProject",
+                rulesetConfigurations: rulesetConfig,
+                terminalConfigurations: terminalConfigurations,
+                memo: ""
+            });
+
+        // Deploy ERC20 so claiming works
+        vm.prank(projectOwner);
+        jbController().deployERC20For(projectId, "TestToken", "TT", bytes32(0));
+
+        // Deploy handler
+        handler = new TokensHandler(jbMultiTerminal(), jbController(), jbTokens(), projectId, projectOwner);
+
+        // Register handler
+        bytes4[] memory selectors = new bytes4[](4);
+        selectors[0] = TokensHandler.mintTokens.selector;
+        selectors[1] = TokensHandler.burnTokens.selector;
+        selectors[2] = TokensHandler.claimCredits.selector;
+        selectors[3] = TokensHandler.transferCredits.selector;
+
+        targetContract(address(handler));
+        targetSelector(FuzzSelector({addr: address(handler), selectors: selectors}));
+    }
+
+    /// @notice INV-TK-1: totalSupplyOf == totalCreditSupplyOf + token.totalSupply()
+    function invariant_TK1_totalSupplyDecomposition() public view {
+        uint256 totalSupply = jbTokens().totalSupplyOf(projectId);
+        uint256 creditSupply = jbTokens().totalCreditSupplyOf(projectId);
+        IJBToken token = jbTokens().tokenOf(projectId);
+        uint256 erc20Supply = address(token) != address(0) ? token.totalSupply() : 0;
+
+        assertEq(totalSupply, creditSupply + erc20Supply, "INV-TK-1: totalSupply must equal creditSupply + erc20Supply");
+    }
+
+    /// @notice INV-TK-2: For each holder, totalBalanceOf == creditBalanceOf + token.balanceOf
+    function invariant_TK2_perHolderBalanceConsistency() public view {
+        uint256 holderCount = handler.holderCount();
+        IJBToken token = jbTokens().tokenOf(projectId);
+
+        for (uint256 i = 0; i < holderCount; i++) {
+            address holder = handler.holderAt(i);
+            uint256 totalBalance = jbTokens().totalBalanceOf(holder, projectId);
+            uint256 creditBalance = jbTokens().creditBalanceOf(holder, projectId);
+            uint256 erc20Balance = address(token) != address(0) ? token.balanceOf(holder) : 0;
+
+            assertEq(
+                totalBalance,
+                creditBalance + erc20Balance,
+                "INV-TK-2: Per-holder totalBalance must equal credits + ERC20"
+            );
+        }
+    }
+
+    /// @notice INV-TK-3: Sum of all holder totalBalanceOf == totalSupplyOf
+    function invariant_TK3_sumOfBalancesEqualsTotalSupply() public view {
+        uint256 holderCount = handler.holderCount();
+        uint256 sumOfBalances;
+
+        for (uint256 i = 0; i < holderCount; i++) {
+            address holder = handler.holderAt(i);
+            sumOfBalances += jbTokens().totalBalanceOf(holder, projectId);
+        }
+
+        uint256 totalSupply = jbTokens().totalSupplyOf(projectId);
+
+        // Sum of tracked holder balances should be <= totalSupply.
+        // It may be < totalSupply if there are holders we haven't tracked (e.g., fee project).
+        assertLe(sumOfBalances, totalSupply, "INV-TK-3: Sum of tracked holder balances must not exceed totalSupply");
+    }
+
+    /// @notice INV-TK-4: Claiming does not change totalSupplyOf.
+    /// @dev This is implicitly tested via TK-1: if claiming changed totalSupply,
+    ///      the creditSupply + erc20Supply decomposition would break.
+    ///      We add an explicit check that supply is always non-negative (trivially true for uint).
+    function invariant_TK4_supplyNeverNegative() public view {
+        uint256 totalSupply = jbTokens().totalSupplyOf(projectId);
+        uint256 creditSupply = jbTokens().totalCreditSupplyOf(projectId);
+
+        assertGe(totalSupply, creditSupply, "INV-TK-4: totalSupply must be >= creditSupply");
+    }
+}

package/test/invariants/handlers/ComprehensiveHandler.sol

@@ -0,0 +1,285 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.6;
+
+import "forge-std/Test.sol";
+import {JBConstants} from "../../../src/libraries/JBConstants.sol";
+import {IJBMultiTerminal} from "../../../src/interfaces/IJBMultiTerminal.sol";
+import {IJBTerminalStore} from "../../../src/interfaces/IJBTerminalStore.sol";
+import {IJBController} from "../../../src/interfaces/IJBController.sol";
+import {IJBTokens} from "../../../src/interfaces/IJBTokens.sol";
+
+/// @notice Comprehensive handler for JBTerminalStore invariant testing.
+/// @dev Extends the basic handler with 10 operations including reserves, allowance, burns, claims, time, and fees.
+contract ComprehensiveHandler is Test {
+    IJBMultiTerminal public terminal;
+    IJBTerminalStore public store;
+    IJBController public controller;
+    IJBTokens public tokens;
+
+    uint256 public projectId;
+    address public projectOwner;
+
+    // Ghost variables for fund tracking
+    uint256 public ghost_totalPaidIn;
+    uint256 public ghost_totalCashedOut;
+    uint256 public ghost_totalPaidOut;
+    uint256 public ghost_totalAddedToBalance;
+    uint256 public ghost_totalAllowanceUsed;
+    uint256 public ghost_feeProjectBalanceLast;
+    uint256 public ghost_feeProjectBalanceDecreased; // should always be 0
+
+    // Track actors
+    address[] public actors;
+    mapping(address => bool) public isActor;
+    uint256 public constant NUM_ACTORS = 5;
+
+    // Operation counters for debugging
+    uint256 public callCount_pay;
+    uint256 public callCount_cashOut;
+    uint256 public callCount_sendPayouts;
+    uint256 public callCount_addToBalance;
+    uint256 public callCount_sendReservedTokens;
+    uint256 public callCount_useAllowance;
+    uint256 public callCount_burnTokens;
+    uint256 public callCount_claimCredits;
+    uint256 public callCount_advanceTime;
+    uint256 public callCount_processHeldFees;
+
+    constructor(
+        IJBMultiTerminal _terminal,
+        IJBTerminalStore _store,
+        IJBController _controller,
+        IJBTokens _tokens,
+        uint256 _projectId,
+        address _projectOwner
+    ) {
+        terminal = _terminal;
+        store = _store;
+        controller = _controller;
+        tokens = _tokens;
+        projectId = _projectId;
+        projectOwner = _projectOwner;
+
+        // Create actor addresses
+        for (uint256 i = 0; i < NUM_ACTORS; i++) {
+            address actor = address(uint160(0x2000 + i));
+            actors.push(actor);
+            isActor[actor] = true;
+        }
+
+        // Initialize fee project balance tracking
+        ghost_feeProjectBalanceLast = store.balanceOf(address(terminal), 1, JBConstants.NATIVE_TOKEN);
+    }
+
+    /// @notice Selects an actor based on a seed.
+    function _getActor(uint256 seed) internal view returns (address) {
+        return actors[seed % actors.length];
+    }
+
+    /// @notice Track fee project balance monotonicity.
+    function _trackFeeProjectBalance() internal {
+        uint256 currentFeeBalance = store.balanceOf(address(terminal), 1, JBConstants.NATIVE_TOKEN);
+        if (currentFeeBalance < ghost_feeProjectBalanceLast) {
+            ghost_feeProjectBalanceDecreased++;
+        }
+        ghost_feeProjectBalanceLast = currentFeeBalance;
+    }
+
+    // ─── Operation 1: Pay
+    // ─────────────────────────────────────────────
+
+    function payProject(uint256 actorSeed, uint256 amount) public {
+        amount = bound(amount, 0.01 ether, 100 ether);
+        address actor = _getActor(actorSeed);
+
+        vm.deal(actor, amount);
+        vm.prank(actor);
+        terminal.pay{value: amount}({
+            projectId: projectId,
+            token: JBConstants.NATIVE_TOKEN,
+            amount: amount,
+            beneficiary: actor,
+            minReturnedTokens: 0,
+            memo: "",
+            metadata: new bytes(0)
+        });
+
+        ghost_totalPaidIn += amount;
+        callCount_pay++;
+        _trackFeeProjectBalance();
+    }
+
+    // ─── Operation 2: Cash Out
+    // ────────────────────────────────────────
+
+    function cashOutTokens(uint256 actorSeed, uint256 cashOutPercent) public {
+        address actor = _getActor(actorSeed);
+        uint256 tokenBalance = tokens.totalBalanceOf(actor, projectId);
+        if (tokenBalance == 0) return;
+
+        cashOutPercent = bound(cashOutPercent, 1, 100);
+        uint256 cashOutCount = (tokenBalance * cashOutPercent) / 100;
+        if (cashOutCount == 0) return;
+
+        vm.prank(actor);
+        uint256 reclaimAmount = terminal.cashOutTokensOf({
+            holder: actor,
+            projectId: projectId,
+            cashOutCount: cashOutCount,
+            tokenToReclaim: JBConstants.NATIVE_TOKEN,
+            minTokensReclaimed: 0,
+            beneficiary: payable(actor),
+            metadata: new bytes(0)
+        });
+
+        ghost_totalCashedOut += reclaimAmount;
+        callCount_cashOut++;
+        _trackFeeProjectBalance();
+    }
+
+    // ─── Operation 3: Send Payouts
+    // ────────────────────────────────────
+
+    function sendPayouts(uint256 amount) public {
+        uint256 balance = store.balanceOf(address(terminal), projectId, JBConstants.NATIVE_TOKEN);
+        if (balance == 0) return;
+
+        amount = bound(amount, 1, balance);
+
+        vm.prank(projectOwner);
+        try terminal.sendPayoutsOf({
+            projectId: projectId,
+            token: JBConstants.NATIVE_TOKEN,
+            amount: amount,
+            currency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+            minTokensPaidOut: 0
+        }) returns (
+            uint256 amountPaidOut
+        ) {
+            ghost_totalPaidOut += amountPaidOut;
+        } catch {}
+
+        callCount_sendPayouts++;
+        _trackFeeProjectBalance();
+    }
+
+    // ─── Operation 4: Add to Balance
+    // ──────────────────────────────────
+
+    function addToBalance(uint256 amount) public {
+        amount = bound(amount, 0.01 ether, 50 ether);
+
+        vm.deal(address(this), amount);
+        terminal.addToBalanceOf{value: amount}({
+            projectId: projectId,
+            token: JBConstants.NATIVE_TOKEN,
+            amount: amount,
+            shouldReturnHeldFees: false,
+            memo: "",
+            metadata: new bytes(0)
+        });
+
+        ghost_totalAddedToBalance += amount;
+        callCount_addToBalance++;
+        _trackFeeProjectBalance();
+    }
+
+    // ─── Operation 5: Send Reserved Tokens
+    // ────────────────────────────
+
+    function sendReservedTokens() public {
+        try controller.sendReservedTokensToSplitsOf(projectId) {} catch {}
+        callCount_sendReservedTokens++;
+        _trackFeeProjectBalance();
+    }
+
+    // ─── Operation 6: Use Allowance
+    // ───────────────────────────────────
+
+    function useAllowance(uint256 amount) public {
+        uint256 balance = store.balanceOf(address(terminal), projectId, JBConstants.NATIVE_TOKEN);
+        if (balance == 0) return;
+
+        amount = bound(amount, 0.001 ether, 3 ether);
+
+        vm.prank(projectOwner);
+        try terminal.useAllowanceOf({
+            projectId: projectId,
+            token: JBConstants.NATIVE_TOKEN,
+            amount: amount,
+            currency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+            minTokensPaidOut: 0,
+            beneficiary: payable(projectOwner),
+            feeBeneficiary: payable(projectOwner),
+            memo: "allowance"
+        }) returns (
+            uint256 netAmountPaidOut
+        ) {
+            ghost_totalAllowanceUsed += netAmountPaidOut;
+        } catch {}
+
+        callCount_useAllowance++;
+        _trackFeeProjectBalance();
+    }
+
+    // ─── Operation 7: Burn Tokens
+    // ─────────────────────────────────────
+
+    function burnTokens(uint256 actorSeed, uint256 burnPercent) public {
+        address actor = _getActor(actorSeed);
+        uint256 tokenBalance = tokens.totalBalanceOf(actor, projectId);
+        if (tokenBalance == 0) return;
+
+        burnPercent = bound(burnPercent, 1, 100);
+        uint256 burnCount = (tokenBalance * burnPercent) / 100;
+        if (burnCount == 0) return;
+
+        vm.prank(actor);
+        try controller.burnTokensOf({holder: actor, projectId: projectId, tokenCount: burnCount, memo: "burn"}) {}
+            catch {}
+
+        callCount_burnTokens++;
+    }
+
+    // ─── Operation 8: Claim Credits as ERC20
+    // ──────────────────────────
+
+    function claimCredits(uint256 actorSeed, uint256 claimPercent) public {
+        address actor = _getActor(actorSeed);
+        uint256 creditBalance = tokens.creditBalanceOf(actor, projectId);
+        if (creditBalance == 0) return;
+
+        claimPercent = bound(claimPercent, 1, 100);
+        uint256 claimCount = (creditBalance * claimPercent) / 100;
+        if (claimCount == 0) return;
+
+        vm.prank(actor);
+        try controller.claimTokensFor({
+            holder: actor, projectId: projectId, tokenCount: claimCount, beneficiary: actor
+        }) {}
+            catch {}
+
+        callCount_claimCredits++;
+    }
+
+    // ─── Operation 9: Advance Time
+    // ────────────────────────────────────
+
+    function advanceTime(uint256 timeSeed) public {
+        uint256 timeJump = bound(timeSeed, 1 hours, 90 days);
+        vm.warp(block.timestamp + timeJump);
+        callCount_advanceTime++;
+    }
+
+    // ─── Operation 10: Process Held Fees
+    // ──────────────────────────────
+
+    function processHeldFees(uint256 count) public {
+        count = bound(count, 1, 10);
+        try terminal.processHeldFeesOf(projectId, JBConstants.NATIVE_TOKEN, count) {} catch {}
+        callCount_processHeldFees++;
+        _trackFeeProjectBalance();
+    }
+
+    receive() external payable {}
+}