@bananapus/core-v6 0.0.20 → 0.0.22

package/src/interfaces/IJBMultiTerminal.sol

@@ -7,7 +7,6 @@ import {IJBFeeTerminal} from "./IJBFeeTerminal.sol";
 import {IJBPayoutTerminal} from "./IJBPayoutTerminal.sol";
 import {IJBPermitTerminal} from "./IJBPermitTerminal.sol";
 import {IJBProjects} from "./IJBProjects.sol";
-import {IJBRulesets} from "./IJBRulesets.sol";
 import {IJBSplits} from "./IJBSplits.sol";
 import {IJBTerminal} from "./IJBTerminal.sol";
 import {IJBTerminalStore} from "./IJBTerminalStore.sol";
@@ -22,9 +21,6 @@ interface IJBMultiTerminal is IJBTerminal, IJBFeeTerminal, IJBCashOutTerminal, I
     /// @notice Mints ERC-721s that represent project ownership and transfers.
     function PROJECTS() external view returns (IJBProjects);
 
-    /// @notice The contract storing and managing project rulesets.
-    function RULESETS() external view returns (IJBRulesets);
-
     /// @notice The contract that stores splits for each project.
     function SPLITS() external view returns (IJBSplits);
 

package/src/interfaces/IJBTerminal.sol

@@ -88,15 +88,15 @@ interface IJBTerminal is IERC165 {
     /// @return The accounting contexts for the project.
     function accountingContextsOf(uint256 projectId) external view returns (JBAccountingContext[] memory);
 
-    /// @notice Returns a project's current surplus for a set of accounting contexts.
+    /// @notice Returns a project's current surplus in this terminal.
     /// @param projectId The ID of the project to get the surplus of.
-    /// @param accountingContexts The accounting contexts to include in the surplus calculation.
+    /// @param tokens The tokens to include in the surplus calculation. If empty, all tokens are included.
     /// @param decimals The number of decimals to express the surplus with.
     /// @param currency The currency to express the surplus in.
-    /// @return The project's current surplus.
+    /// @return The project's current surplus for the given tokens.
     function currentSurplusOf(
         uint256 projectId,
-        JBAccountingContext[] memory accountingContexts,
+        address[] calldata tokens,
         uint256 decimals,
         uint256 currency
     )

package/src/interfaces/IJBTerminalStore.sol

@@ -5,11 +5,11 @@ import {IJBDirectory} from "./IJBDirectory.sol";
 import {IJBPrices} from "./IJBPrices.sol";
 import {IJBRulesets} from "./IJBRulesets.sol";
 import {IJBTerminal} from "./IJBTerminal.sol";
-import {JBAccountingContext} from "./../structs/JBAccountingContext.sol";
-import {JBCashOutHookSpecification} from "./../structs/JBCashOutHookSpecification.sol";
-import {JBPayHookSpecification} from "./../structs/JBPayHookSpecification.sol";
-import {JBRuleset} from "./../structs/JBRuleset.sol";
-import {JBTokenAmount} from "./../structs/JBTokenAmount.sol";
+import {JBAccountingContext} from "../structs/JBAccountingContext.sol";
+import {JBCashOutHookSpecification} from "../structs/JBCashOutHookSpecification.sol";
+import {JBPayHookSpecification} from "../structs/JBPayHookSpecification.sol";
+import {JBRuleset} from "../structs/JBRuleset.sol";
+import {JBTokenAmount} from "../structs/JBTokenAmount.sol";
 
 /// @notice Manages the bookkeeping for payments, cash outs, payouts, and surplus allowance usage for terminals.
 interface IJBTerminalStore {
@@ -22,6 +22,32 @@ interface IJBTerminalStore {
     /// @notice The contract storing and managing project rulesets.
     function RULESETS() external view returns (IJBRulesets);
 
+    /// @notice Returns the accounting context for a terminal's project token.
+    /// @param terminal The terminal the accounting context applies to.
+    /// @param projectId The ID of the project.
+    /// @param token The token to get the accounting context for.
+    /// @return The accounting context.
+    function accountingContextOf(
+        address terminal,
+        uint256 projectId,
+        address token
+    )
+        external
+        view
+        returns (JBAccountingContext memory);
+
+    /// @notice Returns all accounting contexts for a terminal's project.
+    /// @param terminal The terminal the accounting contexts apply to.
+    /// @param projectId The ID of the project.
+    /// @return The accounting contexts.
+    function accountingContextsOf(
+        address terminal,
+        uint256 projectId
+    )
+        external
+        view
+        returns (JBAccountingContext[] memory);
+
     /// @notice Returns the balance of a terminal for a project and token.
     /// @param terminal The terminal to get the balance of.
     /// @param projectId The ID of the project to get the balance for.
@@ -45,11 +71,12 @@ interface IJBTerminalStore {
         view
         returns (uint256);
 
-    /// @notice Returns the reclaimable surplus for a project across multiple terminals.
+    /// @notice Returns the reclaimable surplus for a project across multiple terminals, considering only specific
+    /// tokens.
     /// @param projectId The ID of the project.
     /// @param cashOutCount The number of tokens being cashed out.
-    /// @param terminals The terminals to include in the surplus calculation.
-    /// @param accountingContexts The accounting contexts to include.
+    /// @param terminals The terminals to include in the surplus calculation. If empty, all project terminals are used.
+    /// @param tokens The tokens to include in the surplus calculation.
     /// @param decimals The number of decimals to express the result with.
     /// @param currency The currency to express the result in.
     /// @return The reclaimable surplus amount.
@@ -57,7 +84,7 @@ interface IJBTerminalStore {
         uint256 projectId,
         uint256 cashOutCount,
         IJBTerminal[] calldata terminals,
-        JBAccountingContext[] calldata accountingContexts,
+        address[] calldata tokens,
         uint256 decimals,
         uint256 currency
     )
@@ -65,15 +92,17 @@ interface IJBTerminalStore {
         view
         returns (uint256);
 
-    /// @notice Returns the reclaimable surplus for a project across all terminals using all accounting contexts.
+    /// @notice Returns the current surplus for a project across specified terminals and tokens.
     /// @param projectId The ID of the project.
-    /// @param cashOutCount The number of tokens being cashed out.
+    /// @param terminals The terminals to include. If empty, all project terminals are used.
+    /// @param tokens The tokens to include. If empty, all tokens per terminal are used.
     /// @param decimals The number of decimals to express the result with.
     /// @param currency The currency to express the result in.
-    /// @return The reclaimable surplus amount.
-    function currentTotalReclaimableSurplusOf(
+    /// @return The current surplus.
+    function currentSurplusOf(
         uint256 projectId,
-        uint256 cashOutCount,
+        IJBTerminal[] calldata terminals,
+        address[] calldata tokens,
         uint256 decimals,
         uint256 currency
     )
@@ -81,17 +110,15 @@ interface IJBTerminalStore {
         view
         returns (uint256);
 
-    /// @notice Returns the current surplus for a terminal and project.
-    /// @param terminal The terminal to get the surplus of.
+    /// @notice Returns the reclaimable surplus for a project across all terminals using all accounting contexts.
     /// @param projectId The ID of the project.
-    /// @param accountingContexts The accounting contexts to include.
+    /// @param cashOutCount The number of tokens being cashed out.
     /// @param decimals The number of decimals to express the result with.
     /// @param currency The currency to express the result in.
-    /// @return The current surplus.
-    function currentSurplusOf(
-        address terminal,
+    /// @return The reclaimable surplus amount.
+    function currentTotalReclaimableSurplusOf(
         uint256 projectId,
-        JBAccountingContext[] calldata accountingContexts,
+        uint256 cashOutCount,
         uint256 decimals,
         uint256 currency
     )
@@ -114,11 +141,11 @@ interface IJBTerminalStore {
         returns (uint256);
 
     /// @notice Simulates a cash out without modifying state.
+    /// @param terminal The terminal to simulate the cash out from.
     /// @param holder The address cashing out.
     /// @param projectId The ID of the project being cashed out from.
     /// @param cashOutCount The number of project tokens being cashed out.
-    /// @param accountingContext The accounting context of the token being reclaimed.
-    /// @param balanceAccountingContexts The accounting contexts to include in the balance calculation.
+    /// @param tokenToReclaim The token being reclaimed.
     /// @param beneficiaryIsFeeless Whether the cash out's beneficiary is a feeless address.
     /// @param metadata Extra data to pass along to the data hook.
     /// @return ruleset The project's current ruleset.
@@ -126,11 +153,11 @@ interface IJBTerminalStore {
     /// @return cashOutTaxRate The cash out tax rate that would be applied.
     /// @return hookSpecifications Any cash out hook specifications from the data hook.
     function previewCashOutFrom(
+        address terminal,
         address holder,
         uint256 projectId,
         uint256 cashOutCount,
-        JBAccountingContext calldata accountingContext,
-        JBAccountingContext[] calldata balanceAccountingContexts,
+        address tokenToReclaim,
         bool beneficiaryIsFeeless,
         bytes calldata metadata
     )
@@ -144,6 +171,7 @@ interface IJBTerminalStore {
         );
 
     /// @notice Simulates a payment without modifying state.
+    /// @param terminal The terminal to simulate the payment from.
     /// @param payer The address of the payer.
     /// @param amount The amount being paid.
     /// @param projectId The ID of the project being paid.
@@ -153,6 +181,7 @@ interface IJBTerminalStore {
     /// @return tokenCount The number of project tokens that would be minted, including reserved tokens.
     /// @return hookSpecifications Any pay hook specifications from the data hook.
     function previewPayFrom(
+        address terminal,
         address payer,
         JBTokenAmount memory amount,
         uint256 projectId,
@@ -199,6 +228,11 @@ interface IJBTerminalStore {
         view
         returns (uint256);
 
+    /// @notice Records accounting contexts for a terminal's project tokens.
+    /// @param projectId The ID of the project.
+    /// @param contexts The accounting contexts to record.
+    function recordAccountingContextOf(uint256 projectId, JBAccountingContext[] calldata contexts) external;
+
     /// @notice Records a balance addition for a project.
     /// @param projectId The ID of the project.
     /// @param token The token being added.
@@ -209,8 +243,7 @@ interface IJBTerminalStore {
     /// @param holder The address cashing out.
     /// @param projectId The ID of the project being cashed out from.
     /// @param cashOutCount The number of project tokens being cashed out.
-    /// @param accountingContext The accounting context of the token being reclaimed.
-    /// @param balanceAccountingContexts The accounting contexts to include in the balance calculation.
+    /// @param tokenToReclaim The token being reclaimed.
     /// @param beneficiaryIsFeeless Whether the cash out's beneficiary is a feeless address. Passed through to data
     /// hooks so they can skip their own fees when value stays in the protocol (e.g. project-to-project routing).
     /// @param metadata Extra data to pass along to the data hook.
@@ -222,8 +255,7 @@ interface IJBTerminalStore {
         address holder,
         uint256 projectId,
         uint256 cashOutCount,
-        JBAccountingContext calldata accountingContext,
-        JBAccountingContext[] calldata balanceAccountingContexts,
+        address tokenToReclaim,
         bool beneficiaryIsFeeless,
         bytes calldata metadata
     )
@@ -256,14 +288,14 @@ interface IJBTerminalStore {
 
     /// @notice Records a payout from a project.
     /// @param projectId The ID of the project paying out.
-    /// @param accountingContext The accounting context of the token being paid out.
+    /// @param token The token being paid out.
     /// @param amount The amount being paid out.
     /// @param currency The currency the amount is denominated in.
     /// @return ruleset The project's current ruleset.
     /// @return amountPaidOut The amount paid out in the token's native decimals.
     function recordPayoutFor(
         uint256 projectId,
-        JBAccountingContext calldata accountingContext,
+        address token,
         uint256 amount,
         uint256 currency
     )
@@ -278,14 +310,14 @@ interface IJBTerminalStore {
 
     /// @notice Records surplus allowance usage for a project.
     /// @param projectId The ID of the project using surplus allowance.
-    /// @param accountingContext The accounting context of the token being used.
+    /// @param token The token being used.
     /// @param amount The amount of surplus allowance to use.
     /// @param currency The currency the amount is denominated in.
     /// @return ruleset The project's current ruleset.
     /// @return usedAmount The amount used in the token's native decimals.
     function recordUsedAllowanceOf(
         uint256 projectId,
-        JBAccountingContext calldata accountingContext,
+        address token,
         uint256 amount,
         uint256 currency
     )

package/src/libraries/JBPayoutSplitGroupLib.sol

@@ -3,7 +3,6 @@ pragma solidity 0.8.26;
 
 import {mulDiv} from "@prb/math/src/Common.sol";
 
-import {IJBPayoutTerminal} from "../interfaces/IJBPayoutTerminal.sol";
 import {IJBSplits} from "../interfaces/IJBSplits.sol";
 import {IJBTerminalStore} from "../interfaces/IJBTerminalStore.sol";
 import {JBSplit} from "../structs/JBSplit.sol";
@@ -62,10 +61,10 @@ library JBPayoutSplitGroupLib {
     {
         // The total percentage available to split.
         uint256 leftoverPercentage = JBConstants.SPLITS_TOTAL_PERCENT;
-        uint256 group = uint256(uint160(token));
 
         // Get a reference to the project's payout splits.
-        JBSplit[] memory payoutSplits = splits.splitsOf({projectId: projectId, rulesetId: rulesetId, groupId: group});
+        JBSplit[] memory payoutSplits =
+            splits.splitsOf({projectId: projectId, rulesetId: rulesetId, groupId: uint256(uint160(token))});
 
         leftoverAmount = amount;
 
@@ -102,7 +101,7 @@ library JBPayoutSplitGroupLib {
             emit SendPayoutToSplit({
                 projectId: projectId,
                 rulesetId: rulesetId,
-                group: group,
+                group: uint256(uint160(token)),
                 split: split,
                 amount: payoutAmount,
                 netAmount: netPayoutAmount,

package/src/libraries/JBSurplus.sol

@@ -2,7 +2,6 @@
 pragma solidity ^0.8.17;
 
 import {IJBTerminal} from "../interfaces/IJBTerminal.sol";
-import {JBAccountingContext} from "../structs/JBAccountingContext.sol";
 
 /// @notice Surplus calculations.
 library JBSurplus {
@@ -11,7 +10,7 @@ library JBSurplus {
     /// the project's payout limits.
     /// @param projectId The ID of the project to get the total surplus for.
     /// @param terminals The terminals to look for surplus within.
-    /// @param accountingContexts The accounting contexts to use to calculate the surplus.
+    /// @param tokens The tokens to include in the surplus calculation. If empty, all tokens are included.
     /// @param decimals The number of decimals that the fixed point surplus result should include.
     /// @param currency The currency that the surplus result should be in terms of.
     /// @return surplus The total surplus of a project's funds in terms of `currency`, as a fixed point number with the
@@ -19,7 +18,7 @@ library JBSurplus {
     function currentSurplusOf(
         uint256 projectId,
         IJBTerminal[] memory terminals,
-        JBAccountingContext[] memory accountingContexts,
+        address[] memory tokens,
         uint256 decimals,
         uint256 currency
     )
@@ -33,7 +32,7 @@ library JBSurplus {
         // Add the current surplus for each terminal.
         for (uint256 i; i < numberOfTerminals; i++) {
             surplus += terminals[i].currentSurplusOf({
-                projectId: projectId, accountingContexts: accountingContexts, decimals: decimals, currency: currency
+                projectId: projectId, tokens: tokens, decimals: decimals, currency: currency
             });
         }
     }

package/test/ComprehensiveInvariant.t.sol

@@ -4,6 +4,7 @@ pragma solidity ^0.8.6;
 import {StdInvariant} from "forge-std/StdInvariant.sol";
 import {TestBaseWorkflow} from "./helpers/TestBaseWorkflow.sol";
 import {IJBRulesetApprovalHook} from "../src/interfaces/IJBRulesetApprovalHook.sol";
+import {IJBTerminal} from "../src/interfaces/IJBTerminal.sol";
 import {IJBSplitHook} from "../src/interfaces/IJBSplitHook.sol";
 import {IJBToken} from "../src/interfaces/IJBToken.sol";
 import {JBConstants} from "../src/libraries/JBConstants.sol";
@@ -236,16 +237,13 @@ contract ComprehensiveInvariant_Local is StdInvariant, TestBaseWorkflow {
         uint256 totalSupply = jbTokens().totalSupplyOf(projectId);
         if (totalSupply == 0) return;
 
-        JBAccountingContext[] memory contexts = new JBAccountingContext[](1);
-        contexts[0] = JBAccountingContext({
-            token: JBConstants.NATIVE_TOKEN, decimals: 18, currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
-        });
-
+        IJBTerminal[] memory _terminals = new IJBTerminal[](1);
+        _terminals[0] = IJBTerminal(jbMultiTerminal());
         uint256 surplus = jbTerminalStore()
             .currentSurplusOf({
-                terminal: address(jbMultiTerminal()),
                 projectId: projectId,
-                accountingContexts: contexts,
+                terminals: _terminals,
+                tokens: new address[](0),
                 decimals: 18,
                 currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
             });

package/test/CoreExploitTests.t.sol

@@ -5,6 +5,7 @@ import {TestBaseWorkflow} from "./helpers/TestBaseWorkflow.sol";
 import {MetadataResolverHelper} from "./helpers/MetadataResolverHelper.sol";
 import {MockERC20} from "./mock/MockERC20.sol";
 import {JBMultiTerminal} from "../src/JBMultiTerminal.sol";
+import {JBTerminalStore} from "../src/JBTerminalStore.sol";
 import {JBTokens} from "../src/JBTokens.sol";
 import {JBApprovalStatus} from "../src/enums/JBApprovalStatus.sol";
 import {IJBController} from "../src/interfaces/IJBController.sol";
@@ -624,16 +625,13 @@ contract EdgeCases_Local is TestBaseWorkflow {
         });
 
         // The surplus should be payAmount - payoutLimit = 15 ether.
-        JBAccountingContext[] memory contexts = new JBAccountingContext[](1);
-        contexts[0] = JBAccountingContext({
-            token: JBConstants.NATIVE_TOKEN, decimals: 18, currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
-        });
-
+        IJBTerminal[] memory _surplusTerminals = new IJBTerminal[](1);
+        _surplusTerminals[0] = IJBTerminal(_terminal);
         uint256 surplus = jbTerminalStore()
             .currentSurplusOf({
-                terminal: address(_terminal),
                 projectId: projectId,
-                accountingContexts: contexts,
+                terminals: _surplusTerminals,
+                tokens: new address[](0),
                 decimals: 18,
                 currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
             });
@@ -2461,7 +2459,7 @@ contract EdgeCases_Local is TestBaseWorkflow {
         });
 
         vm.prank(_projectOwner);
-        vm.expectRevert(JBMultiTerminal.JBMultiTerminal_AccountingContextDecimalsMismatch.selector);
+        vm.expectRevert(JBTerminalStore.JBTerminalStore_AccountingContextDecimalsMismatch.selector);
         _terminal.addAccountingContextsFor(projectId, wrongContexts);
     }
 
@@ -2492,15 +2490,13 @@ contract EdgeCases_Local is TestBaseWorkflow {
         });
 
         // Check surplus — should equal the full balance since no payout limits.
-        JBAccountingContext[] memory contexts = new JBAccountingContext[](1);
-        contexts[0] =
-            JBAccountingContext({token: address(token), decimals: 6, currency: uint32(uint160(address(token)))});
-
+        IJBTerminal[] memory _surplusTerminals2 = new IJBTerminal[](1);
+        _surplusTerminals2[0] = IJBTerminal(_terminal);
         uint256 surplus = jbTerminalStore()
             .currentSurplusOf({
-                terminal: address(_terminal),
                 projectId: projectId,
-                accountingContexts: contexts,
+                terminals: _surplusTerminals2,
+                tokens: new address[](0),
                 decimals: 6,
                 currency: uint32(uint160(address(token)))
             });
@@ -2572,17 +2568,14 @@ contract EdgeCases_Local is TestBaseWorkflow {
         uint256 pendingReserved = _controller.pendingReservedTokenBalanceOf(projectId);
 
         // Record surplus before distributing reserves
-        JBAccountingContext[] memory contexts = new JBAccountingContext[](1);
-        contexts[0] = JBAccountingContext({
-            token: JBConstants.NATIVE_TOKEN, decimals: 18, currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
-        });
-
         uint256 supplyBefore = _tokens.totalSupplyOf(projectId);
+        IJBTerminal[] memory _surplusTerminals3 = new IJBTerminal[](1);
+        _surplusTerminals3[0] = IJBTerminal(_terminal);
         uint256 surplusBefore = jbTerminalStore()
             .currentSurplusOf({
-                terminal: address(_terminal),
                 projectId: projectId,
-                accountingContexts: contexts,
+                terminals: _surplusTerminals3,
+                tokens: new address[](0),
                 decimals: 18,
                 currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
             });
@@ -2599,11 +2592,13 @@ contract EdgeCases_Local is TestBaseWorkflow {
         }
 
         uint256 supplyAfter = _tokens.totalSupplyOf(projectId);
+        IJBTerminal[] memory _surplusTerminals4 = new IJBTerminal[](1);
+        _surplusTerminals4[0] = IJBTerminal(_terminal);
         uint256 surplusAfter = jbTerminalStore()
             .currentSurplusOf({
-                terminal: address(_terminal),
                 projectId: projectId,
-                accountingContexts: contexts,
+                terminals: _surplusTerminals4,
+                tokens: new address[](0),
                 decimals: 18,
                 currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
             });

package/test/TestCashOut.sol

@@ -131,15 +131,15 @@ contract TestCashOut_Local is TestBaseWorkflow {
         // Fuzz 1 to full balance cash out.
         _tokenAmountToCashOut = bound(_tokenAmountToCashOut, 1, _beneficiaryTokenBalance);
 
-        JBAccountingContext[] memory _tokensContext = new JBAccountingContext[](1);
-        _tokensContext[0] = JBAccountingContext({
-            token: JBConstants.NATIVE_TOKEN, decimals: 18, currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
-        });
-
         // Get the expected gross per a different view.
         uint256 _grossPerReclaimable = jbTerminalStore()
             .currentReclaimableSurplusOf(
-                _projectId, _tokenAmountToCashOut, new IJBTerminal[](0), _tokensContext, 18, _tokensContext[0].currency
+                _projectId,
+                _tokenAmountToCashOut,
+                new IJBTerminal[](0),
+                new address[](0),
+                18,
+                uint32(uint160(JBConstants.NATIVE_TOKEN))
             );
 
         // Test: cash out.

package/test/TestMultiTerminalSurplus.sol

@@ -162,13 +162,13 @@ contract TestMultiTerminalSurplus_Local is TestBaseWorkflow {
         // Check ETH-only surplus from terminal 1.
         JBAccountingContext[] memory ethCtx = new JBAccountingContext[](1);
         ethCtx[0] = JBAccountingContext({token: JBConstants.NATIVE_TOKEN, decimals: 18, currency: _nativeCurrency});
-        uint256 ethSurplus = _terminal1.currentSurplusOf(_projectId, ethCtx, 18, _nativeCurrency);
+        uint256 ethSurplus = _terminal1.currentSurplusOf(_projectId, new address[](0), 18, _nativeCurrency);
         assertEq(ethSurplus, ethAmount, "terminal1 ETH surplus should match payment");
 
         // Check USDC-only surplus from terminal 2.
         JBAccountingContext[] memory usdcCtx = new JBAccountingContext[](1);
         usdcCtx[0] = JBAccountingContext({token: address(_usdc), decimals: 6, currency: _usdcCurrency});
-        uint256 usdcSurplus = _terminal2.currentSurplusOf(_projectId, usdcCtx, 6, _usdcCurrency);
+        uint256 usdcSurplus = _terminal2.currentSurplusOf(_projectId, new address[](0), 6, _usdcCurrency);
         assertEq(usdcSurplus, usdcAmount, "terminal2 USDC surplus should match payment");
 
         // Check total surplus in ETH terms from the store.
@@ -330,12 +330,12 @@ contract TestMultiTerminalSurplus_Local is TestBaseWorkflow {
         // Get individual surpluses in ETH terms.
         JBAccountingContext[] memory ethCtx = new JBAccountingContext[](1);
         ethCtx[0] = JBAccountingContext({token: JBConstants.NATIVE_TOKEN, decimals: 18, currency: _nativeCurrency});
-        uint256 t1Surplus = _terminal1.currentSurplusOf(_projectId, ethCtx, 18, _nativeCurrency);
+        uint256 t1Surplus = _terminal1.currentSurplusOf(_projectId, new address[](0), 18, _nativeCurrency);
 
         JBAccountingContext[] memory usdcCtx = new JBAccountingContext[](1);
         usdcCtx[0] = JBAccountingContext({token: address(_usdc), decimals: 6, currency: _usdcCurrency});
         // Get terminal 2 surplus in ETH terms.
-        uint256 t2SurplusInEth = _terminal2.currentSurplusOf(_projectId, usdcCtx, 18, _nativeCurrency);
+        uint256 t2SurplusInEth = _terminal2.currentSurplusOf(_projectId, new address[](0), 18, _nativeCurrency);
 
         // Get total surplus from the store.
         uint256 totalSurplus = jbTerminalStore().currentTotalSurplusOf(_projectId, 18, _nativeCurrency);

package/test/TestMultiTokenSurplus.sol

@@ -114,7 +114,7 @@ contract TestMultiTokenSurplus_Local is TestBaseWorkflow {
         JBAccountingContext[] memory contexts = new JBAccountingContext[](1);
         contexts[0] = JBAccountingContext({token: JBConstants.NATIVE_TOKEN, decimals: 18, currency: _nativeCurrency});
 
-        uint256 surplus = _terminal.currentSurplusOf(_projectId, contexts, 18, _nativeCurrency);
+        uint256 surplus = _terminal.currentSurplusOf(_projectId, new address[](0), 18, _nativeCurrency);
         assertEq(surplus, payAmount, "ETH surplus should match payment");
     }
 
@@ -137,7 +137,7 @@ contract TestMultiTokenSurplus_Local is TestBaseWorkflow {
         JBAccountingContext[] memory contexts = new JBAccountingContext[](1);
         contexts[0] = JBAccountingContext({token: address(_usdc), decimals: 6, currency: _usdcCurrency});
 
-        uint256 surplus = _terminal.currentSurplusOf(_projectId, contexts, 6, _usdcCurrency);
+        uint256 surplus = _terminal.currentSurplusOf(_projectId, new address[](0), 6, _usdcCurrency);
         assertEq(surplus, usdcAmount, "USDC surplus should match payment");
     }
 
@@ -162,30 +162,13 @@ contract TestMultiTokenSurplus_Local is TestBaseWorkflow {
         vm.prank(_beneficiary);
         _terminal.pay(_projectId, address(_usdc), usdcAmount, _beneficiary, 0, "", "");
 
-        // Check surplus of each token individually
-        JBAccountingContext[] memory ethContext = new JBAccountingContext[](1);
-        ethContext[0] = JBAccountingContext({token: JBConstants.NATIVE_TOKEN, decimals: 18, currency: _nativeCurrency});
+        // Check surplus (now includes all registered contexts automatically)
+        uint256 ethSurplus = _terminal.currentSurplusOf(_projectId, new address[](0), 18, _nativeCurrency);
 
-        JBAccountingContext[] memory usdcContext = new JBAccountingContext[](1);
-        usdcContext[0] = JBAccountingContext({token: address(_usdc), decimals: 6, currency: _usdcCurrency});
-
-        uint256 ethSurplus = _terminal.currentSurplusOf(_projectId, ethContext, 18, _nativeCurrency);
-        assertEq(ethSurplus, ethAmount, "ETH surplus should match");
-
-        uint256 usdcSurplus = _terminal.currentSurplusOf(_projectId, usdcContext, 6, _usdcCurrency);
-        assertEq(usdcSurplus, usdcAmount, "USDC surplus should match");
-
-        // Check aggregated surplus in ETH terms (both contexts)
-        JBAccountingContext[] memory bothContexts = new JBAccountingContext[](2);
-        bothContexts[0] = ethContext[0];
-        bothContexts[1] = usdcContext[0];
-
-        uint256 totalSurplus = _terminal.currentSurplusOf(_projectId, bothContexts, 18, _nativeCurrency);
-
-        // Total should be ETH amount + USDC converted to ETH
+        // Total should include ETH amount + USDC converted to ETH
         // 1 ETH + (2000 USDC / 2000 per ETH) = 2 ETH
         // But the conversion depends on the feed direction
-        assertGt(totalSurplus, ethAmount, "total surplus should include both tokens");
+        assertGt(ethSurplus, ethAmount, "total surplus should include both tokens");
     }
 
     /// @notice Balance tracking is per-token.

package/test/TestTerminalMigration.sol

@@ -144,13 +144,8 @@ contract TestTerminalMigration_Local is TestBaseWorkflow {
         _terminalA.pay{value: payAmount}(_projectId, JBConstants.NATIVE_TOKEN, payAmount, _beneficiary, 0, "", "");
 
         // Record surplus before migration
-        JBAccountingContext[] memory contexts = new JBAccountingContext[](1);
-        contexts[0] = JBAccountingContext({
-            token: JBConstants.NATIVE_TOKEN, decimals: 18, currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
-        });
-
         uint256 surplusBefore =
-            _terminalA.currentSurplusOf(_projectId, contexts, 18, uint32(uint160(JBConstants.NATIVE_TOKEN)));
+            _terminalA.currentSurplusOf(_projectId, new address[](0), 18, uint32(uint160(JBConstants.NATIVE_TOKEN)));
         assertGt(surplusBefore, 0, "should have surplus before migration");
 
         // Migrate
@@ -159,7 +154,7 @@ contract TestTerminalMigration_Local is TestBaseWorkflow {
 
         // Check surplus from terminal B
         uint256 surplusAfter =
-            _terminalB.currentSurplusOf(_projectId, contexts, 18, uint32(uint160(JBConstants.NATIVE_TOKEN)));
+            _terminalB.currentSurplusOf(_projectId, new address[](0), 18, uint32(uint160(JBConstants.NATIVE_TOKEN)));
         assertEq(surplusAfter, surplusBefore, "surplus should be preserved after migration");
     }
 

package/test/fork/TestSequencerPriceFeedFork.sol

@@ -59,7 +59,7 @@ contract TestSequencerPriceFeedFork is Test {
     // ------------------------------------------------------------------
 
     /// @notice Under normal conditions (sequencer up, grace period elapsed), currentUnitPrice returns a sane price.
-    function test_normalOperation_returnsValidPrice() public skipIfNoRpc {
+    function test_normalOperation_returnsValidPrice() public view skipIfNoRpc {
         uint256 price18 = feed.currentUnitPrice(18);
 
         // ETH price should be between $500 and $50,000.

package/test/fork/TestTerminalPreviewParityFork.sol

@@ -2,7 +2,6 @@
 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";

package/test/invariants/TerminalStoreInvariant.t.sol

@@ -4,6 +4,7 @@ pragma solidity ^0.8.6;
 import {StdInvariant} from "forge-std/StdInvariant.sol";
 import {TestBaseWorkflow} from "../helpers/TestBaseWorkflow.sol";
 import {IJBRulesetApprovalHook} from "../../src/interfaces/IJBRulesetApprovalHook.sol";
+import {IJBTerminal} from "../../src/interfaces/IJBTerminal.sol";
 import {JBConstants} from "../../src/libraries/JBConstants.sol";
 import {JBRulesetMetadataResolver} from "../../src/libraries/JBRulesetMetadataResolver.sol";
 import {JBFundAccessLimitGroup} from "../../src/structs/JBFundAccessLimitGroup.sol";
@@ -153,16 +154,13 @@ contract TerminalStoreInvariant_Local is StdInvariant, TestBaseWorkflow {
         uint256 totalSupply = jbTokens().totalSupplyOf(projectId);
         if (totalSupply == 0) return; // Skip when no tokens exist
 
-        JBAccountingContext[] memory contexts = new JBAccountingContext[](1);
-        contexts[0] = JBAccountingContext({
-            token: JBConstants.NATIVE_TOKEN, decimals: 18, currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
-        });
-
+        IJBTerminal[] memory _terminals = new IJBTerminal[](1);
+        _terminals[0] = IJBTerminal(jbMultiTerminal());
         uint256 surplus = jbTerminalStore()
             .currentSurplusOf({
-                terminal: address(jbMultiTerminal()),
                 projectId: projectId,
-                accountingContexts: contexts,
+                terminals: _terminals,
+                tokens: new address[](0),
                 decimals: 18,
                 currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
             });