@bananapus/core-v6 0.0.18 → 0.0.20

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);
+    }
+}

package/test/fork/TestSequencerPriceFeedFork.sol

@@ -0,0 +1,168 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.26;
+
+import {Test} from "forge-std/Test.sol";
+
+import {AggregatorV2V3Interface} from "@chainlink/contracts/src/v0.8/shared/interfaces/AggregatorV2V3Interface.sol";
+import {AggregatorV3Interface} from "@chainlink/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol";
+
+import {JBChainlinkV3SequencerPriceFeed} from "../../src/JBChainlinkV3SequencerPriceFeed.sol";
+
+/// @notice Fork tests for JBChainlinkV3SequencerPriceFeed against the live Arbitrum sequencer uptime feed and
+/// ETH/USD Chainlink oracle.
+contract TestSequencerPriceFeedFork is Test {
+    // Chainlink feed addresses (Arbitrum mainnet).
+    address constant ARB_ETH_USD_FEED = 0x639Fe6ab55C921f74e7fac1ee960C0B6293ba612;
+    address constant ARB_SEQUENCER_FEED = 0xFdB631F5EE196F0ed6FAa767959853A9F217697D;
+
+    // Staleness threshold (1 hour).
+    uint256 constant THRESHOLD = 3600;
+
+    // Grace period after sequencer restart (1 hour).
+    uint256 constant GRACE_PERIOD = 3600;
+
+    // Pinned block for reproducibility (sequencer is up at this block).
+    uint256 constant FORK_BLOCK = 300_000_000;
+
+    JBChainlinkV3SequencerPriceFeed feed;
+
+    function setUp() public {
+        string memory rpc = vm.envOr("RPC_ARBITRUM_MAINNET", string(""));
+        if (bytes(rpc).length == 0) {
+            // Skip all tests if no Arbitrum RPC is configured.
+            return;
+        }
+
+        vm.createSelectFork(rpc, FORK_BLOCK);
+
+        feed = new JBChainlinkV3SequencerPriceFeed(
+            AggregatorV3Interface(ARB_ETH_USD_FEED),
+            THRESHOLD,
+            AggregatorV2V3Interface(ARB_SEQUENCER_FEED),
+            GRACE_PERIOD
+        );
+    }
+
+    // ------------------------------------------------------------------
+    // Helpers
+    // ------------------------------------------------------------------
+
+    modifier skipIfNoRpc() {
+        if (address(feed) == address(0)) {
+            return;
+        }
+        _;
+    }
+
+    // ------------------------------------------------------------------
+    // 1. Normal operation — valid price returned
+    // ------------------------------------------------------------------
+
+    /// @notice Under normal conditions (sequencer up, grace period elapsed), currentUnitPrice returns a sane price.
+    function test_normalOperation_returnsValidPrice() public skipIfNoRpc {
+        uint256 price18 = feed.currentUnitPrice(18);
+
+        // ETH price should be between $500 and $50,000.
+        assertGt(price18, 500e18, "ETH price too low");
+        assertLt(price18, 50_000e18, "ETH price too high");
+
+        // Cross-check against raw latestRoundData from the price feed.
+        (, int256 rawPrice,,,) = AggregatorV3Interface(ARB_ETH_USD_FEED).latestRoundData();
+        uint256 feedDecimals = AggregatorV3Interface(ARB_ETH_USD_FEED).decimals();
+        // forge-lint: disable-next-line(unsafe-typecast)
+        uint256 expected18 = uint256(rawPrice) * 10 ** (18 - feedDecimals);
+        assertEq(price18, expected18, "Price mismatch vs raw feed");
+    }
+
+    // ------------------------------------------------------------------
+    // 2. Sequencer down — reverts
+    // ------------------------------------------------------------------
+
+    /// @notice When the sequencer feed reports answer=1 (down), currentUnitPrice reverts.
+    function test_sequencerDown_reverts() public skipIfNoRpc {
+        // Mock the sequencer feed to report answer=1 (down).
+        // latestRoundData() selector = 0xfeaf968c
+        vm.mockCall(
+            ARB_SEQUENCER_FEED,
+            abi.encodeWithSelector(AggregatorV3Interface.latestRoundData.selector),
+            abi.encode(
+                uint80(1), // roundId
+                int256(1), // answer = 1 → sequencer down
+                block.timestamp - GRACE_PERIOD - 100, // startedAt (irrelevant when answer=1)
+                block.timestamp, // updatedAt
+                uint80(1) // answeredInRound
+            )
+        );
+
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                JBChainlinkV3SequencerPriceFeed.JBChainlinkV3SequencerPriceFeed_SequencerDownOrRestarting.selector,
+                block.timestamp,
+                GRACE_PERIOD,
+                block.timestamp - GRACE_PERIOD - 100
+            )
+        );
+        feed.currentUnitPrice(18);
+    }
+
+    // ------------------------------------------------------------------
+    // 3. Grace period active — reverts
+    // ------------------------------------------------------------------
+
+    /// @notice When the sequencer just came back up (within grace period), currentUnitPrice reverts.
+    function test_gracePeriodActive_reverts() public skipIfNoRpc {
+        // Mock the sequencer feed: answer=0 (up) but startedAt is 1 second ago (within grace period).
+        uint256 startedAt = block.timestamp - 1;
+
+        vm.mockCall(
+            ARB_SEQUENCER_FEED,
+            abi.encodeWithSelector(AggregatorV3Interface.latestRoundData.selector),
+            abi.encode(
+                uint80(1), // roundId
+                int256(0), // answer = 0 → sequencer up
+                startedAt, // startedAt = very recent
+                block.timestamp, // updatedAt
+                uint80(1) // answeredInRound
+            )
+        );
+
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                JBChainlinkV3SequencerPriceFeed.JBChainlinkV3SequencerPriceFeed_SequencerDownOrRestarting.selector,
+                block.timestamp,
+                GRACE_PERIOD,
+                startedAt
+            )
+        );
+        feed.currentUnitPrice(18);
+    }
+
+    // ------------------------------------------------------------------
+    // 4. Post-grace recovery — succeeds
+    // ------------------------------------------------------------------
+
+    /// @notice After the grace period has elapsed, currentUnitPrice succeeds again.
+    function test_postGraceRecovery_succeeds() public skipIfNoRpc {
+        // Mock the sequencer feed: answer=0 (up), startedAt is well before the grace period ended.
+        uint256 startedAt = block.timestamp - GRACE_PERIOD - 100;
+
+        vm.mockCall(
+            ARB_SEQUENCER_FEED,
+            abi.encodeWithSelector(AggregatorV3Interface.latestRoundData.selector),
+            abi.encode(
+                uint80(1), // roundId
+                int256(0), // answer = 0 → sequencer up
+                startedAt, // startedAt = well in the past
+                block.timestamp, // updatedAt
+                uint80(1) // answeredInRound
+            )
+        );
+
+        // The price feed itself is still the real Chainlink feed, so this should succeed.
+        uint256 price18 = feed.currentUnitPrice(18);
+
+        // Same sanity check: ETH price between $500 and $50,000.
+        assertGt(price18, 500e18, "ETH price too low after recovery");
+        assertLt(price18, 50_000e18, "ETH price too high after recovery");
+    }
+}

package/test/fork/TestTerminalPreviewParityFork.sol

@@ -0,0 +1,109 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.26;
+
+import {TestTerminalPreviewParity_Local} from "../TestTerminalPreviewParity.sol";
+import {IJBController} from "../../src/interfaces/IJBController.sol";
+import {IJBTerminal} from "../../src/interfaces/IJBTerminal.sol";
+import {IJBCashOutTerminal} from "../../src/interfaces/IJBCashOutTerminal.sol";
+import {JBConstants} from "../../src/libraries/JBConstants.sol";
+import {JBCashOutHookSpecification} from "../../src/structs/JBCashOutHookSpecification.sol";
+import {JBPayHookSpecification} from "../../src/structs/JBPayHookSpecification.sol";
+import {JBRuleset} from "../../src/structs/JBRuleset.sol";
+
+contract TestTerminalPreviewParityFork is TestTerminalPreviewParity_Local {
+    uint256 internal constant FORK_BLOCK = 22_000_000;
+
+    function setUp() public override {
+        vm.createSelectFork("ethereum", FORK_BLOCK);
+        super.setUp();
+    }
+
+    function testForkPreviewPayForMatchesPay() external {
+        _launchFeeProject();
+        uint256 projectId = _launchProject(2500, 10_000);
+
+        (
+            JBRuleset memory ruleset,
+            uint256 previewBeneficiaryTokenCount,
+            uint256 previewReservedTokenCount,
+            JBPayHookSpecification[] memory hookSpecifications
+        ) = _terminal.previewPayFor(projectId, JBConstants.NATIVE_TOKEN, 1 ether, _beneficiary, "");
+
+        assertEq(hookSpecifications.length, 0);
+
+        uint256 balanceBefore = jbTokens().totalBalanceOf(_beneficiary, projectId);
+        uint256 reservedBefore = _controller.pendingReservedTokenBalanceOf(projectId);
+
+        address payer = makeAddr("forkPayer");
+        vm.deal(payer, 1 ether);
+
+        vm.expectEmit();
+        emit IJBTerminal.Pay(
+            ruleset.id,
+            ruleset.cycleNumber,
+            projectId,
+            payer,
+            _beneficiary,
+            1 ether,
+            previewBeneficiaryTokenCount,
+            "",
+            "",
+            payer
+        );
+
+        vm.prank(payer);
+        uint256 beneficiaryTokenCount =
+            _terminal.pay{value: 1 ether}(projectId, JBConstants.NATIVE_TOKEN, 1 ether, _beneficiary, 0, "", "");
+
+        assertEq(beneficiaryTokenCount, previewBeneficiaryTokenCount);
+        assertEq(jbTokens().totalBalanceOf(_beneficiary, projectId) - balanceBefore, previewBeneficiaryTokenCount);
+        assertEq(_controller.pendingReservedTokenBalanceOf(projectId) - reservedBefore, previewReservedTokenCount);
+    }
+
+    function testForkPreviewCashOutFromMatchesCashOut() external {
+        _launchFeeProject();
+        uint256 projectId = _launchProject(0, 5000);
+
+        vm.prank(_projectOwner);
+        jbFeelessAddresses().setFeelessAddress(_beneficiary, true);
+
+        vm.deal(_beneficiary, 1 ether);
+        vm.prank(_beneficiary);
+        uint256 minted =
+            _terminal.pay{value: 1 ether}(projectId, JBConstants.NATIVE_TOKEN, 1 ether, _beneficiary, 0, "", "");
+
+        uint256 cashOutCount = minted / 2;
+
+        (
+            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(
+            _beneficiary, projectId, cashOutCount, JBConstants.NATIVE_TOKEN, 0, payable(_beneficiary), ""
+        );
+
+        assertEq(reclaimAmount, previewReclaimAmount);
+    }
+}

package/test/units/static/JBController/TestPreviewMintOf.sol

@@ -0,0 +1,116 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.26;
+
+import {JBController} from "../../../../src/JBController.sol";
+import {IJBRulesetApprovalHook} from "../../../../src/interfaces/IJBRulesetApprovalHook.sol";
+import {IJBRulesets} from "../../../../src/interfaces/IJBRulesets.sol";
+import {JBConstants} from "../../../../src/libraries/JBConstants.sol";
+import {JBRulesetMetadataResolver} from "../../../../src/libraries/JBRulesetMetadataResolver.sol";
+import {JBRuleset} from "../../../../src/structs/JBRuleset.sol";
+import {JBRulesetMetadata} from "../../../../src/structs/JBRulesetMetadata.sol";
+import {JBControllerSetup} from "./JBControllerSetup.sol";
+
+contract TestPreviewMintOf_Local is JBControllerSetup {
+    uint256 _projectId = 1;
+
+    function setUp() public {
+        super.controllerSetup();
+    }
+
+    function test_RevertsWhenTokenCountIsZero() external {
+        vm.expectRevert(JBController.JBController_ZeroTokensToMint.selector);
+        _controller.previewMintOf(_projectId, 0, true);
+    }
+
+    function test_ReturnsSplitCountsWhenUsingReservedPercent() external {
+        uint256 tokenCount = 1000;
+
+        JBRulesetMetadata memory metadata = JBRulesetMetadata({
+            reservedPercent: 2500,
+            cashOutTaxRate: JBConstants.MAX_CASH_OUT_TAX_RATE,
+            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
+        });
+
+        JBRuleset memory ruleset = JBRuleset({
+            cycleNumber: 1,
+            id: 1,
+            basedOnId: 0,
+            start: uint48(block.timestamp),
+            duration: 0,
+            weight: 0,
+            weightCutPercent: 0,
+            approvalHook: IJBRulesetApprovalHook(address(0)),
+            metadata: JBRulesetMetadataResolver.packRulesetMetadata(metadata)
+        });
+
+        mockExpect(address(rulesets), abi.encodeCall(IJBRulesets.currentOf, (_projectId)), abi.encode(ruleset));
+
+        (uint256 beneficiaryTokenCount, uint256 reservedTokenCount) =
+            _controller.previewMintOf(_projectId, tokenCount, true);
+
+        assertEq(beneficiaryTokenCount, 750);
+        assertEq(reservedTokenCount, 250);
+    }
+
+    function test_IgnoresReservedPercentWhenFlagIsFalse() external {
+        uint256 tokenCount = 1000;
+
+        JBRulesetMetadata memory metadata = JBRulesetMetadata({
+            reservedPercent: 9000,
+            cashOutTaxRate: JBConstants.MAX_CASH_OUT_TAX_RATE,
+            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
+        });
+
+        JBRuleset memory ruleset = JBRuleset({
+            cycleNumber: 1,
+            id: 1,
+            basedOnId: 0,
+            start: uint48(block.timestamp),
+            duration: 0,
+            weight: 0,
+            weightCutPercent: 0,
+            approvalHook: IJBRulesetApprovalHook(address(0)),
+            metadata: JBRulesetMetadataResolver.packRulesetMetadata(metadata)
+        });
+
+        mockExpect(address(rulesets), abi.encodeCall(IJBRulesets.currentOf, (_projectId)), abi.encode(ruleset));
+
+        (uint256 beneficiaryTokenCount, uint256 reservedTokenCount) =
+            _controller.previewMintOf(_projectId, tokenCount, false);
+
+        assertEq(beneficiaryTokenCount, tokenCount);
+        assertEq(reservedTokenCount, 0);
+    }
+}