@bananapus/core-v6 0.0.19 → 0.0.20

package/src/interfaces/IJBTerminalStore.sol

@@ -114,7 +114,6 @@ interface IJBTerminalStore {
         returns (uint256);
 
     /// @notice Simulates a cash out without modifying state.
-    /// @param terminal The terminal address to simulate the cash out from.
     /// @param holder The address cashing out.
     /// @param projectId The ID of the project being cashed out from.
     /// @param cashOutCount The number of project tokens being cashed out.
@@ -127,7 +126,6 @@ interface IJBTerminalStore {
     /// @return cashOutTaxRate The cash out tax rate that would be applied.
     /// @return hookSpecifications Any cash out hook specifications from the data hook.
     function previewCashOutFrom(
-        address terminal,
         address holder,
         uint256 projectId,
         uint256 cashOutCount,
@@ -146,17 +144,15 @@ interface IJBTerminalStore {
         );
 
     /// @notice Simulates a payment without modifying state.
-    /// @param terminal The terminal address to simulate the payment from.
     /// @param payer The address of the payer.
     /// @param amount The amount being paid.
     /// @param projectId The ID of the project being paid.
     /// @param beneficiary The address to mint project tokens to.
     /// @param metadata Extra data to pass along to the data hook.
     /// @return ruleset The project's current ruleset.
-    /// @return tokenCount The number of project tokens that would be minted.
+    /// @return tokenCount The number of project tokens that would be minted, including reserved tokens.
     /// @return hookSpecifications Any pay hook specifications from the data hook.
     function previewPayFrom(
-        address terminal,
         address payer,
         JBTokenAmount memory amount,
         uint256 projectId,

package/src/libraries/JBPayoutSplitGroupLib.sol

@@ -0,0 +1,157 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.26;
+
+import {mulDiv} from "@prb/math/src/Common.sol";
+
+import {IJBPayoutTerminal} from "../interfaces/IJBPayoutTerminal.sol";
+import {IJBSplits} from "../interfaces/IJBSplits.sol";
+import {IJBTerminalStore} from "../interfaces/IJBTerminalStore.sol";
+import {JBSplit} from "../structs/JBSplit.sol";
+import {JBConstants} from "./JBConstants.sol";
+
+/// @notice Minimal callback surface used only by this library to call back into the terminal's `executePayout(...)`.
+/// @dev Kept local to this file because `executePayout(...)` is an implementation detail, not a shared public
+/// interface.
+interface IJBPayoutSplitGroupExecutor {
+    function executePayout(
+        JBSplit calldata split,
+        uint256 projectId,
+        address token,
+        uint256 amount,
+        address originalMessageSender
+    )
+        external
+        returns (uint256 netPayoutAmount);
+}
+
+/// @notice External library for payout split-group distribution extracted to reduce terminal bytecode.
+/// @dev Called via DELEGATECALL from the terminal, so events are emitted from the terminal's address.
+library JBPayoutSplitGroupLib {
+    event PayoutReverted(uint256 indexed projectId, JBSplit split, uint256 amount, bytes reason, address caller);
+    event SendPayoutToSplit(
+        uint256 indexed projectId,
+        uint256 indexed rulesetId,
+        uint256 indexed group,
+        JBSplit split,
+        uint256 amount,
+        uint256 netAmount,
+        address caller
+    );
+
+    /// @notice Sends payouts to the payout splits group specified in a project's ruleset.
+    /// @param splits The splits contract to read splits from.
+    /// @param store The terminal store used to restore balance when a payout fails.
+    /// @param projectId The ID of the project to send the payouts of.
+    /// @param token The address of the token being paid out.
+    /// @param rulesetId The ID of the ruleset of the split group being paid.
+    /// @param amount The total amount being paid out.
+    /// @param caller The original caller of the terminal payout flow.
+    /// @return leftoverAmount The leftover amount after split payouts.
+    /// @return amountEligibleForFees The amount of payouts that are eligible for fees.
+    function sendPayoutsToSplitGroupOf(
+        IJBSplits splits,
+        IJBTerminalStore store,
+        uint256 projectId,
+        address token,
+        uint256 rulesetId,
+        uint256 amount,
+        address caller
+    )
+        external
+        returns (uint256 leftoverAmount, uint256 amountEligibleForFees)
+    {
+        // The total percentage available to split.
+        uint256 leftoverPercentage = JBConstants.SPLITS_TOTAL_PERCENT;
+        uint256 group = uint256(uint160(token));
+
+        // Get a reference to the project's payout splits.
+        JBSplit[] memory payoutSplits = splits.splitsOf({projectId: projectId, rulesetId: rulesetId, groupId: group});
+
+        leftoverAmount = amount;
+
+        // Transfer between all splits.
+        for (uint256 i; i < payoutSplits.length; i++) {
+            // Get a reference to the split being iterated on.
+            JBSplit memory split = payoutSplits[i];
+
+            // The amount to send to the split.
+            uint256 payoutAmount = mulDiv(leftoverAmount, split.percent, leftoverPercentage);
+
+            // The final payout amount after taking out any fees.
+            uint256 netPayoutAmount = _sendPayoutToSplit({
+                store: store, split: split, projectId: projectId, token: token, amount: payoutAmount, caller: caller
+            });
+
+            // If the split hook is a feeless address, this payout doesn't incur a fee.
+            if (netPayoutAmount != 0 && netPayoutAmount != payoutAmount) {
+                amountEligibleForFees += payoutAmount;
+            }
+
+            if (payoutAmount != 0) {
+                // Subtract from the amount to be sent to the beneficiary.
+                unchecked {
+                    leftoverAmount -= payoutAmount;
+                }
+            }
+
+            unchecked {
+                // Decrement the leftover percentage.
+                leftoverPercentage -= split.percent;
+            }
+
+            emit SendPayoutToSplit({
+                projectId: projectId,
+                rulesetId: rulesetId,
+                group: group,
+                split: split,
+                amount: payoutAmount,
+                netAmount: netPayoutAmount,
+                caller: caller
+            });
+        }
+    }
+
+    /// @notice Sends a payout to a split.
+    /// @param store The terminal store used to restore balance when a payout fails.
+    /// @param split The split to pay.
+    /// @param projectId The ID of the project the split was specified by.
+    /// @param token The address of the token being paid out.
+    /// @param amount The total amount that the split is being paid.
+    /// @param caller The original caller of the terminal payout flow.
+    /// @return netPayoutAmount The amount sent to the split after subtracting fees.
+    function _sendPayoutToSplit(
+        IJBTerminalStore store,
+        JBSplit memory split,
+        uint256 projectId,
+        address token,
+        uint256 amount,
+        address caller
+    )
+        private
+        returns (uint256 netPayoutAmount)
+    {
+        // Failed split payouts consume the payout limit by design. The try-catch prevents a single
+        // split from DoS-ing the entire payout. Failed splits' amounts are returned to the project balance via
+        // `recordAddedBalanceFor`. Payout limit consumption is correct because the project authorized the
+        // distribution.
+        // slither-disable-next-line reentrancy-events
+        try IJBPayoutSplitGroupExecutor(address(this))
+            .executePayout({
+                split: split, projectId: projectId, token: token, amount: amount, originalMessageSender: caller
+            }) returns (
+            uint256 payoutAmount
+        ) {
+            return payoutAmount;
+        } catch (bytes memory failureReason) {
+            emit PayoutReverted({
+                projectId: projectId, split: split, amount: amount, reason: failureReason, caller: caller
+            });
+
+            // Add balance back to the project.
+            store.recordAddedBalanceFor({projectId: projectId, token: token, amount: amount});
+
+            // Since the payout failed the netPayoutAmount is zero.
+            return 0;
+        }
+    }
+}

package/src/structs/JBCashOutHookSpecification.sol

@@ -6,11 +6,13 @@ import {IJBCashOutHook} from "../interfaces/IJBCashOutHook.sol";
 /// @notice A cash out hook specification sent from the ruleset's data hook back to the terminal. This specification is
 /// fulfilled by the terminal.
 /// @custom:member hook The cash out hook to use when fulfilling this specification.
+/// @custom:member noop A flag indicating if the hook callback should be skipped.
 /// @custom:member amount The amount to send to the hook.
 /// @custom:member metadata Metadata to pass to the hook.
 // forge-lint: disable-next-line(pascal-case-struct)
 struct JBCashOutHookSpecification {
     IJBCashOutHook hook;
+    bool noop;
     uint256 amount;
     bytes metadata;
 }

package/src/structs/JBPayHookSpecification.sol

@@ -6,11 +6,13 @@ import {IJBPayHook} from "../interfaces/IJBPayHook.sol";
 /// @notice A pay hook specification sent from the ruleset's data hook back to the terminal. This specification is
 /// fulfilled by the terminal.
 /// @custom:member hook The pay hook to use when fulfilling this specification.
+/// @custom:member noop A flag indicating if the hook callback should be skipped.
 /// @custom:member amount The amount to send to the hook.
 /// @custom:member metadata Metadata to pass the hook.
 // forge-lint: disable-next-line(pascal-case-struct)
 struct JBPayHookSpecification {
     IJBPayHook hook;
+    bool noop;
     uint256 amount;
     bytes metadata;
 }

package/test/CoreExploitTests.t.sol

@@ -358,7 +358,7 @@ contract EdgeCases_Local is TestBaseWorkflow {
     ///         requires a call boundary to catch the panic.
     function externalWriteToIndex1(JBPayHookSpecification[] memory specs) external pure {
         // This will revert with Panic(0x32) -- array index out of bounds.
-        specs[1] = JBPayHookSpecification({hook: IJBPayHook(address(0)), amount: 0, metadata: ""});
+        specs[1] = JBPayHookSpecification({hook: IJBPayHook(address(0)), noop: false, amount: 0, metadata: ""});
     }
 
     /// @notice Verify that when BOTH hooks are present, the array size is 2 and no OOB occurs.
@@ -372,8 +372,10 @@ contract EdgeCases_Local is TestBaseWorkflow {
         JBPayHookSpecification[] memory hookSpecifications = new JBPayHookSpecification[](arraySize);
 
         // Both writes are valid.
-        hookSpecifications[0] = JBPayHookSpecification({hook: IJBPayHook(address(0)), amount: 0, metadata: ""});
-        hookSpecifications[1] = JBPayHookSpecification({hook: IJBPayHook(address(0)), amount: 0, metadata: ""});
+        hookSpecifications[0] =
+            JBPayHookSpecification({hook: IJBPayHook(address(0)), noop: false, amount: 0, metadata: ""});
+        hookSpecifications[1] =
+            JBPayHookSpecification({hook: IJBPayHook(address(0)), noop: false, amount: 0, metadata: ""});
     }
 
     /// @notice Verify that when neither hook is present, no write occurs.
@@ -1171,7 +1173,9 @@ contract EdgeCases_Local is TestBaseWorkflow {
             // Replicate REVDeployer logic exactly:
             // if (usesTiered721Hook) hookSpecifications[0] = ...
             if (usesT) {
-                specs[0] = JBPayHookSpecification({hook: IJBPayHook(address(0xdead)), amount: 1 ether, metadata: ""});
+                specs[0] = JBPayHookSpecification({
+                    hook: IJBPayHook(address(0xdead)), noop: false, amount: 1 ether, metadata: ""
+                });
             }
 
             // if (usesBuybackHook) hookSpecifications[1] = ... // ALWAYS index 1!
@@ -1182,8 +1186,9 @@ contract EdgeCases_Local is TestBaseWorkflow {
                     this.externalWriteToIndex1(specs);
                 } else {
                     // usesT=true, usesB=true → size=2, writing to [1] → OK
-                    specs[1] =
-                        JBPayHookSpecification({hook: IJBPayHook(address(0xbeef)), amount: 2 ether, metadata: ""});
+                    specs[1] = JBPayHookSpecification({
+                        hook: IJBPayHook(address(0xbeef)), noop: false, amount: 2 ether, metadata: ""
+                    });
                 }
             }
         }
@@ -1496,6 +1501,10 @@ contract EdgeCases_Local is TestBaseWorkflow {
 
     /// @notice Verify processHeldFeesOf correctly handles partial unlock (some locked, some unlocked).
     function test_partialLockedFees() public {
+        // Use an explicit warp to a realistic timestamp to avoid via_ir reordering of block.timestamp reads.
+        vm.warp(1_000_000);
+        uint256 _startTime = 1_000_000;
+
         // Launch fee project.
         JBTerminalConfig[] memory terminalConfigurations = new JBTerminalConfig[](1);
         JBAccountingContext[] memory tokensToAccept = new JBAccountingContext[](1);
@@ -1615,7 +1624,9 @@ contract EdgeCases_Local is TestBaseWorkflow {
         });
 
         // Warp 14 days (halfway through holding period).
-        vm.warp(block.timestamp + 14 days);
+        uint256 _fee1Time = _startTime;
+        uint256 _midPoint = _fee1Time + 14 days;
+        vm.warp(_midPoint);
 
         // Create second held fee (this one will be locked when we process at day 28).
         vm.prank(_projectOwner);
@@ -1635,7 +1646,7 @@ contract EdgeCases_Local is TestBaseWorkflow {
         assertEq(heldFees.length, 2, "should have 2 held fees");
 
         // Warp to 28 days + 1 from the start (first fee unlocked, second still locked 14 more days).
-        vm.warp(block.timestamp + 14 days + 1);
+        vm.warp(_midPoint + 14 days + 1);
 
         // Process all — should only process the first (unlocked) fee and stop at the second (locked).
         _terminal.processHeldFeesOf(projectId, JBConstants.NATIVE_TOKEN, 100);
@@ -1644,8 +1655,8 @@ contract EdgeCases_Local is TestBaseWorkflow {
         JBFee[] memory remainingFees = _terminal.heldFeesOf(projectId, JBConstants.NATIVE_TOKEN, 100);
         assertEq(remainingFees.length, 1, "one fee should still be locked");
 
-        // Warp past second fee's unlock.
-        vm.warp(block.timestamp + 14 days + 1);
+        // Warp past second fee's unlock (second fee was created at _midPoint, unlocks at _midPoint + 28 days).
+        vm.warp(_midPoint + 28 days + 1);
 
         // Process the remaining fee.
         _terminal.processHeldFeesOf(projectId, JBConstants.NATIVE_TOKEN, 100);

package/test/TestCashOutHooks.sol

@@ -156,8 +156,9 @@ contract TestCashOutHooks_Local is TestBaseWorkflow {
         // Reference cash out hook specifications.
         JBCashOutHookSpecification[] memory _specifications = new JBCashOutHookSpecification[](1);
 
-        _specifications[0] =
-            JBCashOutHookSpecification({hook: IJBCashOutHook(_cashOutHook), amount: _halfPaid, metadata: ""});
+        _specifications[0] = JBCashOutHookSpecification({
+            hook: IJBCashOutHook(_cashOutHook), noop: false, amount: _halfPaid, metadata: ""
+        });
 
         vm.startPrank(multisig());
         // Set the hook as feeless.
@@ -260,8 +261,9 @@ contract TestCashOutHooks_Local is TestBaseWorkflow {
         // Reference cash out hook specifications.
         JBCashOutHookSpecification[] memory _specifications = new JBCashOutHookSpecification[](1);
 
-        _specifications[0] =
-            JBCashOutHookSpecification({hook: IJBCashOutHook(_cashOutHook), amount: _halfPaid, metadata: ""});
+        _specifications[0] = JBCashOutHookSpecification({
+            hook: IJBCashOutHook(_cashOutHook), noop: false, amount: _halfPaid, metadata: ""
+        });
 
         uint256 _customCashOutTaxRate = JBConstants.MAX_CASH_OUT_TAX_RATE / 2;
         uint256 _customCashOutCount = 1 * 10 ** 18;

package/test/TestDataHookFuzzing.sol

@@ -206,6 +206,7 @@ contract TestDataHookFuzzing_Local is TestBaseWorkflow {
         JBPayHookSpecification[] memory _specs = new JBPayHookSpecification[](1);
         _specs[0] = JBPayHookSpecification({
             hook: IJBPayHook(_payHook),
+            noop: false,
             amount: _payAmount + 1, // exceeds the paid amount
             metadata: ""
         });
@@ -327,7 +328,9 @@ contract TestDataHookFuzzing_Local is TestBaseWorkflow {
         jbFeelessAddresses().setFeelessAddress(_cashOutHook, true);
 
         JBCashOutHookSpecification[] memory _specs = new JBCashOutHookSpecification[](1);
-        _specs[0] = JBCashOutHookSpecification({hook: IJBCashOutHook(_cashOutHook), amount: _hookAmount, metadata: ""});
+        _specs[0] = JBCashOutHookSpecification({
+            hook: IJBCashOutHook(_cashOutHook), noop: false, amount: _hookAmount, metadata: ""
+        });
 
         // Override: cashOutTaxRate=0, half the tokens cashed out, original totalSupply.
         vm.mockCall(
@@ -491,7 +494,8 @@ contract TestDataHookFuzzing_Local is TestBaseWorkflow {
         // Cash out all tokens. With cashOutTaxRate=0, reclaim = full surplus = _payAmount.
         // Set hook spec amount to 1 wei -- total = _payAmount + 1 which exceeds balance.
         JBCashOutHookSpecification[] memory _specs = new JBCashOutHookSpecification[](1);
-        _specs[0] = JBCashOutHookSpecification({hook: IJBCashOutHook(makeAddr("hook")), amount: 1, metadata: ""});
+        _specs[0] =
+            JBCashOutHookSpecification({hook: IJBCashOutHook(makeAddr("hook")), noop: false, amount: 1, metadata: ""});
 
         vm.mockCall(
             _DATA_HOOK,

package/test/TestPayHooks.sol

@@ -136,7 +136,7 @@ contract TestPayHooks_Local is TestBaseWorkflow {
 
             // Package up the specification struct.
             _specifications[i] = JBPayHookSpecification({
-                hook: IJBPayHook(_hookAddress), amount: _payHookAmounts[i], metadata: _hookMetadata
+                hook: IJBPayHook(_hookAddress), noop: false, amount: _payHookAmounts[i], metadata: _hookMetadata
             });
 
             // Keep a reference to the data that'll be received by the hook.

package/test/TestRulesetQueueing.sol

@@ -39,7 +39,7 @@ contract TestRulesetQueuing_Local is TestBaseWorkflow {
         super.setUp();
 
         // Foundry defaults block.timestamp to 1, which causes underflow in tests using past timestamps.
-        vm.warp(7 days);
+        vm.warp(1_000_001);
 
         _terminal = jbMultiTerminal();
         _controller = jbController();
@@ -637,9 +637,6 @@ contract TestRulesetQueuing_Local is TestBaseWorkflow {
         uint112 _weightFirstQueued = uint112(1234 * 10 ** 18);
         uint112 _weightSecondQueued = uint112(6969 * 10 ** 18);
 
-        // Keep a reference to the expected ruleset IDs (timestamps).
-        uint256 _initialRulesetId = block.timestamp;
-
         // Package up a config.
         JBRulesetConfig[] memory _rulesetConfig = new JBRulesetConfig[](1);
         _rulesetConfig[0].mustStartAtOrAfter = 0;
@@ -657,10 +654,12 @@ contract TestRulesetQueuing_Local is TestBaseWorkflow {
         // Get the ruleset.
         JBRuleset memory _ruleset = jbRulesets().currentOf(projectId);
 
+        // Keep a reference to the expected ruleset IDs (use returned id to avoid via_ir reordering of block.timestamp).
+        uint256 _initialRulesetId = _ruleset.id;
+
         // Make sure the first ruleset has begun.
         assertEq(_ruleset.cycleNumber, 1);
         assertEq(_ruleset.weight, _weightInitial);
-        assertEq(_ruleset.id, block.timestamp);
 
         // Package up a new config.
         JBRulesetConfig[] memory _firstQueued = new JBRulesetConfig[](1);

package/test/TestRulesetQueuingStress.sol

@@ -236,10 +236,11 @@ contract MockApprovalHookConfigurable is IJBRulesetApprovalHook {
         /// @notice Mid-cycle queuing: new ruleset starts at next duration boundary.
         function test_midCycleQueuing_snapsToNextBoundary() external {
             uint256 pid = _launchProject(SEVEN_DAYS, INITIAL_WEIGHT, 0, IJBRulesetApprovalHook(address(0)));
-            uint256 originalStart = block.timestamp;
+            // Capture originalStart from the actual ruleset (avoid via_ir reordering of block.timestamp).
+            uint256 originalStart = _rulesets.currentOf(pid).start;
 
             // Warp to mid-cycle (day 3 of 7).
-            vm.warp(block.timestamp + 3 days);
+            vm.warp(originalStart + 3 days);
 
             _queueRuleset(pid, 0, SEVEN_DAYS, INITIAL_WEIGHT * 2, 0, IJBRulesetApprovalHook(address(0)));
 
@@ -573,7 +574,8 @@ contract MockApprovalHookConfigurable is IJBRulesetApprovalHook {
         /// @notice deriveStartFrom one second after boundary: snaps to next boundary.
         function test_deriveStartFrom_oneSecondAfterBoundary_snapsToNext() external {
             uint256 pid = _launchProject(SEVEN_DAYS, INITIAL_WEIGHT, 0, IJBRulesetApprovalHook(address(0)));
-            uint256 originalStart = block.timestamp;
+            // Capture originalStart from the actual ruleset (avoid via_ir reordering of block.timestamp).
+            uint256 originalStart = _rulesets.currentOf(pid).start;
 
             // 1 second after first boundary -> should snap to second boundary.
             _queueRuleset(

package/test/TestTerminalPreviewParity.sol

@@ -0,0 +1,208 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.26;
+
+import {TestBaseWorkflow} from "./helpers/TestBaseWorkflow.sol";
+import {IJBController} from "../src/interfaces/IJBController.sol";
+import {IJBMultiTerminal} from "../src/interfaces/IJBMultiTerminal.sol";
+import {IJBRulesetApprovalHook} from "../src/interfaces/IJBRulesetApprovalHook.sol";
+import {IJBTerminal} from "../src/interfaces/IJBTerminal.sol";
+import {IJBCashOutTerminal} from "../src/interfaces/IJBCashOutTerminal.sol";
+import {JBConstants} from "../src/libraries/JBConstants.sol";
+import {JBAccountingContext} from "../src/structs/JBAccountingContext.sol";
+import {JBCashOutHookSpecification} from "../src/structs/JBCashOutHookSpecification.sol";
+import {JBFundAccessLimitGroup} from "../src/structs/JBFundAccessLimitGroup.sol";
+import {JBPayHookSpecification} from "../src/structs/JBPayHookSpecification.sol";
+import {JBRuleset} from "../src/structs/JBRuleset.sol";
+import {JBRulesetConfig} from "../src/structs/JBRulesetConfig.sol";
+import {JBRulesetMetadata} from "../src/structs/JBRulesetMetadata.sol";
+import {JBSplitGroup} from "../src/structs/JBSplitGroup.sol";
+import {JBTerminalConfig} from "../src/structs/JBTerminalConfig.sol";
+
+contract TestTerminalPreviewParity_Local is TestBaseWorkflow {
+    IJBController internal _controller;
+    IJBMultiTerminal internal _terminal;
+    address internal _projectOwner;
+    address internal _beneficiary;
+
+    function setUp() public virtual override {
+        super.setUp();
+
+        _controller = jbController();
+        _terminal = jbMultiTerminal();
+        _projectOwner = multisig();
+        _beneficiary = beneficiary();
+    }
+
+    function _launchProject(uint16 reservedPercent, uint16 cashOutTaxRate) internal returns (uint256 projectId) {
+        JBRulesetConfig[] memory rulesetConfigurations = new JBRulesetConfig[](1);
+        rulesetConfigurations[0].mustStartAtOrAfter = 0;
+        rulesetConfigurations[0].duration = 0;
+        rulesetConfigurations[0].weight = 1000 * 10 ** 18;
+        rulesetConfigurations[0].weightCutPercent = 0;
+        rulesetConfigurations[0].approvalHook = IJBRulesetApprovalHook(address(0));
+        rulesetConfigurations[0].metadata = JBRulesetMetadata({
+            reservedPercent: reservedPercent,
+            cashOutTaxRate: cashOutTaxRate,
+            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
+        });
+        rulesetConfigurations[0].splitGroups = new JBSplitGroup[](0);
+        rulesetConfigurations[0].fundAccessLimitGroups = new JBFundAccessLimitGroup[](0);
+
+        JBAccountingContext[] memory contexts = new JBAccountingContext[](1);
+        contexts[0] = JBAccountingContext({
+            token: JBConstants.NATIVE_TOKEN, decimals: 18, currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
+        });
+
+        JBTerminalConfig[] memory terminalConfigurations = new JBTerminalConfig[](1);
+        terminalConfigurations[0] = JBTerminalConfig({terminal: _terminal, accountingContextsToAccept: contexts});
+
+        return _controller.launchProjectFor({
+            owner: _projectOwner,
+            projectUri: "ipfs://preview-parity",
+            rulesetConfigurations: rulesetConfigurations,
+            terminalConfigurations: terminalConfigurations,
+            memo: ""
+        });
+    }
+
+    function _launchFeeProject() internal {
+        _launchProject(0, JBConstants.MAX_CASH_OUT_TAX_RATE);
+    }
+
+    function testFuzzPreviewPayForMatchesPay(uint96 amount, uint16 reservedPercent) external {
+        amount = uint96(bound(amount, 1, 100 ether));
+        reservedPercent = uint16(bound(reservedPercent, 0, JBConstants.MAX_RESERVED_PERCENT));
+
+        _launchFeeProject();
+        uint256 projectId = _launchProject(reservedPercent, JBConstants.MAX_CASH_OUT_TAX_RATE);
+
+        (
+            JBRuleset memory ruleset,
+            uint256 previewBeneficiaryTokenCount,
+            uint256 previewReservedTokenCount,
+            JBPayHookSpecification[] memory hookSpecifications
+        ) = _terminal.previewPayFor(projectId, JBConstants.NATIVE_TOKEN, amount, _beneficiary, "");
+
+        assertEq(hookSpecifications.length, 0);
+
+        uint256 balanceBefore = jbTokens().totalBalanceOf(_beneficiary, projectId);
+        uint256 reservedBefore = _controller.pendingReservedTokenBalanceOf(projectId);
+
+        address payer = makeAddr("payer");
+        vm.deal(payer, amount);
+
+        vm.expectEmit();
+        emit IJBTerminal.Pay(
+            ruleset.id,
+            ruleset.cycleNumber,
+            projectId,
+            payer,
+            _beneficiary,
+            amount,
+            previewBeneficiaryTokenCount,
+            "",
+            "",
+            payer
+        );
+
+        vm.prank(payer);
+        uint256 beneficiaryTokenCount = _terminal.pay{value: amount}({
+            projectId: projectId,
+            token: JBConstants.NATIVE_TOKEN,
+            amount: amount,
+            beneficiary: _beneficiary,
+            minReturnedTokens: 0,
+            memo: "",
+            metadata: ""
+        });
+
+        assertEq(beneficiaryTokenCount, previewBeneficiaryTokenCount);
+        assertEq(jbTokens().totalBalanceOf(_beneficiary, projectId) - balanceBefore, previewBeneficiaryTokenCount);
+        assertEq(_controller.pendingReservedTokenBalanceOf(projectId) - reservedBefore, previewReservedTokenCount);
+    }
+
+    function testFuzzPreviewCashOutMatchesCashOut(
+        uint96 payAmount,
+        uint16 cashOutTaxRate,
+        uint256 cashOutCountSeed
+    )
+        external
+    {
+        payAmount = uint96(bound(payAmount, 1, 100 ether));
+        cashOutTaxRate = uint16(bound(cashOutTaxRate, 0, JBConstants.MAX_CASH_OUT_TAX_RATE));
+
+        _launchFeeProject();
+        uint256 projectId = _launchProject(0, cashOutTaxRate);
+
+        vm.prank(_projectOwner);
+        jbFeelessAddresses().setFeelessAddress(_beneficiary, true);
+
+        vm.deal(_beneficiary, payAmount);
+        vm.prank(_beneficiary);
+        uint256 minted = _terminal.pay{value: payAmount}({
+            projectId: projectId,
+            token: JBConstants.NATIVE_TOKEN,
+            amount: payAmount,
+            beneficiary: _beneficiary,
+            minReturnedTokens: 0,
+            memo: "",
+            metadata: ""
+        });
+
+        uint256 cashOutCount = bound(cashOutCountSeed, 1, minted);
+
+        (
+            JBRuleset memory ruleset,
+            uint256 previewReclaimAmount,
+            uint256 previewCashOutTaxRate,
+            JBCashOutHookSpecification[] memory hookSpecifications
+        ) = _terminal.previewCashOutFrom(
+            _beneficiary, projectId, cashOutCount, JBConstants.NATIVE_TOKEN, payable(_beneficiary), ""
+        );
+
+        assertEq(hookSpecifications.length, 0);
+
+        vm.expectEmit();
+        emit IJBCashOutTerminal.CashOutTokens(
+            ruleset.id,
+            ruleset.cycleNumber,
+            projectId,
+            _beneficiary,
+            _beneficiary,
+            cashOutCount,
+            previewCashOutTaxRate,
+            previewReclaimAmount,
+            "",
+            _beneficiary
+        );
+
+        vm.prank(_beneficiary);
+        uint256 reclaimAmount = _terminal.cashOutTokensOf({
+            holder: _beneficiary,
+            projectId: projectId,
+            cashOutCount: cashOutCount,
+            tokenToReclaim: JBConstants.NATIVE_TOKEN,
+            minTokensReclaimed: 0,
+            beneficiary: payable(_beneficiary),
+            metadata: ""
+        });
+
+        assertEq(reclaimAmount, previewReclaimAmount);
+    }
+}