@bananapus/core-v6 0.0.21 → 0.0.23

package/test/units/static/JBTerminalStore/TestCurrentReclaimableSurplusOf.sol

@@ -37,31 +37,26 @@ contract TestCurrentReclaimableSurplusOf_Local is JBTerminalStoreSetup {
         super.terminalStoreSetup();
     }
 
-    modifier whenProjectHasBalance() {
-        // Find the storage slot
+    /// @notice Helper to register an accounting context with the store (pranks as the terminal).
+    function _registerContext(JBAccountingContext memory ctx) internal {
+        JBAccountingContext[] memory ctxs = new JBAccountingContext[](1);
+        ctxs[0] = ctx;
+        vm.prank(address(_terminal));
+        _store.recordAccountingContextOf(_projectId, ctxs);
+    }
+
+    /// @notice Helper to set balance for the terminal/project/token via vm.store.
+    function _setBalance(uint256 balance) internal {
         bytes32 balanceOfSlot = keccak256(abi.encode(address(_terminal), uint256(0)));
         bytes32 projectSlot = keccak256(abi.encode(_projectId, uint256(balanceOfSlot)));
         bytes32 slot = keccak256(abi.encode(address(_token), uint256(projectSlot)));
-
-        bytes32 balanceBytes = bytes32(_balance);
-
-        // Set balance
-        vm.store(address(_store), slot, balanceBytes);
-
-        // Ensure balance is set correctly
-        uint256 _balanceCallReturn = _store.balanceOf(address(_terminal), _projectId, address(_token));
-        assertEq(_balanceCallReturn, _balance);
-        _;
+        vm.store(address(_store), slot, bytes32(balance));
     }
 
-    function test_GivenCurrentSurplusEqZero() external {
-        // it will return zero
-
-        // setup calldata
-        JBAccountingContext[] memory _contexts = new JBAccountingContext[](1);
-        _contexts[0] = JBAccountingContext({token: address(_token), decimals: 18, currency: _currency});
-
-        // JBRulesets return calldata
+    /// @notice Helper to set up common mocks for surplus computation.
+    /// @param packedMetadata The packed ruleset metadata.
+    /// @param payoutLimits The payout limits to mock.
+    function _mockSurplusInfra(uint256 packedMetadata, JBCurrencyAmount[] memory payoutLimits) internal {
         JBRuleset memory _returnedRuleset = JBRuleset({
             cycleNumber: uint48(block.timestamp),
             id: uint48(block.timestamp),
@@ -71,32 +66,45 @@ contract TestCurrentReclaimableSurplusOf_Local is JBTerminalStoreSetup {
             weight: 1e18,
             weightCutPercent: 0,
             approvalHook: IJBRulesetApprovalHook(address(0)),
-            metadata: 0
+            metadata: packedMetadata
         });
 
-        // mock call to JBRulesets currentOf
         mockExpect(address(rulesets), abi.encodeCall(IJBRulesets.currentOf, (_projectId)), abi.encode(_returnedRuleset));
-
-        // mock current surplus as zero
+        mockExpect(address(directory), abi.encodeCall(IJBDirectory.controllerOf, (_projectId)), abi.encode(_controller));
         mockExpect(
-            address(_terminal),
-            abi.encodeCall(IJBTerminal.currentSurplusOf, (_projectId, _contexts, 18, _currency)),
-            abi.encode(0)
+            address(_controller), abi.encodeCall(IJBController.FUND_ACCESS_LIMITS, ()), abi.encode(_accessLimits)
         );
+        mockExpect(
+            address(_accessLimits),
+            abi.encodeCall(
+                IJBFundAccessLimits.payoutLimitsOf, (_projectId, block.timestamp, address(_terminal), address(_token))
+            ),
+            abi.encode(payoutLimits)
+        );
+    }
+
+    function test_GivenCurrentSurplusEqZero() external {
+        // it will return zero
+
+        // Register accounting context so the store can resolve it.
+        _registerContext(JBAccountingContext({token: address(_token), decimals: 18, currency: _currency}));
+
+        // No balance set — surplus is 0.
+        JBCurrencyAmount[] memory _emptyLimits = new JBCurrencyAmount[](0);
+        _mockSurplusInfra(0, _emptyLimits);
 
         IJBTerminal[] memory _terminals = new IJBTerminal[](1);
         _terminals[0] = _terminal;
         uint256 reclaimable =
-            _store.currentReclaimableSurplusOf(_projectId, _tokenCount, _terminals, _contexts, 18, _currency);
+            _store.currentReclaimableSurplusOf(_projectId, _tokenCount, _terminals, new address[](0), 18, _currency);
         assertEq(0, reclaimable);
     }
 
-    function test_GivenCurrentSurplusGtZero() external whenProjectHasBalance {
+    function test_GivenCurrentSurplusGtZero() external {
         // it will get the number of outstanding tokens and return the reclaimable surplus
 
-        // setup calldata
-        JBAccountingContext[] memory _contexts = new JBAccountingContext[](1);
-        _contexts[0] = JBAccountingContext({token: address(_token), decimals: 18, currency: _currency});
+        // Register accounting context.
+        _registerContext(JBAccountingContext({token: address(_token), decimals: 18, currency: _currency}));
 
         JBRulesetMetadata memory _metadata = JBRulesetMetadata({
             reservedPercent: 0,
@@ -122,36 +130,18 @@ contract TestCurrentReclaimableSurplusOf_Local is JBTerminalStoreSetup {
 
         uint256 _packedMetadata = JBRulesetMetadataResolver.packRulesetMetadata(_metadata);
 
-        // JBRulesets return calldata
-        JBRuleset memory _returnedRuleset = JBRuleset({
-            cycleNumber: uint48(block.timestamp),
-            id: uint48(block.timestamp),
-            basedOnId: 0,
-            start: uint48(block.timestamp),
-            duration: uint32(block.timestamp + 1000),
-            weight: 1e18,
-            weightCutPercent: 0,
-            approvalHook: IJBRulesetApprovalHook(address(0)),
-            metadata: _packedMetadata
-        });
-
-        // mock call to JBRulesets currentOf
-        mockExpect(address(rulesets), abi.encodeCall(IJBRulesets.currentOf, (_projectId)), abi.encode(_returnedRuleset));
-
-        // mock call to JBDirectory controllerOf
-        mockExpect(address(directory), abi.encodeCall(IJBDirectory.controllerOf, (_projectId)), abi.encode(_controller));
-
-        // "mock" payout amount since the currentSurplusOf call is mocked
         uint224 _payout = 1e17;
         uint256 _supply = 1e19;
         uint256 _cashoutAmount = 1e18;
+        uint256 _surplus = _supply - _payout;
 
-        // surplus call to the terminal
-        mockExpect(
-            address(_terminal),
-            abi.encodeCall(IJBTerminal.currentSurplusOf, (_projectId, _contexts, 18, _currency)),
-            abi.encode(_supply - _payout)
-        );
+        // Set balance = surplus + payout limit to get the desired surplus after deducting limits.
+        // balance - payoutLimit = surplus => balance = surplus + payoutLimit
+        // But we want surplus = _supply - _payout = 9.9e18. So set balance = surplus (with zero limits).
+        _setBalance(_surplus);
+
+        JBCurrencyAmount[] memory _emptyLimits = new JBCurrencyAmount[](0);
+        _mockSurplusInfra(_packedMetadata, _emptyLimits);
 
         // mock JBController totalTokenSupplyWithReservedTokensOf
         mockExpect(
@@ -163,21 +153,20 @@ contract TestCurrentReclaimableSurplusOf_Local is JBTerminalStoreSetup {
         IJBTerminal[] memory _terminals = new IJBTerminal[](1);
         _terminals[0] = _terminal;
         uint256 reclaimable =
-            _store.currentReclaimableSurplusOf(_projectId, _cashoutAmount, _terminals, _contexts, 18, _currency);
+            _store.currentReclaimableSurplusOf(_projectId, _cashoutAmount, _terminals, new address[](0), 18, _currency);
 
         // The above call should be calculating the reclaimable amount as we are here, so they will be congruent.
         uint256 assumed =
-            JBCashOuts.cashOutFrom(_supply - _payout, _cashoutAmount, _supply, JBConstants.MAX_CASH_OUT_TAX_RATE / 2);
+            JBCashOuts.cashOutFrom(_surplus, _cashoutAmount, _supply, JBConstants.MAX_CASH_OUT_TAX_RATE / 2);
 
         assertEq(assumed, reclaimable);
     }
 
-    function test_GivenTokenCountIsEqToTotalSupply() external whenProjectHasBalance {
+    function test_GivenTokenCountIsEqToTotalSupply() external {
         // it will return the rest of the surplus
 
-        // setup calldata
-        JBAccountingContext[] memory _contexts = new JBAccountingContext[](1);
-        _contexts[0] = JBAccountingContext({token: address(_token), decimals: 18, currency: _currency});
+        // Register accounting context.
+        _registerContext(JBAccountingContext({token: address(_token), decimals: 18, currency: _currency}));
 
         JBRulesetMetadata memory _metadata = JBRulesetMetadata({
             reservedPercent: 0,
@@ -203,53 +192,34 @@ contract TestCurrentReclaimableSurplusOf_Local is JBTerminalStoreSetup {
 
         uint256 _packedMetadata = JBRulesetMetadataResolver.packRulesetMetadata(_metadata);
 
-        // JBRulesets return calldata
-        JBRuleset memory _returnedRuleset = JBRuleset({
-            cycleNumber: uint48(block.timestamp),
-            id: uint48(block.timestamp),
-            basedOnId: 0,
-            start: uint48(block.timestamp),
-            duration: uint32(block.timestamp + 1000),
-            weight: 1e18,
-            weightCutPercent: 0,
-            approvalHook: IJBRulesetApprovalHook(address(0)),
-            metadata: _packedMetadata
-        });
-
-        // mock call to JBRulesets currentOf
-        mockExpect(address(rulesets), abi.encodeCall(IJBRulesets.currentOf, (_projectId)), abi.encode(_returnedRuleset));
+        // Set balance = tokenCount so surplus = tokenCount (with zero payout limits).
+        _setBalance(_tokenCount);
 
-        // mock call to JBDirectory controllerOf
-        mockExpect(address(directory), abi.encodeCall(IJBDirectory.controllerOf, (_projectId)), abi.encode(_controller));
+        JBCurrencyAmount[] memory _emptyLimits = new JBCurrencyAmount[](0);
+        _mockSurplusInfra(_packedMetadata, _emptyLimits);
 
-        // mock call to get cumulative surplus
+        // mock JBController totalTokenSupplyWithReservedTokensOf
         mockExpect(
-            address(_terminal),
-            abi.encodeCall(IJBTerminal.currentSurplusOf, (_projectId, _contexts, 18, _currency)),
+            address(_controller),
+            abi.encodeCall(IJBController.totalTokenSupplyWithReservedTokensOf, (_projectId)),
             abi.encode(_tokenCount)
         );
 
-        // mock JBController totalTokenSupplyWithReservedTokensOf
-        bytes memory _totalTokenCall = abi.encodeCall(IJBController.totalTokenSupplyWithReservedTokensOf, (_projectId));
-        bytes memory _tokenTotal = abi.encode(_tokenCount);
-        mockExpect(address(_controller), _totalTokenCall, _tokenTotal);
-
         IJBTerminal[] memory _terminals = new IJBTerminal[](1);
         _terminals[0] = _terminal;
         uint256 reclaimable =
-            _store.currentReclaimableSurplusOf(_projectId, _tokenCount, _terminals, _contexts, 18, _currency);
+            _store.currentReclaimableSurplusOf(_projectId, _tokenCount, _terminals, new address[](0), 18, _currency);
 
         // The tokenCount is equal to the total supply, so the reclaimable amount will be the same as the supply. We
         // couldn't reclaim more.
         assertEq(_tokenCount, reclaimable);
     }
 
-    function test_GivenCashOutTaxRateEqZero() external whenProjectHasBalance {
-        // it will return zero
+    function test_GivenCashOutTaxRateEqZero() external {
+        // it will return zero (cashOutTaxRate = MAX means no surplus can be reclaimed)
 
-        // setup calldata
-        JBAccountingContext[] memory _contexts = new JBAccountingContext[](1);
-        _contexts[0] = JBAccountingContext({token: address(_token), decimals: 18, currency: _currency});
+        // Register accounting context.
+        _registerContext(JBAccountingContext({token: address(_token), decimals: 18, currency: _currency}));
 
         JBRulesetMetadata memory _metadata = JBRulesetMetadata({
             reservedPercent: 0,
@@ -275,55 +245,33 @@ contract TestCurrentReclaimableSurplusOf_Local is JBTerminalStoreSetup {
 
         uint256 _packedMetadata = JBRulesetMetadataResolver.packRulesetMetadata(_metadata);
 
-        // JBRulesets return calldata
-        JBRuleset memory _returnedRuleset = JBRuleset({
-            cycleNumber: uint48(block.timestamp),
-            id: uint48(block.timestamp),
-            basedOnId: 0,
-            start: uint48(block.timestamp),
-            duration: uint32(block.timestamp + 1000),
-            weight: 1e18,
-            weightCutPercent: 0,
-            approvalHook: IJBRulesetApprovalHook(address(0)),
-            metadata: _packedMetadata
-        });
+        // Set balance = 1e18 so surplus = 1e18 (with zero payout limits).
+        _setBalance(1e18);
 
-        // mock call to JBRulesets currentOf
-        mockExpect(address(rulesets), abi.encodeCall(IJBRulesets.currentOf, (_projectId)), abi.encode(_returnedRuleset));
-
-        // mock call to JBDirectory controllerOf
-        mockExpect(address(directory), abi.encodeCall(IJBDirectory.controllerOf, (_projectId)), abi.encode(_controller));
-
-        JBCurrencyAmount[] memory _limits = new JBCurrencyAmount[](1);
-        _limits[0] = JBCurrencyAmount({amount: 0, currency: _currency});
+        JBCurrencyAmount[] memory _emptyLimits = new JBCurrencyAmount[](0);
+        _mockSurplusInfra(_packedMetadata, _emptyLimits);
 
         // mock JBController totalTokenSupplyWithReservedTokensOf
-        bytes memory _totalTokenCall = abi.encodeCall(IJBController.totalTokenSupplyWithReservedTokensOf, (_projectId));
-        bytes memory _tokenTotal = abi.encode(1e18);
-        mockExpect(address(_controller), _totalTokenCall, _tokenTotal);
-
-        // mock current surplus
         mockExpect(
-            address(_terminal),
-            abi.encodeCall(IJBTerminal.currentSurplusOf, (_projectId, _contexts, 18, _currency)),
+            address(_controller),
+            abi.encodeCall(IJBController.totalTokenSupplyWithReservedTokensOf, (_projectId)),
             abi.encode(1e18)
         );
 
         IJBTerminal[] memory _terminals = new IJBTerminal[](1);
         _terminals[0] = _terminal;
         uint256 reclaimable =
-            _store.currentReclaimableSurplusOf(_projectId, _tokenCount, _terminals, _contexts, 18, _currency);
+            _store.currentReclaimableSurplusOf(_projectId, _tokenCount, _terminals, new address[](0), 18, _currency);
 
         // No surplus can be reclaimed.
         assertEq(0, reclaimable);
     }
 
-    function test_GivenCashOutRateDneqMAX_CASH_OUT_RATE() external whenProjectHasBalance {
+    function test_GivenCashOutRateDneqMAX_CASH_OUT_RATE() external {
         // it will return the calculated proportion
 
-        // setup calldata
-        JBAccountingContext[] memory _contexts = new JBAccountingContext[](1);
-        _contexts[0] = JBAccountingContext({token: address(_token), decimals: 18, currency: _currency});
+        // Register accounting context.
+        _registerContext(JBAccountingContext({token: address(_token), decimals: 18, currency: _currency}));
 
         JBRulesetMetadata memory _metadata = JBRulesetMetadata({
             reservedPercent: 0,
@@ -349,43 +297,26 @@ contract TestCurrentReclaimableSurplusOf_Local is JBTerminalStoreSetup {
 
         uint256 _packedMetadata = JBRulesetMetadataResolver.packRulesetMetadata(_metadata);
 
-        // JBRulesets return calldata
-        JBRuleset memory _returnedRuleset = JBRuleset({
-            cycleNumber: uint48(block.timestamp),
-            id: uint48(block.timestamp),
-            basedOnId: 0,
-            start: uint48(block.timestamp),
-            duration: uint32(block.timestamp + 1000),
-            weight: 1e18,
-            weightCutPercent: 0,
-            approvalHook: IJBRulesetApprovalHook(address(0)),
-            metadata: _packedMetadata
-        });
+        // Set balance = 1e18 so surplus = 1e18 (with zero payout limits).
+        _setBalance(1e18);
 
-        // mock call to JBRulesets currentOf
-        mockExpect(address(rulesets), abi.encodeCall(IJBRulesets.currentOf, (_projectId)), abi.encode(_returnedRuleset));
+        JBCurrencyAmount[] memory _emptyLimits = new JBCurrencyAmount[](0);
+        _mockSurplusInfra(_packedMetadata, _emptyLimits);
 
-        // mock call to JBDirectory controllerOf
-        mockExpect(address(directory), abi.encodeCall(IJBDirectory.controllerOf, (_projectId)), abi.encode(_controller));
-
-        // mock current surplus
+        // mock JBController totalTokenSupplyWithReservedTokensOf
         mockExpect(
-            address(_terminal),
-            abi.encodeCall(IJBTerminal.currentSurplusOf, (_projectId, _contexts, 18, _currency)),
+            address(_controller),
+            abi.encodeCall(IJBController.totalTokenSupplyWithReservedTokensOf, (_projectId)),
             abi.encode(1e18)
         );
 
-        // mock JBController totalTokenSupplyWithReservedTokensOf
-        bytes memory _totalTokenCall = abi.encodeCall(IJBController.totalTokenSupplyWithReservedTokensOf, (_projectId));
-        bytes memory _tokenTotal = abi.encode(1e18);
-        mockExpect(address(_controller), _totalTokenCall, _tokenTotal);
-
         uint256 reclaimable;
         {
             IJBTerminal[] memory _terminals = new IJBTerminal[](1);
             _terminals[0] = _terminal;
-            reclaimable =
-                _store.currentReclaimableSurplusOf(_projectId, _tokenCount, _terminals, _contexts, 18, _currency);
+            reclaimable = _store.currentReclaimableSurplusOf(
+                _projectId, _tokenCount, _terminals, new address[](0), 18, _currency
+            );
         }
 
         uint256 assumed = mulDiv(
@@ -397,10 +328,11 @@ contract TestCurrentReclaimableSurplusOf_Local is JBTerminalStoreSetup {
         assertEq(assumed, reclaimable);
     }
 
-    function test_GivenNotOverloaded() external whenProjectHasBalance {
+    function test_GivenNotOverloaded() external {
         // it will get the current ruleset and proceed to return reclaimable as above
 
-        // Params
+        // This test uses the 4-param overload (projectId, cashOutCount, totalSupply, surplus)
+        // which does not go through the store's currentSurplusOf — it takes surplus directly.
         JBRulesetMetadata memory _metadata = JBRulesetMetadata({
             reservedPercent: 0,
             cashOutTaxRate: JBConstants.MAX_CASH_OUT_TAX_RATE / 2,
@@ -425,7 +357,6 @@ contract TestCurrentReclaimableSurplusOf_Local is JBTerminalStoreSetup {
 
         uint256 _packedMetadata = JBRulesetMetadataResolver.packRulesetMetadata(_metadata);
 
-        // JBRulesets return calldata
         JBRuleset memory _returnedRuleset = JBRuleset({
             cycleNumber: uint48(block.timestamp),
             id: uint48(block.timestamp),
@@ -438,19 +369,17 @@ contract TestCurrentReclaimableSurplusOf_Local is JBTerminalStoreSetup {
             metadata: _packedMetadata
         });
 
-        // mock call to JBRulesets currentOf
         mockExpect(address(rulesets), abi.encodeCall(IJBRulesets.currentOf, (_projectId)), abi.encode(_returnedRuleset));
 
         uint256 reclaimable = _store.currentReclaimableSurplusOf(_projectId, _tokenCount, 1e18, 1e18);
         assertEq(1e18, reclaimable);
     }
 
-    function test_GivenTotalReclaimableWithSurplus() external whenProjectHasBalance {
+    function test_GivenTotalReclaimableWithSurplus() external {
         // it will default to all terminals and all accounting contexts and return the reclaimable surplus
 
-        // setup calldata
-        JBAccountingContext[] memory _contexts = new JBAccountingContext[](1);
-        _contexts[0] = JBAccountingContext({token: address(_token), decimals: 18, currency: _currency});
+        // Register accounting context.
+        _registerContext(JBAccountingContext({token: address(_token), decimals: 18, currency: _currency}));
 
         JBRulesetMetadata memory _metadata = JBRulesetMetadata({
             reservedPercent: 0,
@@ -476,41 +405,20 @@ contract TestCurrentReclaimableSurplusOf_Local is JBTerminalStoreSetup {
 
         uint256 _packedMetadata = JBRulesetMetadataResolver.packRulesetMetadata(_metadata);
 
-        // JBRulesets return calldata
-        JBRuleset memory _returnedRuleset = JBRuleset({
-            cycleNumber: uint48(block.timestamp),
-            id: uint48(block.timestamp),
-            basedOnId: 0,
-            start: uint48(block.timestamp),
-            duration: uint32(block.timestamp + 1000),
-            weight: 1e18,
-            weightCutPercent: 0,
-            approvalHook: IJBRulesetApprovalHook(address(0)),
-            metadata: _packedMetadata
-        });
-
-        // mock call to JBRulesets currentOf
-        mockExpect(address(rulesets), abi.encodeCall(IJBRulesets.currentOf, (_projectId)), abi.encode(_returnedRuleset));
-
-        // mock call to JBDirectory controllerOf
-        mockExpect(address(directory), abi.encodeCall(IJBDirectory.controllerOf, (_projectId)), abi.encode(_controller));
-
         uint256 _supply = 1e19;
         uint256 _surplus = 1e18;
         uint256 _cashoutAmount = 1e18;
 
-        // mock JBDirectory terminalsOf to return the terminal
+        // Set balance = surplus (with zero payout limits, surplus = balance).
+        _setBalance(_surplus);
+
+        // Mock terminalsOf to return our terminal (for currentTotalReclaimableSurplusOf which uses empty terminals).
         IJBTerminal[] memory _terminals = new IJBTerminal[](1);
         _terminals[0] = _terminal;
         mockExpect(address(directory), abi.encodeCall(IJBDirectory.terminalsOf, (_projectId)), abi.encode(_terminals));
 
-        // surplus call to the terminal (empty accounting contexts passed through)
-        JBAccountingContext[] memory _emptyContexts = new JBAccountingContext[](0);
-        mockExpect(
-            address(_terminal),
-            abi.encodeCall(IJBTerminal.currentSurplusOf, (_projectId, _emptyContexts, 18, _currency)),
-            abi.encode(_surplus)
-        );
+        JBCurrencyAmount[] memory _emptyLimits = new JBCurrencyAmount[](0);
+        _mockSurplusInfra(_packedMetadata, _emptyLimits);
 
         // mock JBController totalTokenSupplyWithReservedTokensOf
         mockExpect(
@@ -532,44 +440,28 @@ contract TestCurrentReclaimableSurplusOf_Local is JBTerminalStoreSetup {
     function test_GivenTotalReclaimableWithZeroSurplus() external {
         // it will return zero when there is no surplus
 
-        JBAccountingContext[] memory _emptyContexts = new JBAccountingContext[](0);
+        // Register accounting context.
+        _registerContext(JBAccountingContext({token: address(_token), decimals: 18, currency: _currency}));
 
-        // JBRulesets return calldata
-        JBRuleset memory _returnedRuleset = JBRuleset({
-            cycleNumber: uint48(block.timestamp),
-            id: uint48(block.timestamp),
-            basedOnId: 0,
-            start: uint48(block.timestamp),
-            duration: uint32(block.timestamp + 1000),
-            weight: 1e18,
-            weightCutPercent: 0,
-            approvalHook: IJBRulesetApprovalHook(address(0)),
-            metadata: 0
-        });
+        // No balance set — surplus is 0.
 
-        // mock call to JBRulesets currentOf
-        mockExpect(address(rulesets), abi.encodeCall(IJBRulesets.currentOf, (_projectId)), abi.encode(_returnedRuleset));
-
-        // mock JBDirectory terminalsOf to return the terminal
+        // Mock terminalsOf to return our terminal.
         IJBTerminal[] memory _terminals = new IJBTerminal[](1);
         _terminals[0] = _terminal;
         mockExpect(address(directory), abi.encodeCall(IJBDirectory.terminalsOf, (_projectId)), abi.encode(_terminals));
 
-        // mock current surplus as zero
-        mockExpect(
-            address(_terminal),
-            abi.encodeCall(IJBTerminal.currentSurplusOf, (_projectId, _emptyContexts, 18, _currency)),
-            abi.encode(0)
-        );
+        JBCurrencyAmount[] memory _emptyLimits = new JBCurrencyAmount[](0);
+        _mockSurplusInfra(0, _emptyLimits);
 
         uint256 reclaimable = _store.currentTotalReclaimableSurplusOf(_projectId, _tokenCount, 18, _currency);
         assertEq(0, reclaimable);
     }
 
-    function test_GivenTotalReclaimableMatchesSixParamOverload() external whenProjectHasBalance {
+    function test_GivenTotalReclaimableMatchesSixParamOverload() external {
         // it will produce the same result as calling the 6-param overload with empty arrays
 
-        JBAccountingContext[] memory _emptyContexts = new JBAccountingContext[](0);
+        // Register accounting context.
+        _registerContext(JBAccountingContext({token: address(_token), decimals: 18, currency: _currency}));
 
         JBRulesetMetadata memory _metadata = JBRulesetMetadata({
             reservedPercent: 0,
@@ -595,38 +487,24 @@ contract TestCurrentReclaimableSurplusOf_Local is JBTerminalStoreSetup {
 
         uint256 _packedMetadata = JBRulesetMetadataResolver.packRulesetMetadata(_metadata);
 
-        JBRuleset memory _returnedRuleset = JBRuleset({
-            cycleNumber: uint48(block.timestamp),
-            id: uint48(block.timestamp),
-            basedOnId: 0,
-            start: uint48(block.timestamp),
-            duration: uint32(block.timestamp + 1000),
-            weight: 1e18,
-            weightCutPercent: 0,
-            approvalHook: IJBRulesetApprovalHook(address(0)),
-            metadata: _packedMetadata
-        });
-
         uint256 _supply = 1e19;
         uint256 _surplus = 5e17;
         uint256 _cashoutAmount = 1e18;
 
+        // Set balance = surplus (with zero payout limits).
+        _setBalance(_surplus);
+
         IJBTerminal[] memory _terminals = new IJBTerminal[](1);
         _terminals[0] = _terminal;
 
-        // The new overload calls the 6-param via `this`, so JBRulesets.currentOf gets called twice.
-        // Mock it to return the same ruleset both times.
-        mockExpect(address(rulesets), abi.encodeCall(IJBRulesets.currentOf, (_projectId)), abi.encode(_returnedRuleset));
+        JBCurrencyAmount[] memory _emptyLimits = new JBCurrencyAmount[](0);
 
-        mockExpect(address(directory), abi.encodeCall(IJBDirectory.controllerOf, (_projectId)), abi.encode(_controller));
+        // --- Call 1: currentTotalReclaimableSurplusOf (uses empty terminals -> resolves from directory) ---
 
+        // Mock terminalsOf for the total reclaimable call.
         mockExpect(address(directory), abi.encodeCall(IJBDirectory.terminalsOf, (_projectId)), abi.encode(_terminals));
 
-        mockExpect(
-            address(_terminal),
-            abi.encodeCall(IJBTerminal.currentSurplusOf, (_projectId, _emptyContexts, 18, _currency)),
-            abi.encode(_surplus)
-        );
+        _mockSurplusInfra(_packedMetadata, _emptyLimits);
 
         mockExpect(
             address(_controller),
@@ -634,27 +512,23 @@ contract TestCurrentReclaimableSurplusOf_Local is JBTerminalStoreSetup {
             abi.encode(_supply)
         );
 
-        // Call the new convenience function.
         uint256 reclaimableDefault = _store.currentTotalReclaimableSurplusOf(_projectId, _cashoutAmount, 18, _currency);
 
-        // Re-mock for the 6-param call (mocks are consumed).
-        mockExpect(address(rulesets), abi.encodeCall(IJBRulesets.currentOf, (_projectId)), abi.encode(_returnedRuleset));
-        mockExpect(address(directory), abi.encodeCall(IJBDirectory.controllerOf, (_projectId)), abi.encode(_controller));
+        // --- Call 2: 6-param overload with empty arrays ---
+
+        // Re-mock for the 6-param call (mocks are consumed by the first call).
         mockExpect(address(directory), abi.encodeCall(IJBDirectory.terminalsOf, (_projectId)), abi.encode(_terminals));
-        mockExpect(
-            address(_terminal),
-            abi.encodeCall(IJBTerminal.currentSurplusOf, (_projectId, _emptyContexts, 18, _currency)),
-            abi.encode(_surplus)
-        );
+
+        _mockSurplusInfra(_packedMetadata, _emptyLimits);
+
         mockExpect(
             address(_controller),
             abi.encodeCall(IJBController.totalTokenSupplyWithReservedTokensOf, (_projectId)),
             abi.encode(_supply)
         );
 
-        // Call the 6-param overload with empty arrays.
         uint256 reclaimableExplicit = _store.currentReclaimableSurplusOf(
-            _projectId, _cashoutAmount, new IJBTerminal[](0), new JBAccountingContext[](0), 18, _currency
+            _projectId, _cashoutAmount, new IJBTerminal[](0), new address[](0), 18, _currency
         );
 
         assertEq(reclaimableDefault, reclaimableExplicit);