@bananapus/core-v6 0.0.1

package/test/invariants/handlers/Phase3Handler.sol

@@ -0,0 +1,414 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.6;
+
+import "forge-std/Test.sol";
+import {JBConstants} from "../../../src/libraries/JBConstants.sol";
+import {JBFees} from "../../../src/libraries/JBFees.sol";
+import {JBFee} from "../../../src/structs/JBFee.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";
+import {JBMultiTerminal} from "../../../src/JBMultiTerminal.sol";
+
+/// @title Phase3Handler
+/// @notice Stateful fuzzing handler with ghost variable tracking for strict invariant verification.
+/// @dev 14 operations across 4 projects with 10 actors. Ghost variables track every fee flow,
+///      enabling strict equality checks instead of the looser `>=` used in Phase 2.
+contract Phase3Handler is Test {
+    IJBMultiTerminal public terminal;
+    IJBTerminalStore public store;
+    IJBController public controller;
+    IJBTokens public tokens;
+
+    uint256 public constant PROJECT_FEE = 1;
+    uint256 public projectId2;
+    uint256 public projectId3;
+    uint256 public projectId4;
+    address public projectOwner;
+
+    uint256 public constant FEE_PERCENT = 25; // 2.5% — matches JBMultiTerminal.FEE
+
+    // =========================================================================
+    // Actors
+    // =========================================================================
+    address[] public actors;
+    uint256 public constant NUM_ACTORS = 10;
+
+    // =========================================================================
+    // Ghost Variables — strict accounting
+    // =========================================================================
+
+    // Per-project total inflows/outflows
+    mapping(uint256 => uint256) public ghost_totalPaidIn;
+    mapping(uint256 => uint256) public ghost_totalCashedOut;
+    mapping(uint256 => uint256) public ghost_totalPaidOut;
+    mapping(uint256 => uint256) public ghost_totalAllowanceUsed;
+    mapping(uint256 => uint256) public ghost_totalAddedToBalance;
+
+    // Fee tracking (key innovation for strict invariants)
+    mapping(uint256 => uint256) public ghost_totalFeesDeducted;
+    mapping(uint256 => uint256) public ghost_totalFeesSentToProject1;
+    mapping(uint256 => uint256) public ghost_totalHeldFeeAmounts;
+    mapping(uint256 => uint256) public ghost_totalReturnedFees;
+    mapping(uint256 => uint256) public ghost_totalProcessedFees;
+
+    // Per-actor tracking
+    mapping(address => mapping(uint256 => uint256)) public ghost_actorContributed;
+    mapping(address => mapping(uint256 => uint256)) public ghost_actorExtracted;
+
+    // Token tracking
+    mapping(uint256 => uint256) public ghost_totalReservesSent;
+
+    // Global conservation
+    uint256 public ghost_globalInflows;
+    uint256 public ghost_globalOutflows;
+
+    // Operation counters
+    uint256 public callCount_pay2;
+    uint256 public callCount_pay3;
+    uint256 public callCount_cashOut2;
+    uint256 public callCount_cashOut3;
+    uint256 public callCount_sendPayouts2;
+    uint256 public callCount_useAllowance2;
+    uint256 public callCount_sendReserved2;
+    uint256 public callCount_processHeldFees2;
+    uint256 public callCount_addToBalanceReturn2;
+    uint256 public callCount_addToBalanceNoReturn2;
+    uint256 public callCount_burnTokens2;
+    uint256 public callCount_burnTokens3;
+    uint256 public callCount_claimCredits2;
+    uint256 public callCount_advanceTime;
+
+    constructor(
+        IJBMultiTerminal _terminal,
+        IJBTerminalStore _store,
+        IJBController _controller,
+        IJBTokens _tokens,
+        uint256 _projectId2,
+        uint256 _projectId3,
+        uint256 _projectId4,
+        address _projectOwner
+    ) {
+        terminal = _terminal;
+        store = _store;
+        controller = _controller;
+        tokens = _tokens;
+        projectId2 = _projectId2;
+        projectId3 = _projectId3;
+        projectId4 = _projectId4;
+        projectOwner = _projectOwner;
+
+        for (uint256 i = 0; i < NUM_ACTORS; i++) {
+            address actor = address(uint160(0x4000 + i));
+            actors.push(actor);
+        }
+    }
+
+    // =========================================================================
+    // Helpers
+    // =========================================================================
+
+    function _getActor(uint256 seed) internal view returns (address) {
+        return actors[seed % actors.length];
+    }
+
+    /// @notice Compute the fee that would be deducted from `amount` (forward fee).
+    function _feeFrom(uint256 amount) internal pure returns (uint256) {
+        return JBFees.feeAmountFrom(amount, FEE_PERCENT);
+    }
+
+    // =========================================================================
+    // 14 Operations
+    // =========================================================================
+
+    /// @notice Pay into project 2.
+    function payProject2(uint256 seed) external {
+        uint256 amount = bound(seed, 0.001 ether, 5 ether);
+        address actor = _getActor(seed);
+        vm.deal(actor, amount);
+
+        vm.prank(actor);
+        try terminal.pay{value: amount}(projectId2, JBConstants.NATIVE_TOKEN, amount, actor, 0, "", "") {
+            ghost_totalPaidIn[projectId2] += amount;
+            ghost_actorContributed[actor][projectId2] += amount;
+            ghost_globalInflows += amount;
+            callCount_pay2++;
+        } catch {}
+    }
+
+    /// @notice Pay into project 3.
+    function payProject3(uint256 seed) external {
+        uint256 amount = bound(seed, 0.001 ether, 5 ether);
+        address actor = _getActor(seed);
+        vm.deal(actor, amount);
+
+        vm.prank(actor);
+        try terminal.pay{value: amount}(projectId3, JBConstants.NATIVE_TOKEN, amount, actor, 0, "", "") {
+            ghost_totalPaidIn[projectId3] += amount;
+            ghost_actorContributed[actor][projectId3] += amount;
+            ghost_globalInflows += amount;
+            callCount_pay3++;
+        } catch {}
+    }
+
+    /// @notice Cash out tokens from project 2.
+    function cashOutProject2(uint256 seed) external {
+        address actor = _getActor(seed);
+        uint256 actorBalance = tokens.totalBalanceOf(actor, projectId2);
+        if (actorBalance == 0) return;
+
+        uint256 cashOutAmount = bound(seed, 1, actorBalance);
+
+        vm.prank(actor);
+        try terminal.cashOutTokensOf({
+            holder: actor,
+            projectId: projectId2,
+            cashOutCount: cashOutAmount,
+            tokenToReclaim: JBConstants.NATIVE_TOKEN,
+            minTokensReclaimed: 0,
+            beneficiary: payable(actor),
+            metadata: ""
+        }) returns (
+            uint256 reclaimAmount
+        ) {
+            ghost_totalCashedOut[projectId2] += reclaimAmount;
+            ghost_actorExtracted[actor][projectId2] += reclaimAmount;
+            ghost_globalOutflows += reclaimAmount;
+            // Cash out fee is deducted from reclaim when cashOutTaxRate < MAX
+            uint256 feeAmount = _feeFrom(reclaimAmount);
+            ghost_totalFeesDeducted[projectId2] += feeAmount;
+            callCount_cashOut2++;
+        } catch {}
+    }
+
+    /// @notice Cash out tokens from project 3.
+    function cashOutProject3(uint256 seed) external {
+        address actor = _getActor(seed);
+        uint256 actorBalance = tokens.totalBalanceOf(actor, projectId3);
+        if (actorBalance == 0) return;
+
+        uint256 cashOutAmount = bound(seed, 1, actorBalance);
+
+        vm.prank(actor);
+        try terminal.cashOutTokensOf({
+            holder: actor,
+            projectId: projectId3,
+            cashOutCount: cashOutAmount,
+            tokenToReclaim: JBConstants.NATIVE_TOKEN,
+            minTokensReclaimed: 0,
+            beneficiary: payable(actor),
+            metadata: ""
+        }) returns (
+            uint256 reclaimAmount
+        ) {
+            ghost_totalCashedOut[projectId3] += reclaimAmount;
+            ghost_actorExtracted[actor][projectId3] += reclaimAmount;
+            ghost_globalOutflows += reclaimAmount;
+            callCount_cashOut3++;
+        } catch {}
+    }
+
+    /// @notice Send payouts from project 2.
+    function sendPayoutsProject2(uint256 seed) external {
+        uint256 balance = store.balanceOf(address(terminal), projectId2, JBConstants.NATIVE_TOKEN);
+        if (balance == 0) return;
+
+        uint256 amount = bound(seed, 1, balance);
+
+        uint256 terminalBalBefore = address(terminal).balance;
+        vm.prank(projectOwner);
+        try terminal.sendPayoutsOf({
+            projectId: projectId2,
+            token: JBConstants.NATIVE_TOKEN,
+            amount: amount,
+            currency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+            minTokensPaidOut: 0
+        }) returns (
+            uint256 amountPaidOut
+        ) {
+            ghost_totalPaidOut[projectId2] += amountPaidOut;
+            // Track actual ETH that left the terminal, not the gross recorded amount.
+            // The fee stays in the terminal (paid to project #1 via internal _pay).
+            uint256 actualOutflow = terminalBalBefore - address(terminal).balance;
+            ghost_globalOutflows += actualOutflow;
+            callCount_sendPayouts2++;
+        } catch {}
+    }
+
+    /// @notice Use surplus allowance from project 2.
+    function useAllowanceProject2(uint256 seed) external {
+        uint256 balance = store.balanceOf(address(terminal), projectId2, JBConstants.NATIVE_TOKEN);
+        if (balance == 0) return;
+
+        uint256 amount = bound(seed, 1, balance > 3 ether ? 3 ether : balance);
+
+        vm.prank(projectOwner);
+        try terminal.useAllowanceOf({
+            projectId: projectId2,
+            token: JBConstants.NATIVE_TOKEN,
+            amount: amount,
+            currency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+            minTokensPaidOut: 0,
+            beneficiary: payable(projectOwner),
+            feeBeneficiary: payable(projectOwner),
+            memo: ""
+        }) returns (
+            uint256 netAmountPaidOut
+        ) {
+            ghost_totalAllowanceUsed[projectId2] += netAmountPaidOut;
+            ghost_globalOutflows += netAmountPaidOut;
+            callCount_useAllowance2++;
+        } catch {}
+    }
+
+    /// @notice Send reserved tokens for project 2.
+    function sendReservedTokens2(uint256 seed) external {
+        seed; // suppress unused warning
+        vm.prank(projectOwner);
+        try controller.sendReservedTokensToSplitsOf(projectId2) returns (uint256 tokenCount) {
+            ghost_totalReservesSent[projectId2] += tokenCount;
+            callCount_sendReserved2++;
+        } catch {}
+    }
+
+    /// @notice Process held fees for project 2.
+    function processHeldFees2(uint256 seed) external {
+        seed;
+
+        // Advance time past the 28-day holding period to ensure fees are unlocked
+        vm.warp(block.timestamp + 30 days);
+
+        // Count available held fees
+        JBFee[] memory fees = terminal.heldFeesOf(projectId2, JBConstants.NATIVE_TOKEN, 100);
+        if (fees.length == 0) return;
+
+        uint256 feeSum;
+        for (uint256 i = 0; i < fees.length; i++) {
+            feeSum += _feeFrom(fees[i].amount);
+        }
+
+        try terminal.processHeldFeesOf(projectId2, JBConstants.NATIVE_TOKEN, fees.length) {
+            ghost_totalProcessedFees[projectId2] += feeSum;
+            callCount_processHeldFees2++;
+        } catch {}
+    }
+
+    /// @notice Add to balance with fee return.
+    function addToBalanceReturnFees2(uint256 seed) external {
+        uint256 amount = bound(seed, 0.001 ether, 2 ether);
+        address actor = _getActor(seed);
+        vm.deal(actor, amount);
+
+        // Snapshot held fees before
+        JBFee[] memory feesBefore = terminal.heldFeesOf(projectId2, JBConstants.NATIVE_TOKEN, 100);
+        uint256 heldBefore;
+        for (uint256 i = 0; i < feesBefore.length; i++) {
+            heldBefore += feesBefore[i].amount;
+        }
+
+        vm.prank(actor);
+        try terminal.addToBalanceOf{value: amount}(
+            projectId2,
+            JBConstants.NATIVE_TOKEN,
+            amount,
+            true,
+            "",
+            "" // shouldReturnHeldFees = true
+        ) {
+            ghost_totalAddedToBalance[projectId2] += amount;
+            ghost_globalInflows += amount;
+
+            // Track returned fees by measuring held fee change
+            JBFee[] memory feesAfter = terminal.heldFeesOf(projectId2, JBConstants.NATIVE_TOKEN, 100);
+            uint256 heldAfter;
+            for (uint256 i = 0; i < feesAfter.length; i++) {
+                heldAfter += feesAfter[i].amount;
+            }
+            if (heldBefore > heldAfter) {
+                ghost_totalReturnedFees[projectId2] += (heldBefore - heldAfter);
+            }
+            callCount_addToBalanceReturn2++;
+        } catch {}
+    }
+
+    /// @notice Add to balance without fee return.
+    function addToBalanceNoReturn2(uint256 seed) external {
+        uint256 amount = bound(seed, 0.001 ether, 2 ether);
+        address actor = _getActor(seed);
+        vm.deal(actor, amount);
+
+        vm.prank(actor);
+        try terminal.addToBalanceOf{value: amount}(
+            projectId2,
+            JBConstants.NATIVE_TOKEN,
+            amount,
+            false,
+            "",
+            "" // shouldReturnHeldFees = false
+        ) {
+            ghost_totalAddedToBalance[projectId2] += amount;
+            ghost_globalInflows += amount;
+            callCount_addToBalanceNoReturn2++;
+        } catch {}
+    }
+
+    /// @notice Burn tokens for project 2.
+    function burnTokens2(uint256 seed) external {
+        address actor = _getActor(seed);
+        uint256 actorBalance = tokens.totalBalanceOf(actor, projectId2);
+        if (actorBalance == 0) return;
+
+        uint256 burnAmount = bound(seed, 1, actorBalance);
+
+        vm.prank(actor);
+        try controller.burnTokensOf({holder: actor, projectId: projectId2, tokenCount: burnAmount, memo: ""}) {
+            callCount_burnTokens2++;
+        } catch {}
+    }
+
+    /// @notice Burn tokens for project 3.
+    function burnTokens3(uint256 seed) external {
+        address actor = _getActor(seed);
+        uint256 actorBalance = tokens.totalBalanceOf(actor, projectId3);
+        if (actorBalance == 0) return;
+
+        uint256 burnAmount = bound(seed, 1, actorBalance);
+
+        vm.prank(actor);
+        try controller.burnTokensOf({holder: actor, projectId: projectId3, tokenCount: burnAmount, memo: ""}) {
+            callCount_burnTokens3++;
+        } catch {}
+    }
+
+    /// @notice Claim credits as ERC20 for project 2.
+    function claimCredits2(uint256 seed) external {
+        address actor = _getActor(seed);
+
+        // creditBalanceOf returns just the credit portion (not ERC20)
+        uint256 creditBalance = tokens.creditBalanceOf(actor, projectId2);
+        if (creditBalance == 0) return;
+
+        uint256 claimAmount = bound(seed, 1, creditBalance);
+
+        vm.prank(actor);
+        try tokens.claimTokensFor({holder: actor, projectId: projectId2, count: claimAmount, beneficiary: actor}) {
+            callCount_claimCredits2++;
+        } catch {}
+    }
+
+    /// @notice Advance block time.
+    function advanceTime(uint256 seed) external {
+        uint256 delta = bound(seed, 1 hours, 30 days);
+        vm.warp(block.timestamp + delta);
+        callCount_advanceTime++;
+    }
+
+    // =========================================================================
+    // View helpers for invariant checks
+    // =========================================================================
+
+    function getActor(uint256 index) external view returns (address) {
+        return actors[index];
+    }
+}

package/test/invariants/handlers/RulesetsHandler.sol

@@ -0,0 +1,111 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.6;
+
+import "forge-std/Test.sol";
+import {JBConstants} from "../../../src/libraries/JBConstants.sol";
+import {IJBRulesets} from "../../../src/interfaces/IJBRulesets.sol";
+import {IJBController} from "../../../src/interfaces/IJBController.sol";
+import {IJBRulesetApprovalHook} from "../../../src/interfaces/IJBRulesetApprovalHook.sol";
+import {JBRuleset} from "../../../src/structs/JBRuleset.sol";
+import {JBRulesetMetadata} from "../../../src/structs/JBRulesetMetadata.sol";
+import {JBRulesetConfig} from "../../../src/structs/JBRulesetConfig.sol";
+import {JBSplitGroup} from "../../../src/structs/JBSplitGroup.sol";
+import {JBFundAccessLimitGroup} from "../../../src/structs/JBFundAccessLimitGroup.sol";
+import {JBRulesetMetadataResolver} from "../../../src/libraries/JBRulesetMetadataResolver.sol";
+
+/// @notice Handler contract for JBRulesets invariant testing.
+/// @dev Drives ruleset queueing, time advancement, and weight cache updates.
+contract RulesetsHandler is Test {
+    using JBRulesetMetadataResolver for JBRulesetMetadata;
+
+    IJBRulesets public rulesets;
+    IJBController public controller;
+
+    uint256 public projectId;
+    address public projectOwner;
+
+    // Ghost: track the last observed cycle number and weight for monotonicity checks
+    uint48 public ghost_lastCycleNumber;
+    uint112 public ghost_lastWeight;
+    bool public ghost_hasLaunched;
+    uint256 public ghost_queueCount;
+
+    constructor(IJBRulesets _rulesets, IJBController _controller, uint256 _projectId, address _projectOwner) {
+        rulesets = _rulesets;
+        controller = _controller;
+        projectId = _projectId;
+        projectOwner = _projectOwner;
+        ghost_hasLaunched = true;
+
+        // Snapshot initial state
+        JBRuleset memory current = rulesets.currentOf(projectId);
+        ghost_lastCycleNumber = current.cycleNumber;
+        ghost_lastWeight = current.weight;
+    }
+
+    /// @notice Queue a new ruleset with random weight and duration.
+    function queueRuleset(uint256 weightSeed, uint256 durationSeed, uint256 weightCutSeed) public {
+        uint112 weight = uint112(bound(weightSeed, 1, 1e24));
+        uint32 duration = uint32(bound(durationSeed, 1 days, 365 days));
+        uint32 weightCutPercent = uint32(bound(weightCutSeed, 0, JBConstants.MAX_WEIGHT_CUT_PERCENT));
+
+        JBRulesetMetadata memory 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
+        });
+
+        JBRulesetConfig[] memory configs = new JBRulesetConfig[](1);
+        configs[0] = JBRulesetConfig({
+            mustStartAtOrAfter: 0,
+            duration: duration,
+            weight: weight,
+            weightCutPercent: weightCutPercent,
+            approvalHook: IJBRulesetApprovalHook(address(0)),
+            metadata: metadata,
+            splitGroups: new JBSplitGroup[](0),
+            fundAccessLimitGroups: new JBFundAccessLimitGroup[](0)
+        });
+
+        vm.prank(projectOwner);
+        try controller.queueRulesetsOf({projectId: projectId, rulesetConfigurations: configs, memo: ""}) {
+            ghost_queueCount++;
+        } catch {
+            // May fail if not controller
+        }
+    }
+
+    /// @notice Advance time to trigger ruleset cycling.
+    function advanceTime(uint256 timeSeed) public {
+        uint256 timeToAdvance = bound(timeSeed, 1 hours, 180 days);
+        vm.warp(block.timestamp + timeToAdvance);
+
+        // Update ghost state from current ruleset
+        JBRuleset memory current = rulesets.currentOf(projectId);
+        if (current.id != 0) {
+            ghost_lastCycleNumber = current.cycleNumber;
+            ghost_lastWeight = current.weight;
+        }
+    }
+
+    /// @notice Update the weight cache for the project.
+    function updateWeightCache() public {
+        try rulesets.updateRulesetWeightCache(projectId) {} catch {}
+    }
+}

package/test/invariants/handlers/TerminalStoreHandler.sol

@@ -0,0 +1,146 @@
+// 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 Handler contract for JBTerminalStore invariant testing.
+/// @dev Wraps terminal operations and tracks ghost variables for conservation checks.
+contract TerminalStoreHandler 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;
+
+    // Track actors
+    address[] public actors;
+    mapping(address => bool) public isActor;
+    uint256 public constant NUM_ACTORS = 5;
+
+    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(0x1000 + i));
+            actors.push(actor);
+            isActor[actor] = true;
+        }
+    }
+
+    /// @notice Selects an actor based on a seed.
+    function _getActor(uint256 seed) internal view returns (address) {
+        return actors[seed % actors.length];
+    }
+
+    /// @notice Pay the project with native tokens.
+    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,
+            amount: amount,
+            token: JBConstants.NATIVE_TOKEN,
+            beneficiary: actor,
+            minReturnedTokens: 0,
+            memo: "",
+            metadata: new bytes(0)
+        });
+
+        ghost_totalPaidIn += amount;
+    }
+
+    /// @notice Cash out tokens for native tokens.
+    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;
+    }
+
+    /// @notice Send payouts from the project.
+    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 {
+            // Payout may fail if there's no payout limit configured
+        }
+    }
+
+    /// @notice Add to project balance without minting tokens.
+    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;
+    }
+
+    receive() external payable {}
+}