@bananapus/core-v6 0.0.37 → 0.0.38

package/test/TestCashOutCountFor.sol

@@ -1,271 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.17;
-
-import {Test} from "forge-std/Test.sol";
-import {JBCashOuts} from "../src/libraries/JBCashOuts.sol";
-import {JBConstants} from "../src/libraries/JBConstants.sol";
-
-/// @dev Wrapper so library reverts can be caught by vm.expectRevert (library calls are inlined otherwise).
-contract CashOutCountForWrapper {
-    function minCashOutCountFor(
-        uint256 surplus,
-        uint256 desiredOutput,
-        uint256 totalSupply,
-        uint256 cashOutTaxRate
-    )
-        external
-        pure
-        returns (uint256)
-    {
-        return JBCashOuts.minCashOutCountFor(surplus, desiredOutput, totalSupply, cashOutTaxRate);
-    }
-}
-
-/// @title TestCashOutCountFor
-/// @notice Tests for JBCashOuts.minCashOutCountFor — the inverse of the bonding curve.
-contract TestCashOutCountFor is Test {
-    uint256 constant MAX_TAX = JBConstants.MAX_CASH_OUT_TAX_RATE;
-
-    CashOutCountForWrapper wrapper;
-
-    function setUp() public {
-        wrapper = new CashOutCountForWrapper();
-    }
-
-    // =========================================================================
-    // Edge cases
-    // =========================================================================
-
-    function test_zeroDesiredOutput() public pure {
-        assertEq(JBCashOuts.minCashOutCountFor(100 ether, 0, 1000e18, 5000), 0);
-    }
-
-    function test_desiredOutputEqualsSurplus() public pure {
-        uint256 count = JBCashOuts.minCashOutCountFor(100 ether, 100 ether, 1000e18, 5000);
-        assertEq(count, 1000e18, "Should return totalSupply when desiredOutput == surplus");
-    }
-
-    function test_desiredOutputExceedsSurplus() public pure {
-        uint256 count = JBCashOuts.minCashOutCountFor(100 ether, 200 ether, 1000e18, 5000);
-        assertEq(count, 1000e18, "Should return totalSupply when desiredOutput > surplus");
-    }
-
-    function test_maxTaxRate_reverts() public {
-        vm.expectRevert(JBCashOuts.JBCashOuts_DesiredOutputNotAchievable.selector);
-        wrapper.minCashOutCountFor(100 ether, 50 ether, 1000e18, MAX_TAX);
-    }
-
-    function test_zeroTaxRate() public pure {
-        // With 0 tax: out = S * c / T, so c = out * T / S.
-        // surplus=100, desiredOutput=25, totalSupply=200 → c = 25*200/100 = 50.
-        uint256 count = JBCashOuts.minCashOutCountFor(100, 25, 200, 0);
-        assertEq(count, 50);
-        assertGe(JBCashOuts.cashOutFrom(100, count, 200, 0), 25);
-    }
-
-    function test_zeroTaxRate_roundsUp() public pure {
-        // surplus=7, desiredOutput=2, totalSupply=100.
-        // Exact: c = 2*100/7 = 28.57... floor = 28. mulDiv(7, 28, 100) = 1 < 2. So c = 29.
-        uint256 count = JBCashOuts.minCashOutCountFor(7, 2, 100, 0);
-        assertGe(JBCashOuts.cashOutFrom(7, count, 100, 0), 2);
-    }
-
-    function test_zeroSurplus() public pure {
-        // surplus=0, desiredOutput=1 → desiredOutput >= surplus → return totalSupply.
-        uint256 count = JBCashOuts.minCashOutCountFor(0, 1, 1000e18, 5000);
-        assertEq(count, 1000e18);
-    }
-
-    // =========================================================================
-    // Specific examples
-    // =========================================================================
-
-    function test_halfTax_knownValues() public pure {
-        // surplus=100, totalSupply=100, taxRate=5000 (50%).
-        // Forward: cashOutFrom(100, 50, 100, 5000) = 37.
-        uint256 forwardResult = JBCashOuts.cashOutFrom(100, 50, 100, 5000);
-        assertEq(forwardResult, 37);
-
-        // Inverse: to get 37 out, we need at least 50 tokens.
-        uint256 count = JBCashOuts.minCashOutCountFor(100, 37, 100, 5000);
-        assertEq(count, 50);
-        assertGe(JBCashOuts.cashOutFrom(100, count, 100, 5000), 37);
-    }
-
-    function test_lowTax() public pure {
-        // taxRate=1000 (10%).
-        uint256 forwardResult = JBCashOuts.cashOutFrom(1000, 100, 1000, 1000);
-
-        uint256 count = JBCashOuts.minCashOutCountFor(1000, forwardResult, 1000, 1000);
-        assertGe(JBCashOuts.cashOutFrom(1000, count, 1000, 1000), forwardResult);
-        assertLe(count, 100);
-    }
-
-    function test_highTax() public pure {
-        // taxRate=9000 (90%).
-        uint256 forwardResult = JBCashOuts.cashOutFrom(1000, 500, 1000, 9000);
-
-        uint256 count = JBCashOuts.minCashOutCountFor(1000, forwardResult, 1000, 9000);
-        assertGe(JBCashOuts.cashOutFrom(1000, count, 1000, 9000), forwardResult);
-        assertLe(count, 500);
-    }
-
-    function test_realisticValues() public pure {
-        // 10 ETH surplus, 1M tokens, 30% tax.
-        uint256 surplus = 10 ether;
-        uint256 totalSupply = 1_000_000e18;
-        uint256 taxRate = 3000;
-        uint256 cashOutAmount = 100_000e18;
-
-        uint256 forwardResult = JBCashOuts.cashOutFrom(surplus, cashOutAmount, totalSupply, taxRate);
-
-        uint256 count = JBCashOuts.minCashOutCountFor(surplus, forwardResult, totalSupply, taxRate);
-        assertGe(JBCashOuts.cashOutFrom(surplus, count, totalSupply, taxRate), forwardResult);
-        assertLe(count, cashOutAmount);
-    }
-
-    function test_smallSurplus_largeTotalSupply() public pure {
-        // Edge case that trips up analytic formulas: surplus << totalSupply.
-        uint256 surplus = 3178;
-        uint256 totalSupply = 11_740_172_277_586_795;
-        uint256 taxRate = 2;
-        uint256 desiredOutput = 1589;
-
-        uint256 count = JBCashOuts.minCashOutCountFor(surplus, desiredOutput, totalSupply, taxRate);
-        assertGe(JBCashOuts.cashOutFrom(surplus, count, totalSupply, taxRate), desiredOutput);
-    }
-
-    // =========================================================================
-    // Round-trip: minCashOutCountFor(S, cashOutFrom(S, c, T, r), T, r) <= c
-    // =========================================================================
-
-    function testFuzz_roundTrip_inverseOfForward(
-        uint128 surplus,
-        uint128 totalSupply,
-        uint128 cashOutCount,
-        uint16 cashOutTaxRate
-    )
-        public
-        pure
-    {
-        vm.assume(surplus > 0);
-        vm.assume(totalSupply > 0);
-        vm.assume(cashOutCount > 0 && cashOutCount <= totalSupply);
-        vm.assume(cashOutTaxRate <= MAX_TAX);
-        vm.assume(cashOutTaxRate < MAX_TAX);
-
-        uint256 output = JBCashOuts.cashOutFrom(surplus, cashOutCount, totalSupply, cashOutTaxRate);
-        vm.assume(output > 0);
-
-        uint256 recoveredCount = JBCashOuts.minCashOutCountFor(surplus, output, totalSupply, cashOutTaxRate);
-
-        // The recovered count should be <= the original count, because the forward function rounds down.
-        assertLe(recoveredCount, cashOutCount, "Round-trip: recovered count should be <= original");
-    }
-
-    // =========================================================================
-    // Correctness: cashOutFrom(S, minCashOutCountFor(S, out, T, r), T, r) >= out
-    // =========================================================================
-
-    function testFuzz_correctness_outputMeetsTarget(
-        uint128 surplus,
-        uint128 totalSupply,
-        uint16 cashOutTaxRate
-    )
-        public
-        pure
-    {
-        vm.assume(surplus > 1);
-        vm.assume(totalSupply > 0);
-        vm.assume(cashOutTaxRate <= MAX_TAX);
-        vm.assume(cashOutTaxRate < MAX_TAX);
-
-        uint256 desiredOutput = uint256(surplus) / 2;
-        vm.assume(desiredOutput > 0 && desiredOutput < surplus);
-
-        uint256 count = JBCashOuts.minCashOutCountFor(surplus, desiredOutput, totalSupply, cashOutTaxRate);
-
-        uint256 actualOutput = JBCashOuts.cashOutFrom(surplus, count, totalSupply, cashOutTaxRate);
-        assertGe(actualOutput, desiredOutput, "Correctness: output should meet or exceed target");
-    }
-
-    function testFuzz_correctness_fullRange(
-        uint128 surplus,
-        uint128 totalSupply,
-        uint128 desiredOutput,
-        uint16 cashOutTaxRate
-    )
-        public
-        pure
-    {
-        vm.assume(surplus > 0);
-        vm.assume(totalSupply > 0);
-        vm.assume(cashOutTaxRate <= MAX_TAX);
-        vm.assume(cashOutTaxRate < MAX_TAX);
-        vm.assume(desiredOutput > 0 && desiredOutput < surplus);
-
-        uint256 count = JBCashOuts.minCashOutCountFor(surplus, desiredOutput, totalSupply, cashOutTaxRate);
-
-        assertLe(count, totalSupply, "Count should not exceed totalSupply");
-
-        uint256 actualOutput = JBCashOuts.cashOutFrom(surplus, count, totalSupply, cashOutTaxRate);
-        assertGe(actualOutput, desiredOutput, "Output should meet target");
-    }
-
-    // =========================================================================
-    // Monotonicity: larger desired output → larger or equal count
-    // =========================================================================
-
-    function testFuzz_monotonicity(
-        uint128 surplus,
-        uint128 totalSupply,
-        uint128 out1,
-        uint128 out2,
-        uint16 cashOutTaxRate
-    )
-        public
-        pure
-    {
-        vm.assume(surplus > 2);
-        vm.assume(totalSupply > 0);
-        vm.assume(cashOutTaxRate <= MAX_TAX);
-        vm.assume(cashOutTaxRate < MAX_TAX);
-        vm.assume(out1 > 0 && out2 > 0);
-        vm.assume(out1 < surplus && out2 < surplus);
-
-        if (out1 > out2) (out1, out2) = (out2, out1);
-
-        uint256 count1 = JBCashOuts.minCashOutCountFor(surplus, out1, totalSupply, cashOutTaxRate);
-        uint256 count2 = JBCashOuts.minCashOutCountFor(surplus, out2, totalSupply, cashOutTaxRate);
-
-        assertLe(count1, count2, "Monotonicity: larger output needs >= count");
-    }
-
-    // =========================================================================
-    // Minimality: count - 1 should produce less than desiredOutput
-    // =========================================================================
-
-    function testFuzz_minimality(
-        uint128 surplus,
-        uint128 totalSupply,
-        uint128 desiredOutput,
-        uint16 cashOutTaxRate
-    )
-        public
-        pure
-    {
-        vm.assume(surplus > 0);
-        vm.assume(totalSupply > 1);
-        vm.assume(cashOutTaxRate <= MAX_TAX);
-        vm.assume(cashOutTaxRate < MAX_TAX);
-        vm.assume(desiredOutput > 0 && desiredOutput < surplus);
-
-        uint256 count = JBCashOuts.minCashOutCountFor(surplus, desiredOutput, totalSupply, cashOutTaxRate);
-
-        vm.assume(count > 1);
-        vm.assume(count < totalSupply);
-
-        uint256 lesserOutput = JBCashOuts.cashOutFrom(surplus, count - 1, totalSupply, cashOutTaxRate);
-        assertLt(lesserOutput, desiredOutput, "Minimality: count-1 should produce less than target");
-    }
-}

package/test/TestCashOutHooks.sol

@@ -1,351 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity >=0.8.6;
-
-import {TestBaseWorkflow} from "./helpers/TestBaseWorkflow.sol";
-import {IJBCashOutHook} from "../src/interfaces/IJBCashOutHook.sol";
-import {IJBController} from "../src/interfaces/IJBController.sol";
-import {IJBMultiTerminal} from "../src/interfaces/IJBMultiTerminal.sol";
-import {IJBRulesetApprovalHook} from "../src/interfaces/IJBRulesetApprovalHook.sol";
-import {IJBRulesetDataHook} from "../src/interfaces/IJBRulesetDataHook.sol";
-import {IJBToken} from "../src/interfaces/IJBToken.sol";
-import {IJBTokens} from "../src/interfaces/IJBTokens.sol";
-import {JBConstants} from "../src/libraries/JBConstants.sol";
-import {JBRulesetMetadataResolver} from "../src/libraries/JBRulesetMetadataResolver.sol";
-import {JBAccountingContext} from "../src/structs/JBAccountingContext.sol";
-import {JBAfterCashOutRecordedContext} from "../src/structs/JBAfterCashOutRecordedContext.sol";
-import {JBCashOutHookSpecification} from "../src/structs/JBCashOutHookSpecification.sol";
-import {JBFundAccessLimitGroup} from "../src/structs/JBFundAccessLimitGroup.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";
-import {JBTokenAmount} from "../src/structs/JBTokenAmount.sol";
-import {mulDiv} from "@prb/math/src/Common.sol";
-import {mul as UD60x18mul, unwrap as UD60x18unwrap, wrap as UD60x18wrap} from "@prb/math/src/UD60x18.sol";
-
-contract TestCashOutHooks_Local is TestBaseWorkflow {
-    using JBRulesetMetadataResolver for JBRuleset;
-
-    uint112 private constant _WEIGHT = 1000 * 10 ** 18;
-    address private constant _DATA_HOOK = address(bytes20(keccak256("datahook")));
-
-    IJBController private _controller;
-    IJBMultiTerminal private _terminal;
-    IJBTokens private _tokens;
-    address private _projectOwner;
-    address private _beneficiary;
-
-    uint64 _projectId;
-
-    function setUp() public override {
-        super.setUp();
-
-        vm.label(_DATA_HOOK, "Data Hook");
-
-        _controller = jbController();
-        _projectOwner = multisig();
-        _beneficiary = beneficiary();
-        _terminal = jbMultiTerminal();
-        _tokens = jbTokens();
-
-        JBRulesetMetadata memory _metadata = JBRulesetMetadata({
-            reservedPercent: 0,
-            cashOutTaxRate: 0,
-            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: true,
-            dataHook: _DATA_HOOK,
-            metadata: 0
-        });
-
-        // Package up ruleset configuration.
-        JBRulesetConfig[] memory _rulesetConfig = new JBRulesetConfig[](1);
-        _rulesetConfig[0].mustStartAtOrAfter = 0;
-        _rulesetConfig[0].duration = 0;
-        _rulesetConfig[0].weight = _WEIGHT;
-        _rulesetConfig[0].weightCutPercent = 0;
-        _rulesetConfig[0].approvalHook = IJBRulesetApprovalHook(address(0));
-        _rulesetConfig[0].metadata = _metadata;
-        _rulesetConfig[0].splitGroups = new JBSplitGroup[](0);
-        _rulesetConfig[0].fundAccessLimitGroups = new JBFundAccessLimitGroup[](0);
-
-        JBTerminalConfig[] memory _terminalConfigurations = new JBTerminalConfig[](1);
-        JBAccountingContext[] memory _tokensToAccept = new JBAccountingContext[](1);
-        _tokensToAccept[0] = JBAccountingContext({
-            token: JBConstants.NATIVE_TOKEN, decimals: 18, currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
-        });
-        _terminalConfigurations[0] =
-            JBTerminalConfig({terminal: _terminal, accountingContextsToAccept: _tokensToAccept});
-
-        // Create a first project to collect fees.
-        _controller.launchProjectFor({
-            owner: _projectOwner,
-            projectUri: "myIPFSHash",
-            rulesetConfigurations: _rulesetConfig,
-            terminalConfigurations: _terminalConfigurations,
-            memo: ""
-        });
-
-        _projectId = uint64(
-            _controller.launchProjectFor({
-                owner: _projectOwner,
-                projectUri: "myIPFSHash",
-                rulesetConfigurations: _rulesetConfig,
-                terminalConfigurations: _terminalConfigurations,
-                memo: ""
-            })
-        );
-
-        // Issue the project's tokens.
-        vm.prank(_projectOwner);
-        IJBToken _token = _controller.deployERC20For(_projectId, "TestName", "TestSymbol", bytes32(0));
-
-        // Make sure the project's new project token is set.
-        assertEq(address(_tokens.tokenOf(_projectId)), address(_token));
-    }
-
-    function testCashOutHookWithNoFees() public {
-        // Reference and bound pay amount.
-        uint256 _nativePayAmount = 10 ether;
-        uint256 _halfPaid = 5 ether;
-
-        // Cash out hook address.
-        address _cashOutHook = makeAddr("SOFA");
-        vm.label(_cashOutHook, "Cash Out Delegate");
-
-        // Keep a reference to the current ruleset.
-        (JBRuleset memory _ruleset,) = _controller.currentRulesetOf(_projectId);
-
-        vm.deal(address(this), _nativePayAmount);
-        uint256 _beneficiaryTokensReceived = _terminal.pay{value: _nativePayAmount}({
-            projectId: _projectId,
-            amount: _nativePayAmount,
-            token: JBConstants.NATIVE_TOKEN,
-            beneficiary: address(this),
-            minReturnedTokens: 0,
-            memo: "Forge Test",
-            metadata: ""
-        });
-
-        // Make sure the beneficiary has a balance of project tokens.
-        uint256 _beneficiaryTokenBalance =
-            UD60x18unwrap(UD60x18mul(UD60x18wrap(_nativePayAmount), UD60x18wrap(_WEIGHT)));
-        assertEq(_tokens.totalBalanceOf(address(this), _projectId), _beneficiaryTokenBalance);
-        assertEq(_beneficiaryTokensReceived, _beneficiaryTokenBalance);
-
-        // Make sure the native token balance in terminal is up to date.
-        uint256 _nativeTerminalBalance = _nativePayAmount;
-        assertEq(
-            jbTerminalStore().balanceOf(address(_terminal), _projectId, JBConstants.NATIVE_TOKEN),
-            _nativeTerminalBalance
-        );
-
-        // Reference cash out hook specifications.
-        JBCashOutHookSpecification[] memory _specifications = new JBCashOutHookSpecification[](1);
-
-        _specifications[0] = JBCashOutHookSpecification({
-            hook: IJBCashOutHook(_cashOutHook), noop: false, amount: _halfPaid, metadata: ""
-        });
-
-        vm.startPrank(multisig());
-        // Set the hook as feeless.
-        _terminal.FEELESS_ADDRESSES().setFeelessAddress(_cashOutHook, true);
-        vm.stopPrank();
-
-        // Cash out context.
-        JBAfterCashOutRecordedContext memory _cashOutContext = JBAfterCashOutRecordedContext({
-            holder: address(this),
-            projectId: _projectId,
-            rulesetId: _ruleset.id,
-            cashOutCount: _beneficiaryTokenBalance / 2,
-            reclaimedAmount: JBTokenAmount({
-                token: JBConstants.NATIVE_TOKEN,
-                decimals: _terminal.accountingContextForTokenOf(_projectId, JBConstants.NATIVE_TOKEN).decimals,
-                currency: _terminal.accountingContextForTokenOf(_projectId, JBConstants.NATIVE_TOKEN).currency,
-                value: _halfPaid
-            }),
-            forwardedAmount: JBTokenAmount({
-                token: JBConstants.NATIVE_TOKEN,
-                decimals: _terminal.accountingContextForTokenOf(_projectId, JBConstants.NATIVE_TOKEN).decimals,
-                currency: _terminal.accountingContextForTokenOf(_projectId, JBConstants.NATIVE_TOKEN).currency,
-                value: _halfPaid
-            }),
-            cashOutTaxRate: 0,
-            beneficiary: payable(address(this)),
-            hookMetadata: "",
-            cashOutMetadata: ""
-        });
-
-        // Mock the hook.
-        vm.mockCall(
-            _cashOutHook,
-            abi.encodeWithSelector(IJBCashOutHook.afterCashOutRecordedWith.selector),
-            abi.encode(_cashOutContext)
-        );
-
-        // Assert that the hook gets called with the expected value.
-        vm.expectCall(
-            _cashOutHook,
-            _halfPaid,
-            abi.encodeWithSelector(IJBCashOutHook.afterCashOutRecordedWith.selector, _cashOutContext)
-        );
-
-        vm.mockCall(
-            _DATA_HOOK,
-            abi.encodeWithSelector(IJBRulesetDataHook.beforeCashOutRecordedWith.selector),
-            abi.encode(
-                _ruleset.cashOutTaxRate(),
-                _beneficiaryTokenBalance / 2,
-                _beneficiaryTokenBalance,
-                _nativePayAmount,
-                _specifications
-            )
-        );
-
-        _terminal.cashOutTokensOf({
-            holder: address(this),
-            projectId: _projectId,
-            cashOutCount: _beneficiaryTokenBalance / 2,
-            tokenToReclaim: JBConstants.NATIVE_TOKEN,
-            minTokensReclaimed: 0,
-            beneficiary: payable(address(this)),
-            metadata: new bytes(0)
-        });
-    }
-
-    function testCashOutHookWithFeesAndCustomInfo() public {
-        // Reference and bound pay amount.
-        uint256 _nativePayAmount = 10 ether;
-        uint256 _halfPaid = 5 ether;
-
-        // Cash out hook address.
-        address _cashOutHook = makeAddr("SOFA");
-        vm.label(_cashOutHook, "Cash Out Delegate");
-
-        // Keep a reference to the current ruleset.
-        (JBRuleset memory _ruleset,) = _controller.currentRulesetOf(_projectId);
-
-        vm.deal(address(this), _nativePayAmount);
-        uint256 _beneficiaryTokensReceived = _terminal.pay{value: _nativePayAmount}({
-            projectId: _projectId,
-            amount: _nativePayAmount,
-            token: JBConstants.NATIVE_TOKEN,
-            beneficiary: address(this),
-            minReturnedTokens: 0,
-            memo: "Forge Test",
-            metadata: ""
-        });
-
-        // Make sure the beneficiary has a balance of project tokens.
-        uint256 _beneficiaryTokenBalance =
-            UD60x18unwrap(UD60x18mul(UD60x18wrap(_nativePayAmount), UD60x18wrap(_WEIGHT)));
-        assertEq(_tokens.totalBalanceOf(address(this), _projectId), _beneficiaryTokenBalance);
-        assertEq(_beneficiaryTokensReceived, _beneficiaryTokenBalance);
-
-        // Make sure the native token balance in terminal is up to date.
-        uint256 _nativeTerminalBalance = _nativePayAmount;
-        assertEq(
-            jbTerminalStore().balanceOf(address(_terminal), _projectId, JBConstants.NATIVE_TOKEN),
-            _nativeTerminalBalance
-        );
-
-        // Reference cash out hook specifications.
-        JBCashOutHookSpecification[] memory _specifications = new JBCashOutHookSpecification[](1);
-
-        _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;
-        uint256 _customTotalSupply = 5 * 10 ** 18;
-
-        uint256 _forwardedAmount = _halfPaid - (_halfPaid * _terminal.FEE() / JBConstants.MAX_FEE);
-
-        uint256 _beneficiaryAmount = mulDiv(
-            mulDiv(_nativePayAmount, _customCashOutCount, _customTotalSupply),
-            (JBConstants.MAX_CASH_OUT_TAX_RATE - _customCashOutTaxRate)
-                + mulDiv(_customCashOutCount, _customCashOutTaxRate, _customTotalSupply),
-            JBConstants.MAX_CASH_OUT_TAX_RATE
-        );
-
-        _beneficiaryAmount -= mulDiv(_beneficiaryAmount, _terminal.FEE(), JBConstants.MAX_FEE);
-
-        // Cash out context.
-        JBAfterCashOutRecordedContext memory _cashOutContext = JBAfterCashOutRecordedContext({
-            holder: address(this),
-            projectId: _projectId,
-            rulesetId: _ruleset.id,
-            cashOutCount: _beneficiaryTokenBalance / 2,
-            reclaimedAmount: JBTokenAmount({
-                token: JBConstants.NATIVE_TOKEN,
-                decimals: _terminal.accountingContextForTokenOf(_projectId, JBConstants.NATIVE_TOKEN).decimals,
-                currency: _terminal.accountingContextForTokenOf(_projectId, JBConstants.NATIVE_TOKEN).currency,
-                value: _beneficiaryAmount
-            }),
-            forwardedAmount: JBTokenAmount({
-                token: JBConstants.NATIVE_TOKEN,
-                decimals: _terminal.accountingContextForTokenOf(_projectId, JBConstants.NATIVE_TOKEN).decimals,
-                currency: _terminal.accountingContextForTokenOf(_projectId, JBConstants.NATIVE_TOKEN).currency,
-                value: _forwardedAmount
-            }),
-            // forge-lint: disable-next-line(unsafe-typecast)
-            cashOutTaxRate: uint16(_customCashOutTaxRate),
-            beneficiary: payable(address(this)),
-            hookMetadata: "",
-            cashOutMetadata: ""
-        });
-
-        // Mock the hook.
-        vm.mockCall(
-            _cashOutHook,
-            abi.encodeWithSelector(IJBCashOutHook.afterCashOutRecordedWith.selector),
-            abi.encode(_cashOutContext)
-        );
-
-        // Assert that the hook gets called with the expected value.
-        vm.expectCall(
-            _cashOutHook,
-            _forwardedAmount,
-            abi.encodeWithSelector(IJBCashOutHook.afterCashOutRecordedWith.selector, _cashOutContext)
-        );
-
-        vm.mockCall(
-            _DATA_HOOK,
-            abi.encodeWithSelector(IJBRulesetDataHook.beforeCashOutRecordedWith.selector),
-            abi.encode(
-                _customCashOutTaxRate,
-                _customCashOutCount,
-                _customTotalSupply,
-                _nativeTerminalBalance, // Same as _nativePayAmount (no payouts); avoids stack depth limit.
-                _specifications
-            )
-        );
-
-        _terminal.cashOutTokensOf({
-            holder: address(this),
-            projectId: _projectId,
-            cashOutCount: _beneficiaryTokenBalance / 2,
-            tokenToReclaim: JBConstants.NATIVE_TOKEN,
-            minTokensReclaimed: 0,
-            beneficiary: payable(address(this)),
-            metadata: new bytes(0)
-        });
-    }
-
-    receive() external payable {}
-    fallback() external payable {}
-}