@bananapus/core-v6 0.0.19 → 0.0.20

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

package/test/units/static/JBMultiTerminal/TestCashOutTokensOf.sol

@@ -10,6 +10,7 @@ import {IJBController} from "../../../../src/interfaces/IJBController.sol";
 import {IJBDirectory} from "../../../../src/interfaces/IJBDirectory.sol";
 import {IJBFeelessAddresses} from "../../../../src/interfaces/IJBFeelessAddresses.sol";
 import {IJBPermissions} from "../../../../src/interfaces/IJBPermissions.sol";
+import {IJBRulesets} from "../../../../src/interfaces/IJBRulesets.sol";
 import {IJBRulesetApprovalHook} from "../../../../src/interfaces/IJBRulesetApprovalHook.sol";
 import {IJBTerminalStore} from "../../../../src/interfaces/IJBTerminalStore.sol";
 import {JBConstants} from "../../../../src/libraries/JBConstants.sol";
@@ -21,6 +22,8 @@ import {JBRuleset} from "../../../../src/structs/JBRuleset.sol";
 import {JBTokenAmount} from "../../../../src/structs/JBTokenAmount.sol";
 import {JBPermissionIds} from "@bananapus/permission-ids-v6/src/JBPermissionIds.sol";
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
 import {JBMultiTerminalSetup} from "./JBMultiTerminalSetup.sol";
 
 contract TestCashOutTokensOf_Local is JBMultiTerminalSetup {
@@ -45,6 +48,37 @@ contract TestCashOutTokensOf_Local is JBMultiTerminalSetup {
         _mockToken2 = new MockERC20("testToken", "TT");
     }
 
+    function _acceptToken(address token, uint8 decimals, uint32 currency) internal {
+        mockExpect(address(projects), abi.encodeCall(IERC721.ownerOf, (_projectId)), abi.encode(address(0)));
+        mockExpect(
+            address(directory), abi.encodeCall(IJBDirectory.controllerOf, (_projectId)), abi.encode(address(this))
+        );
+
+        if (token != JBConstants.NATIVE_TOKEN) {
+            mockExpect(token, abi.encodeCall(IERC20Metadata.decimals, ()), abi.encode(decimals));
+        }
+
+        JBAccountingContext[] memory _tokens = new JBAccountingContext[](1);
+        _tokens[0] = JBAccountingContext({token: token, decimals: decimals, currency: currency});
+
+        JBRuleset memory returnedRuleset = JBRuleset({
+            cycleNumber: 1,
+            id: 0,
+            basedOnId: 0,
+            start: 0,
+            duration: 0,
+            weight: 0,
+            weightCutPercent: 0,
+            approvalHook: IJBRulesetApprovalHook(address(0)),
+            metadata: 0
+        });
+
+        mockExpect(address(rulesets), abi.encodeCall(IJBRulesets.currentOf, (_projectId)), abi.encode(returnedRuleset));
+
+        vm.prank(address(this));
+        _terminal.addAccountingContextsFor(_projectId, _tokens);
+    }
+
     function test_WhenCallerDNHavePermission() external {
         // it will revert UNAUTHORIZED
 
@@ -72,8 +106,6 @@ contract TestCashOutTokensOf_Local is JBMultiTerminalSetup {
     }
 
     modifier whenCallerHasPermission() {
-        vm.prank(_bene);
-
         // mock call to JBPermissions hasPermission
         mockExpect(
             address(permissions),
@@ -92,8 +124,10 @@ contract TestCashOutTokensOf_Local is JBMultiTerminalSetup {
 
         uint256 reclaimAmount = 1e9;
         JBCashOutHookSpecification[] memory hookSpecifications = new JBCashOutHookSpecification[](0);
-        JBAccountingContext[] memory mockBalanceContext = new JBAccountingContext[](0);
-        JBAccountingContext memory mockTokenContext = JBAccountingContext({token: address(0), decimals: 0, currency: 0});
+        JBAccountingContext memory mockTokenContext =
+            JBAccountingContext({token: _mockToken, decimals: 18, currency: uint32(uint160(_mockToken))});
+        JBAccountingContext[] memory mockBalanceContext = new JBAccountingContext[](1);
+        mockBalanceContext[0] = mockTokenContext;
         JBRuleset memory returnedRuleset = JBRuleset({
             cycleNumber: 1,
             id: 1,
@@ -131,7 +165,9 @@ contract TestCashOutTokensOf_Local is JBMultiTerminalSetup {
 
         // put code at mockToken address to pass OZ Address check
         vm.etch(_mockToken, abi.encode(1));
+        _acceptToken(_mockToken, 18, uint32(uint160(_mockToken)));
 
+        vm.prank(_bene);
         _terminal.cashOutTokensOf(_holder, _projectId, _defaultAmount, _mockToken, _minReclaimed, _bene, "");
     }
 
@@ -140,8 +176,10 @@ contract TestCashOutTokensOf_Local is JBMultiTerminalSetup {
 
         uint256 reclaimAmount = 1e9;
         JBCashOutHookSpecification[] memory hookSpecifications = new JBCashOutHookSpecification[](0);
-        JBAccountingContext[] memory mockBalanceContext = new JBAccountingContext[](0);
-        JBAccountingContext memory mockTokenContext = JBAccountingContext({token: address(0), decimals: 0, currency: 0});
+        JBAccountingContext memory mockTokenContext =
+            JBAccountingContext({token: _mockToken, decimals: 18, currency: uint32(uint160(_mockToken))});
+        JBAccountingContext[] memory mockBalanceContext = new JBAccountingContext[](1);
+        mockBalanceContext[0] = mockTokenContext;
         JBRuleset memory returnedRuleset = JBRuleset({
             cycleNumber: 1,
             id: 1,
@@ -179,10 +217,14 @@ contract TestCashOutTokensOf_Local is JBMultiTerminalSetup {
 
         // put code at mockToken address to pass OZ Address check
         vm.etch(_mockToken, abi.encode(1));
+        _acceptToken(_mockToken, 18, uint32(uint160(_mockToken)));
 
         vm.expectRevert(
-            abi.encodeWithSelector(JBMultiTerminal.JBMultiTerminal_UnderMinTokensReclaimed.selector, 1e9, 1e18)
+            abi.encodeWithSelector(
+                JBMultiTerminal.JBMultiTerminal_UnderMinTokensReclaimed.selector, reclaimAmount, 1e18
+            )
         );
+        vm.prank(_bene);
         _terminal.cashOutTokensOf(_holder, _projectId, _defaultAmount, _mockToken, 1e18, _bene, ""); // minReclaimAmount
         // = 1e18 but only 1e9 reclaimed
     }
@@ -195,8 +237,10 @@ contract TestCashOutTokensOf_Local is JBMultiTerminalSetup {
 
         uint256 reclaimAmount = 1e9;
         JBCashOutHookSpecification[] memory hookSpecifications = new JBCashOutHookSpecification[](0);
-        JBAccountingContext[] memory mockBalanceContext = new JBAccountingContext[](0);
-        JBAccountingContext memory mockTokenContext = JBAccountingContext({token: address(0), decimals: 0, currency: 0});
+        JBAccountingContext memory mockTokenContext =
+            JBAccountingContext({token: _mockToken, decimals: 18, currency: uint32(uint160(_mockToken))});
+        JBAccountingContext[] memory mockBalanceContext = new JBAccountingContext[](1);
+        mockBalanceContext[0] = mockTokenContext;
         JBRuleset memory returnedRuleset = JBRuleset({
             cycleNumber: 1,
             id: 1,
@@ -234,6 +278,7 @@ contract TestCashOutTokensOf_Local is JBMultiTerminalSetup {
 
         // put code at mockToken address to pass OZ Address check
         vm.etch(_mockToken, abi.encode(1));
+        _acceptToken(_mockToken, 18, uint32(uint160(_mockToken)));
 
         // get fee amount
         uint256 tax = JBFees.feeAmountFrom(reclaimAmount, 25); // 25 = default fee)
@@ -256,6 +301,7 @@ contract TestCashOutTokensOf_Local is JBMultiTerminalSetup {
             ""
         );
 
+        vm.prank(_bene);
         _terminal.cashOutTokensOf(_holder, _projectId, _defaultAmount, _mockToken, _minReclaimed, _bene, "");
     }
 
@@ -306,9 +352,13 @@ contract TestCashOutTokensOf_Local is JBMultiTerminalSetup {
 
         uint256 reclaimAmount = 1e9;
         JBCashOutHookSpecification[] memory hookSpecifications = new JBCashOutHookSpecification[](1);
-        hookSpecifications[0] = JBCashOutHookSpecification({hook: _mockHook, amount: _defaultAmount, metadata: ""});
-        JBAccountingContext[] memory mockBalanceContext = new JBAccountingContext[](0);
-        JBAccountingContext memory mockTokenContext = JBAccountingContext({token: address(0), decimals: 0, currency: 0});
+        hookSpecifications[0] =
+            JBCashOutHookSpecification({hook: _mockHook, noop: false, amount: _defaultAmount, metadata: ""});
+        JBAccountingContext memory mockTokenContext = JBAccountingContext({
+            token: address(_mockToken2), decimals: 18, currency: uint32(uint160(address(_mockToken2)))
+        });
+        JBAccountingContext[] memory mockBalanceContext = new JBAccountingContext[](1);
+        mockBalanceContext[0] = mockTokenContext;
         JBRuleset memory returnedRuleset = JBRuleset({
             cycleNumber: 1,
             id: 1,
@@ -349,10 +399,18 @@ contract TestCashOutTokensOf_Local is JBMultiTerminalSetup {
             abi.encode(true)
         );
 
-        JBTokenAmount memory reclaimedAmount =
-            JBTokenAmount({token: address(_mockToken2), decimals: 0, currency: 0, value: reclaimAmount});
-        JBTokenAmount memory forwardedAmount =
-            JBTokenAmount({token: address(_mockToken2), decimals: 0, currency: 0, value: _defaultAmount});
+        JBTokenAmount memory reclaimedAmount = JBTokenAmount({
+            token: address(_mockToken2),
+            decimals: 18,
+            currency: uint32(uint160(address(_mockToken2))),
+            value: reclaimAmount
+        });
+        JBTokenAmount memory forwardedAmount = JBTokenAmount({
+            token: address(_mockToken2),
+            decimals: 18,
+            currency: uint32(uint160(address(_mockToken2))),
+            value: _defaultAmount
+        });
 
         // needed for hook call
         JBAfterCashOutRecordedContext memory context = JBAfterCashOutRecordedContext({
@@ -373,6 +431,8 @@ contract TestCashOutTokensOf_Local is JBMultiTerminalSetup {
         // ensure approval is increased
         vm.expectCall(address(_mockToken2), abi.encodeCall(IERC20.approve, (address(_mockHook), _defaultAmount * 2)));
 
+        _acceptToken(address(_mockToken2), 18, uint32(uint160(address(_mockToken2))));
+
         vm.expectEmit();
         emit IJBCashOutTerminal.HookAfterRecordCashOut(_mockHook, context, _defaultAmount, 0, address(_bene));
 
@@ -409,9 +469,13 @@ contract TestCashOutTokensOf_Local is JBMultiTerminalSetup {
         uint256 reclaimAmount = 1e9;
         JBCashOutHookSpecification[] memory hookSpecifications = new JBCashOutHookSpecification[](1);
         JBCashOutHookSpecification[] memory paySpecs = new JBCashOutHookSpecification[](0);
-        hookSpecifications[0] = JBCashOutHookSpecification({hook: _mockHook, amount: _defaultAmount, metadata: ""});
-        JBAccountingContext[] memory mockBalanceContext = new JBAccountingContext[](0);
-        JBAccountingContext memory mockTokenContext = JBAccountingContext({token: address(0), decimals: 0, currency: 0});
+        hookSpecifications[0] =
+            JBCashOutHookSpecification({hook: _mockHook, noop: false, amount: _defaultAmount, metadata: ""});
+        JBAccountingContext memory mockTokenContext = JBAccountingContext({
+            token: address(_mockToken2), decimals: 18, currency: uint32(uint160(address(_mockToken2)))
+        });
+        JBAccountingContext[] memory mockBalanceContext = new JBAccountingContext[](1);
+        mockBalanceContext[0] = mockTokenContext;
         JBRuleset memory returnedRuleset = JBRuleset({
             cycleNumber: 1,
             id: 1,
@@ -455,12 +519,21 @@ contract TestCashOutTokensOf_Local is JBMultiTerminalSetup {
         uint256 hookTax = JBFees.feeAmountFrom(_defaultAmount, 25);
         uint256 passedAfterTax = _defaultAmount - hookTax;
 
-        JBTokenAmount memory reclaimedAmount =
-            JBTokenAmount({token: address(_mockToken2), decimals: 0, currency: 0, value: reclaimAmount});
-        JBTokenAmount memory forwardedAmount =
-            JBTokenAmount({token: address(_mockToken2), decimals: 0, currency: 0, value: passedAfterTax});
-        JBTokenAmount memory feeRepayAmount =
-            JBTokenAmount({token: address(_mockToken2), decimals: 0, currency: 0, value: hookTax});
+        JBTokenAmount memory reclaimedAmount = JBTokenAmount({
+            token: address(_mockToken2),
+            decimals: 18,
+            currency: uint32(uint160(address(_mockToken2))),
+            value: reclaimAmount
+        });
+        JBTokenAmount memory forwardedAmount = JBTokenAmount({
+            token: address(_mockToken2),
+            decimals: 18,
+            currency: uint32(uint160(address(_mockToken2))),
+            value: passedAfterTax
+        });
+        JBTokenAmount memory feeRepayAmount = JBTokenAmount({
+            token: address(_mockToken2), decimals: 18, currency: uint32(uint160(address(_mockToken2))), value: hookTax
+        });
 
         // needed for hook call
         JBAfterCashOutRecordedContext memory context = JBAfterCashOutRecordedContext({
@@ -494,10 +567,56 @@ contract TestCashOutTokensOf_Local is JBMultiTerminalSetup {
             ),
             abi.encode(returnedRuleset, 0, paySpecs)
         );
+
+        _acceptToken(address(_mockToken2), 18, uint32(uint160(address(_mockToken2))));
+
         vm.expectEmit();
         emit IJBCashOutTerminal.HookAfterRecordCashOut(_mockHook, context, passedAfterTax, hookTax, address(_bene));
 
         vm.prank(_bene);
         _terminal.cashOutTokensOf(_holder, _projectId, _defaultAmount, address(_mockToken2), _minReclaimed, _bene, "");
     }
+
+    function test_GivenTheCashOutHookSpecIsNoop() external whenCallerHasPermission {
+        uint256 reclaimAmount = 1e9;
+        JBCashOutHookSpecification[] memory hookSpecifications = new JBCashOutHookSpecification[](1);
+        hookSpecifications[0] =
+            JBCashOutHookSpecification({hook: IJBCashOutHook(address(this)), noop: true, amount: 0, metadata: "info"});
+        JBAccountingContext memory mockTokenContext =
+            JBAccountingContext({token: _mockToken, decimals: 18, currency: uint32(uint160(_mockToken))});
+        JBAccountingContext[] memory mockBalanceContext = new JBAccountingContext[](1);
+        mockBalanceContext[0] = mockTokenContext;
+        JBRuleset memory returnedRuleset = JBRuleset({
+            cycleNumber: 1,
+            id: 1,
+            basedOnId: 0,
+            start: 0,
+            duration: 0,
+            weight: 0,
+            weightCutPercent: 0,
+            approvalHook: IJBRulesetApprovalHook(address(0)),
+            metadata: 0
+        });
+
+        mockExpect(address(feelessAddresses), abi.encodeCall(IJBFeelessAddresses.isFeeless, (_bene)), abi.encode(true));
+        mockExpect(
+            address(store),
+            abi.encodeCall(
+                IJBTerminalStore.recordCashOutFor,
+                (_holder, _projectId, _defaultAmount, mockTokenContext, mockBalanceContext, true, "")
+            ),
+            abi.encode(returnedRuleset, reclaimAmount, _maxCashOutTaxRate, hookSpecifications)
+        );
+        mockExpect(
+            address(directory), abi.encodeCall(IJBDirectory.controllerOf, (_projectId)), abi.encode(address(this))
+        );
+        mockExpect(
+            address(this), abi.encodeCall(IJBController.burnTokensOf, (_holder, _projectId, _defaultAmount, "")), ""
+        );
+
+        _acceptToken(_mockToken, 18, uint32(uint160(_mockToken)));
+
+        vm.prank(_bene);
+        _terminal.cashOutTokensOf(_holder, _projectId, _defaultAmount, _mockToken, _minReclaimed, _bene, "");
+    }
 }

package/test/units/static/JBMultiTerminal/TestExecutePayout.sol

@@ -32,6 +32,7 @@ contract TestExecutePayout_Local is JBMultiTerminalSetup {
 
     address _native = JBConstants.NATIVE_TOKEN;
     address _usdc = makeAddr("USDC");
+    uint32 _usdcCurrency = uint32(uint160(_usdc));
 
     JBSplit private _split;
     JBSplit private _emptySplit;
@@ -40,6 +41,13 @@ contract TestExecutePayout_Local is JBMultiTerminalSetup {
         super.multiTerminalSetup();
     }
 
+    function _setAccountingContext(uint256 projectId, address token, uint8 decimals, uint32 currency) internal {
+        bytes32 contextSlot = keccak256(abi.encode(projectId, uint256(0)));
+        bytes32 slot = keccak256(abi.encode(token, contextSlot));
+        bytes32 packed = bytes32(uint256(uint160(token)) | (uint256(decimals) << 160) | (uint256(currency) << 168));
+        vm.store(address(_terminal), slot, packed);
+    }
+
     modifier whenASplitHookIsConfigured() {
         _split = JBSplit({
             preferAddToBalance: false,
@@ -342,6 +350,8 @@ contract TestExecutePayout_Local is JBMultiTerminalSetup {
     function test_GivenPreferAddToBalanceDNEQTrueAndTerminalEQThisAddress() external {
         // it will call internal _pay
 
+        _setAccountingContext(_projectId, _usdc, 0, _usdcCurrency);
+
         // mock call to directory primaryTerminalOf
         mockExpect(
             address(directory),
@@ -360,7 +370,7 @@ contract TestExecutePayout_Local is JBMultiTerminalSetup {
 
         // needed for next mock call returns
         JBTokenAmount memory tokenAmount =
-            JBTokenAmount({token: _usdc, decimals: 0, currency: 0, value: _defaultAmount});
+            JBTokenAmount({token: _usdc, decimals: 0, currency: _usdcCurrency, value: _defaultAmount});
         JBPayHookSpecification[] memory hookSpecifications = new JBPayHookSpecification[](0);
         JBRuleset memory returnedRuleset = JBRuleset({
             cycleNumber: 1,

package/test/units/static/JBMultiTerminal/TestExecuteProcessFee.sol

@@ -6,6 +6,7 @@ import {IJBRulesetApprovalHook} from "../../../../src/interfaces/IJBRulesetAppro
 import {IJBTerminal} from "../../../../src/interfaces/IJBTerminal.sol";
 import {IJBTerminalStore} from "../../../../src/interfaces/IJBTerminalStore.sol";
 import {JBConstants} from "../../../../src/libraries/JBConstants.sol";
+import {JBAccountingContext} from "../../../../src/structs/JBAccountingContext.sol";
 import {JBPayHookSpecification} from "../../../../src/structs/JBPayHookSpecification.sol";
 import {JBRuleset} from "../../../../src/structs/JBRuleset.sol";
 import {JBTokenAmount} from "../../../../src/structs/JBTokenAmount.sol";
@@ -26,6 +27,14 @@ contract TestExecuteProcessFee_Local is JBMultiTerminalSetup {
         super.multiTerminalSetup();
     }
 
+    function _setAccountingContext(address token, uint8 decimals, uint32 currency) internal {
+        bytes32 contextSlot = keccak256(abi.encode(_projectId, uint256(0)));
+        bytes32 slot = keccak256(abi.encode(token, contextSlot));
+
+        bytes32 packed = bytes32(uint256(uint160(token)) | (uint256(decimals) << 160) | (uint256(currency) << 168));
+        vm.store(address(_terminal), slot, packed);
+    }
+
     function test_WhenCallerIsNotItself() external {
         // it will revert
 
@@ -87,9 +96,11 @@ contract TestExecuteProcessFee_Local is JBMultiTerminalSetup {
     function test_WhenFeeTerminalEQItself() external {
         // it will call internal _pay
 
+        _setAccountingContext(_native, 0, 1);
+
         // needed for next mock call returns
         JBTokenAmount memory tokenAmount =
-            JBTokenAmount({token: _native, decimals: 0, currency: 0, value: _defaultAmount});
+            JBTokenAmount({token: _native, decimals: 0, currency: 1, value: _defaultAmount});
         JBPayHookSpecification[] memory hookSpecifications = new JBPayHookSpecification[](0);
         JBRuleset memory returnedRuleset = JBRuleset({
             cycleNumber: 1,
@@ -151,9 +162,11 @@ contract TestExecuteProcessFee_Local is JBMultiTerminalSetup {
     function test_GivenTokenDNEQNATIVE_TOKENAndPayingItself() external {
         // it will call external pay with zero msgvalue
 
+        _setAccountingContext(_usdc, 0, 1);
+
         // needed for next mock call returns
         JBTokenAmount memory tokenAmount =
-            JBTokenAmount({token: _usdc, decimals: 0, currency: 0, value: _defaultAmount});
+            JBTokenAmount({token: _usdc, decimals: 0, currency: 1, value: _defaultAmount});
         JBPayHookSpecification[] memory hookSpecifications = new JBPayHookSpecification[](0);
         JBRuleset memory returnedRuleset = JBRuleset({
             cycleNumber: 1,