@bananapus/core-v6 0.0.36 → 0.0.38

package/test/fork/TestChainlinkPriceFeedFork.sol

@@ -1,254 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity 0.8.28;
-
-import {Test} from "forge-std/Test.sol";
-
-import {AggregatorV3Interface} from "@chainlink/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol";
-
-import {JBChainlinkV3PriceFeed} from "../../src/JBChainlinkV3PriceFeed.sol";
-import {JBPrices} from "../../src/JBPrices.sol";
-import {IJBDirectory} from "../../src/interfaces/IJBDirectory.sol";
-import {IJBPermissions} from "../../src/interfaces/IJBPermissions.sol";
-import {IJBPriceFeed} from "../../src/interfaces/IJBPriceFeed.sol";
-import {IJBProjects} from "../../src/interfaces/IJBProjects.sol";
-
-/// @notice Fork tests for JBChainlinkV3PriceFeed and JBPrices against live Chainlink oracles on Ethereum mainnet.
-contract TestChainlinkPriceFeedFork is Test {
-    // Chainlink feed addresses (Ethereum mainnet).
-    address constant ETH_USD_FEED = 0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419;
-    address constant BTC_USD_FEED = 0xF4030086522a5bEEa4988F8cA5B36dbC97BeE88c;
-
-    // Staleness threshold (1 hour).
-    uint256 constant THRESHOLD = 3600;
-
-    // Currency identifiers (arbitrary nonzero values for JBPrices mapping keys).
-    uint256 constant CURRENCY_ETH = 1;
-    uint256 constant CURRENCY_USD = 2;
-    uint256 constant CURRENCY_BTC = 3;
-
-    // Pinned block for reproducibility.
-    uint256 constant FORK_BLOCK = 22_000_000;
-
-    JBChainlinkV3PriceFeed ethUsdPriceFeed;
-    JBChainlinkV3PriceFeed btcUsdPriceFeed;
-    JBPrices prices;
-    address owner;
-
-    function setUp() public {
-        vm.createSelectFork("ethereum", FORK_BLOCK);
-
-        owner = makeAddr("owner");
-
-        // Deploy price feeds against real Chainlink aggregators.
-        ethUsdPriceFeed = new JBChainlinkV3PriceFeed(AggregatorV3Interface(ETH_USD_FEED), THRESHOLD);
-        btcUsdPriceFeed = new JBChainlinkV3PriceFeed(AggregatorV3Interface(BTC_USD_FEED), THRESHOLD);
-
-        // Deploy JBPrices with mock directory/permissions/projects (only price resolution is tested).
-        prices = new JBPrices(
-            IJBDirectory(makeAddr("directory")),
-            IJBPermissions(makeAddr("permissions")),
-            IJBProjects(makeAddr("projects")),
-            owner,
-            address(0)
-        );
-    }
-
-    // ------------------------------------------------------------------
-    // Live feed sanity checks
-    // ------------------------------------------------------------------
-
-    /// @notice Verify currentUnitPrice returns a sane ETH/USD price at the pinned block.
-    function test_currentUnitPrice_liveEthUsd() public view {
-        uint256 price18 = ethUsdPriceFeed.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.
-        (, int256 rawPrice,,,) = AggregatorV3Interface(ETH_USD_FEED).latestRoundData();
-        uint256 feedDecimals = AggregatorV3Interface(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");
-    }
-
-    // ------------------------------------------------------------------
-    // Decimal scaling
-    // ------------------------------------------------------------------
-
-    /// @notice Verify correct scaling across 6, 8, 18, and 27 decimals.
-    function test_currentUnitPrice_differentDecimals() public view {
-        uint256 price6 = ethUsdPriceFeed.currentUnitPrice(6);
-        uint256 price8 = ethUsdPriceFeed.currentUnitPrice(8);
-        uint256 price18 = ethUsdPriceFeed.currentUnitPrice(18);
-        uint256 price27 = ethUsdPriceFeed.currentUnitPrice(27);
-
-        // Raw feed is 8 decimals — price8 should match it exactly.
-        (, int256 rawPrice,,,) = AggregatorV3Interface(ETH_USD_FEED).latestRoundData();
-        // forge-lint: disable-next-line(unsafe-typecast)
-        assertEq(price8, uint256(rawPrice), "8-decimal mismatch");
-
-        // 6 decimals = raw / 100 (truncated).
-        // forge-lint: disable-next-line(unsafe-typecast)
-        assertEq(price6, uint256(rawPrice) / 1e2, "6-decimal mismatch");
-
-        // 18 decimals = raw * 1e10.
-        // forge-lint: disable-next-line(unsafe-typecast)
-        assertEq(price18, uint256(rawPrice) * 1e10, "18-decimal mismatch");
-
-        // 27 decimals = raw * 1e19.
-        // forge-lint: disable-next-line(unsafe-typecast)
-        assertEq(price27, uint256(rawPrice) * 1e19, "27-decimal mismatch");
-    }
-
-    // ------------------------------------------------------------------
-    // JBPrices integration — direct feed
-    // ------------------------------------------------------------------
-
-    /// @notice Register ETH/USD feed and resolve via pricePerUnitOf.
-    function test_pricePerUnitOf_directFeed() public {
-        vm.prank(owner);
-        prices.addPriceFeedFor(0, CURRENCY_USD, CURRENCY_ETH, IJBPriceFeed(address(ethUsdPriceFeed)));
-
-        uint256 priceFromPrices = prices.pricePerUnitOf(0, CURRENCY_USD, CURRENCY_ETH, 18);
-        uint256 priceFromFeed = ethUsdPriceFeed.currentUnitPrice(18);
-
-        assertEq(priceFromPrices, priceFromFeed, "Direct feed mismatch");
-    }
-
-    // ------------------------------------------------------------------
-    // JBPrices integration — inverse feed
-    // ------------------------------------------------------------------
-
-    /// @notice Register ETH/USD feed but query USD/ETH — verify inverse calculation.
-    function test_pricePerUnitOf_inverseFeed() public {
-        vm.prank(owner);
-        prices.addPriceFeedFor(0, CURRENCY_USD, CURRENCY_ETH, IJBPriceFeed(address(ethUsdPriceFeed)));
-
-        uint256 inversePrice = prices.pricePerUnitOf(0, CURRENCY_ETH, CURRENCY_USD, 18);
-
-        // inverse = (1e18 * 1e18) / ethUsdPrice. For ETH ~$2000, inverse ~0.0005e18 = 5e14.
-        // Sane range: $500–$50k → inverse 2e13–2e15.
-        assertGt(inversePrice, 2e13, "Inverse price too low");
-        assertLt(inversePrice, 2e15, "Inverse price too high");
-
-        // Verify round-trip: price * inverse ≈ 1e18 (within mulDiv rounding).
-        uint256 directPrice = ethUsdPriceFeed.currentUnitPrice(18);
-        uint256 product = (directPrice * inversePrice) / 1e18;
-        // mulDiv truncation can cause up to ~1e4 wei error at these magnitudes.
-        assertApproxEqAbs(product, 1e18, 1e4, "Round-trip mismatch");
-    }
-
-    // ------------------------------------------------------------------
-    // JBPrices — same currency
-    // ------------------------------------------------------------------
-
-    /// @notice pricePerUnitOf(X, X, 18) should return 1e18 without any feed.
-    function test_pricePerUnitOf_sameCurrency() public view {
-        uint256 price = prices.pricePerUnitOf(0, CURRENCY_ETH, CURRENCY_ETH, 18);
-        assertEq(price, 1e18, "Same currency should be 1e18");
-    }
-
-    // ------------------------------------------------------------------
-    // JBPrices — default fallback
-    // ------------------------------------------------------------------
-
-    /// @notice Feed registered at projectId=0 should be used when querying projectId=99.
-    function test_pricePerUnitOf_defaultFallback() public {
-        vm.prank(owner);
-        prices.addPriceFeedFor(0, CURRENCY_USD, CURRENCY_ETH, IJBPriceFeed(address(ethUsdPriceFeed)));
-
-        uint256 defaultPrice = prices.pricePerUnitOf(0, CURRENCY_USD, CURRENCY_ETH, 18);
-        uint256 fallbackPrice = prices.pricePerUnitOf(99, CURRENCY_USD, CURRENCY_ETH, 18);
-
-        assertEq(fallbackPrice, defaultPrice, "Fallback should match default");
-    }
-
-    // ------------------------------------------------------------------
-    // Stale price revert
-    // ------------------------------------------------------------------
-
-    /// @notice Warping past the threshold should cause a StalePrice revert.
-    function test_stalePriceReverts() public {
-        // Snapshot updatedAt from the feed at this block.
-        (,,, uint256 updatedAt,) = AggregatorV3Interface(ETH_USD_FEED).latestRoundData();
-
-        // Warp far enough that the feed's updatedAt + threshold < block.timestamp.
-        uint256 warpTo = block.timestamp + 7200;
-        vm.warp(warpTo);
-
-        vm.expectRevert(
-            abi.encodeWithSelector(
-                JBChainlinkV3PriceFeed.JBChainlinkV3PriceFeed_StalePrice.selector, warpTo, THRESHOLD, updatedAt
-            )
-        );
-        ethUsdPriceFeed.currentUnitPrice(18);
-    }
-
-    // ------------------------------------------------------------------
-    // Feed immutability
-    // ------------------------------------------------------------------
-
-    /// @notice Registering the same currency pair twice should revert.
-    function test_feedImmutability() public {
-        vm.prank(owner);
-        prices.addPriceFeedFor(0, CURRENCY_USD, CURRENCY_ETH, IJBPriceFeed(address(ethUsdPriceFeed)));
-
-        vm.prank(owner);
-        vm.expectRevert(
-            abi.encodeWithSelector(
-                JBPrices.JBPrices_PriceFeedAlreadyExists.selector, IJBPriceFeed(address(ethUsdPriceFeed))
-            )
-        );
-        prices.addPriceFeedFor(0, CURRENCY_USD, CURRENCY_ETH, IJBPriceFeed(address(btcUsdPriceFeed)));
-    }
-
-    // ------------------------------------------------------------------
-    // Multiple feeds
-    // ------------------------------------------------------------------
-
-    /// @notice Register both ETH/USD and BTC/USD and verify independent resolution.
-    function test_multipleFeeds_ethUsd_btcUsd() public {
-        vm.startPrank(owner);
-        prices.addPriceFeedFor(0, CURRENCY_USD, CURRENCY_ETH, IJBPriceFeed(address(ethUsdPriceFeed)));
-        prices.addPriceFeedFor(0, CURRENCY_USD, CURRENCY_BTC, IJBPriceFeed(address(btcUsdPriceFeed)));
-        vm.stopPrank();
-
-        uint256 ethUsd = prices.pricePerUnitOf(0, CURRENCY_USD, CURRENCY_ETH, 18);
-        uint256 btcUsd = prices.pricePerUnitOf(0, CURRENCY_USD, CURRENCY_BTC, 18);
-
-        // ETH/USD: $500–$50,000.
-        assertGt(ethUsd, 500e18, "ETH/USD too low");
-        assertLt(ethUsd, 50_000e18, "ETH/USD too high");
-
-        // BTC/USD: $10,000–$500,000.
-        assertGt(btcUsd, 10_000e18, "BTC/USD too low");
-        assertLt(btcUsd, 500_000e18, "BTC/USD too high");
-
-        // BTC should be more expensive than ETH.
-        assertGt(btcUsd, ethUsd, "BTC should cost more than ETH");
-    }
-
-    // ------------------------------------------------------------------
-    // Cross-price derivation
-    // ------------------------------------------------------------------
-
-    /// @notice Derive ETH/BTC price from ETH/USD and BTC/USD feeds.
-    function test_crossPriceDerived() public {
-        vm.startPrank(owner);
-        prices.addPriceFeedFor(0, CURRENCY_USD, CURRENCY_ETH, IJBPriceFeed(address(ethUsdPriceFeed)));
-        prices.addPriceFeedFor(0, CURRENCY_USD, CURRENCY_BTC, IJBPriceFeed(address(btcUsdPriceFeed)));
-        vm.stopPrank();
-
-        uint256 ethUsd = prices.pricePerUnitOf(0, CURRENCY_USD, CURRENCY_ETH, 18);
-        uint256 btcUsd = prices.pricePerUnitOf(0, CURRENCY_USD, CURRENCY_BTC, 18);
-
-        // ETH/BTC = ethUsd / btcUsd (how many BTC per 1 ETH).
-        uint256 ethPerBtc = (ethUsd * 1e18) / btcUsd;
-
-        // Should be between 0.01 and 0.1 (at 18 decimals: 1e16–1e17).
-        assertGt(ethPerBtc, 1e16, "ETH/BTC ratio too low");
-        assertLt(ethPerBtc, 1e17, "ETH/BTC ratio too high");
-    }
-}

package/test/fork/TestSequencerPriceFeedFork.sol

@@ -1,168 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity 0.8.28;
-
-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 view 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

@@ -1,108 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity 0.8.28;
-
-import {TestTerminalPreviewParity_Local} from "../TestTerminalPreviewParity.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);
-    }
-}