@bananapus/core-v6 0.0.1

package/test/invariants/handlers/TokensHandler.sol

@@ -0,0 +1,127 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.6;
+
+import "forge-std/Test.sol";
+import {JBConstants} from "../../../src/libraries/JBConstants.sol";
+import {IJBMultiTerminal} from "../../../src/interfaces/IJBMultiTerminal.sol";
+import {IJBController} from "../../../src/interfaces/IJBController.sol";
+import {IJBTokens} from "../../../src/interfaces/IJBTokens.sol";
+import {IJBToken} from "../../../src/interfaces/IJBToken.sol";
+
+/// @notice Handler contract for JBTokens invariant testing.
+/// @dev Drives mint, burn, claim, and transfer operations; tracks holders for sum-of-balances checks.
+contract TokensHandler is Test {
+    IJBMultiTerminal public terminal;
+    IJBController public controller;
+    IJBTokens public tokens;
+
+    uint256 public projectId;
+    address public projectOwner;
+
+    // Track all unique holders for sum-of-balances invariant
+    address[] public holders;
+    mapping(address => bool) public isHolder;
+
+    uint256 public constant NUM_ACTORS = 5;
+
+    constructor(
+        IJBMultiTerminal _terminal,
+        IJBController _controller,
+        IJBTokens _tokens,
+        uint256 _projectId,
+        address _projectOwner
+    ) {
+        terminal = _terminal;
+        controller = _controller;
+        tokens = _tokens;
+        projectId = _projectId;
+        projectOwner = _projectOwner;
+    }
+
+    function _getActor(uint256 seed) internal pure returns (address) {
+        return address(uint160(0x2000 + (seed % NUM_ACTORS)));
+    }
+
+    function _trackHolder(address holder) internal {
+        if (!isHolder[holder]) {
+            isHolder[holder] = true;
+            holders.push(holder);
+        }
+    }
+
+    function holderCount() external view returns (uint256) {
+        return holders.length;
+    }
+
+    function holderAt(uint256 i) external view returns (address) {
+        return holders[i];
+    }
+
+    /// @notice Pay the project to mint tokens for an actor.
+    function mintTokens(uint256 actorSeed, uint256 amount) public {
+        amount = bound(amount, 0.01 ether, 50 ether);
+        address actor = _getActor(actorSeed);
+        _trackHolder(actor);
+
+        vm.deal(actor, amount);
+        vm.prank(actor);
+        terminal.pay{value: amount}({
+            projectId: projectId,
+            amount: amount,
+            token: JBConstants.NATIVE_TOKEN,
+            beneficiary: actor,
+            minReturnedTokens: 0,
+            memo: "",
+            metadata: new bytes(0)
+        });
+    }
+
+    /// @notice Burn tokens from an actor.
+    function burnTokens(uint256 actorSeed, uint256 burnPercent) public {
+        address actor = _getActor(actorSeed);
+        uint256 balance = tokens.totalBalanceOf(actor, projectId);
+        if (balance == 0) return;
+
+        burnPercent = bound(burnPercent, 1, 100);
+        uint256 burnCount = (balance * burnPercent) / 100;
+        if (burnCount == 0) return;
+
+        vm.prank(actor);
+        controller.burnTokensOf({holder: actor, projectId: projectId, tokenCount: burnCount, memo: ""});
+    }
+
+    /// @notice Claim credits as ERC20 tokens.
+    function claimCredits(uint256 actorSeed, uint256 claimPercent) public {
+        address actor = _getActor(actorSeed);
+        uint256 creditBalance = tokens.creditBalanceOf(actor, projectId);
+        if (creditBalance == 0) return;
+
+        claimPercent = bound(claimPercent, 1, 100);
+        uint256 claimCount = (creditBalance * claimPercent) / 100;
+        if (claimCount == 0) return;
+
+        vm.prank(actor);
+        controller.claimTokensFor({holder: actor, projectId: projectId, tokenCount: claimCount, beneficiary: actor});
+    }
+
+    /// @notice Transfer credits between actors.
+    function transferCredits(uint256 fromSeed, uint256 toSeed, uint256 transferPercent) public {
+        address from = _getActor(fromSeed);
+        address to = _getActor(toSeed);
+        if (from == to) return;
+
+        uint256 creditBalance = tokens.creditBalanceOf(from, projectId);
+        if (creditBalance == 0) return;
+
+        transferPercent = bound(transferPercent, 1, 100);
+        uint256 transferCount = (creditBalance * transferPercent) / 100;
+        if (transferCount == 0) return;
+
+        _trackHolder(to);
+
+        vm.prank(from);
+        controller.transferCreditsFrom({holder: from, projectId: projectId, recipient: to, creditCount: transferCount});
+    }
+
+    receive() external payable {}
+}

package/test/mock/ERC2771ForwarderMock.sol

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.6;
+
+import {ERC2771Forwarder} from "@openzeppelin/contracts/metatx/ERC2771Forwarder.sol";
+
+struct ForwardRequest {
+    address from;
+    address to;
+    uint256 value;
+    uint256 gas;
+    uint256 nonce;
+    uint48 deadline;
+    bytes data;
+}
+
+contract ERC2771ForwarderMock is ERC2771Forwarder {
+    bool public deployed = true;
+
+    constructor(string memory name) ERC2771Forwarder(name) {}
+
+    function structHash(ForwardRequest calldata request) external view returns (bytes32) {
+        return _hashTypedDataV4(
+            keccak256(
+                abi.encode(
+                    _FORWARD_REQUEST_TYPEHASH,
+                    request.from,
+                    request.to,
+                    request.value,
+                    request.gas,
+                    request.nonce,
+                    request.deadline,
+                    keccak256(request.data)
+                )
+            )
+        );
+    }
+}

package/test/mock/MockERC20.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../helpers/TestBaseWorkflow.sol";
+
+import {ERC20, IERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+contract MockERC20 is ERC20 {
+    function decimals() public view virtual override returns (uint8) {
+        return 6;
+    }
+
+    constructor(string memory name_, string memory symbol_) ERC20(name_, symbol_) {}
+
+    function mint(address _to, uint256 _amount) external {
+        _mint(_to, _amount);
+    }
+}

package/test/mock/MockMaliciousBeneficiary.sol

@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../helpers/TestBaseWorkflow.sol";
+import {IJBMultiTerminal} from "../../src/interfaces/IJBMultiTerminal.sol";
+import {JBMultiTerminal} from "../../src/JBMultiTerminal.sol";
+import {JBConstants} from "../../src/libraries/JBConstants.sol";
+import {IERC721Receiver} from "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
+
+/// @notice Used for tests in TestAccessToFunds.sol
+/// @dev Attempts to re-enter sendPayoutsOf after receiving control-flow.
+contract MaliciousPayoutBeneficiary is IERC721Receiver, Test {
+    function reEnter(address _terminal) internal {
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                JBTerminalStore.JBTerminalStore_InadequateControllerPayoutLimit.selector, 1.5e19, 10 * 10 ** 18
+            )
+        );
+
+        IJBMultiTerminal(_terminal)
+            .sendPayoutsOf({
+                projectId: 2,
+                amount: 5 * 10 ** 18,
+                currency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+                token: JBConstants.NATIVE_TOKEN,
+                minTokensPaidOut: 0
+            });
+    }
+
+    receive() external payable {
+        if (msg.value > 0) reEnter(address(msg.sender));
+    }
+
+    function onERC721Received(address, address, uint256, bytes calldata) external pure override returns (bytes4) {
+        return IERC721Receiver.onERC721Received.selector;
+    }
+}
+
+/// @notice Used for tests in TestAccessToFunds.sol
+/// @dev Attempts to re-enter useAllowanceOf after receiving control-flow.
+contract MaliciousAllowanceBeneficiary is IERC721Receiver, Test {
+    function reEnter(address _terminal) internal {
+        vm.expectRevert(
+            abi.encodeWithSelector(JBTerminalStore.JBTerminalStore_InadequateControllerAllowance.selector, 1e19, 5e18)
+        );
+
+        IJBMultiTerminal(_terminal)
+            .useAllowanceOf({
+                projectId: 2,
+                amount: 5 * 10 ** 18,
+                currency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+                token: JBConstants.NATIVE_TOKEN,
+                minTokensPaidOut: 0,
+                beneficiary: payable(address(this)),
+                feeBeneficiary: payable(0x000000000000000000000000000000000000007B),
+                memo: "MEMO"
+            });
+    }
+
+    receive() external payable {
+        if (msg.value > 0) reEnter(address(msg.sender));
+    }
+
+    function onERC721Received(address, address, uint256, bytes calldata) external pure override returns (bytes4) {
+        return IERC721Receiver.onERC721Received.selector;
+    }
+}

package/test/mock/MockMaliciousSplitHook.sol

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../helpers/TestBaseWorkflow.sol";
+
+import {ERC165, IERC165} from "@openzeppelin/contracts/utils/introspection/ERC165.sol";
+
+contract MockMaliciousSplitHook is ERC165, IJBSplitHook {
+    error NopeNotGonnaDoIt();
+
+    uint256 revertMode;
+
+    function processSplitWith(JBSplitHookContext calldata _context) external payable override {
+        _context;
+        if (revertMode == 0) {
+            revert();
+        } else if (revertMode == 1) {
+            revert NopeNotGonnaDoIt();
+        } else if (revertMode == 2) {
+            require(false, "thanks no thanks");
+        } else {
+            uint256 a = 3;
+            uint256 b = 6;
+            uint256 c = a - b;
+            c;
+        }
+    }
+
+    function setRevertMode(uint256 _newMode) external {
+        revertMode = _newMode;
+    }
+
+    function supportsInterface(bytes4 _interfaceId) public view override(IERC165, ERC165) returns (bool) {
+        return _interfaceId == type(IJBSplitHook).interfaceId || super.supportsInterface(_interfaceId);
+    }
+}
+
+contract GasGussler {
+    fallback() external payable {
+        while (true) {}
+    }
+}

package/test/mock/MockPriceFeed.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../helpers/TestBaseWorkflow.sol";
+
+contract MockPriceFeed is IJBPriceFeed {
+    uint256 public fakePrice;
+    uint256 public fakeDecimals;
+
+    constructor(uint256 _fakePrice, uint256 _fakeDecimals) {
+        fakePrice = _fakePrice;
+        fakeDecimals = _fakeDecimals;
+    }
+
+    function currentUnitPrice(uint256 _decimals) external view override returns (uint256 _quote) {
+        if (_decimals == fakeDecimals) return fakePrice;
+        else if (_decimals > fakeDecimals) return fakePrice * 10 ** (_decimals - fakeDecimals);
+        else return fakePrice / 10 ** (fakeDecimals - _decimals);
+    }
+}

package/test/trees/JBController/burnTokensOf.tree

@@ -0,0 +1,9 @@
+TestBurnTokensOf_Local
+├── when caller is not permissioned or terminal
+│   └── it should revert UNAUTHORIZED()
+├── when caller is terminal and tokenCount gt zero
+│   └── it should burn and emit BurnTokens
+├── when caller has permission and tokenCount gt zero
+│   └── it should burn and emit BurnTokens
+└── when tokenCount eq zero
+    └── it should revert NO_BURNABLE_TOKENS

package/test/trees/JBController/claimTokensFor.tree

@@ -0,0 +1,5 @@
+TestClaimTokensFor_Local
+├── when caller is permissioned
+│   └── it should call JBTokens to claim on behalf of holder
+└── when caller is not permissioned
+    └── it should revert UNAUTHORIZED

package/test/trees/JBController/deployERC20For.tree

@@ -0,0 +1,5 @@
+TestDeployERC20For_Local
+├── when caller is permissioned
+│   └── it will deploy ERC20 and return IJBToken
+└── when caller is not permissioned
+    └── it will revert UNAUTHORIZED

package/test/trees/JBController/getRulesetOf.tree

@@ -0,0 +1,5 @@
+TestGetRulesetOf
+├── when rulesetId is zero
+│   └── it should return empty ruleset and metadata
+└── when rulesetID is non-zero
+    └── it should return populated ruleset and metadata

package/test/trees/JBController/launchProjectFor.tree

@@ -0,0 +1,12 @@
+TestLaunchProjectFor_Local
+└── when called
+    ├── given metadata is provided
+    │   └── it will set metadata
+    ├── given rulesets are provided
+    │   └── it will set rulesets
+    ├── given terminals are provided
+    │   └── it will set terminals
+    ├── given memo is provided
+    │   └── it will be included in the emit
+    └── given Directory exists
+        └── it will setControllerOf to itself

package/test/trees/JBController/launchRulesetsFor.tree

@@ -0,0 +1,8 @@
+TestLaunchRulesetsFor
+├── when caller does not have permission
+│   └── it should revert
+└── when caller has permission
+    ├── given the project already has rulesets
+    │   └── it should revert
+    └── given the project does not yet have rulesets
+        └── it should set the controller, queue the rulesets, configure terminals, and emit LaunchRulesets

package/test/trees/JBController/migrateController.tree

@@ -0,0 +1,12 @@
+TestMigrateController
+├── when caller does not have MIGRATE_CONTROLLER permission
+│   └── it should revert
+└── when caller has MIGRATE_CONTROLLER permission
+    ├── given migration is not allowed by ruleset
+    │   └── it should revert
+    └── given migration is allowed by ruleset
+        ├── given reserved token balance is pending
+        │   └── it should send reserved tokens to splits
+        └── given no reserved token balance is pending
+            ├── it should prepare new controller for migration
+            └── it should emit MigrateController event

package/test/trees/JBController/mintTokensOf.tree

@@ -0,0 +1,12 @@
+TestMintTokensOf_Local
+├── when no ruleset is active
+│   └── it should be able to mint
+├── when minting is disabled in the funding cycle ruleset
+│   └── it should revert
+└── when minting is enabled in the funding cycle ruleset
+    ├── given that there are tokens available to mint
+    │   └── it should be possible to mint
+    ├── given that a data source is configured
+    │   └── it should be able to mint
+    └── given that a data source has permissioned another contract to mint
+        └── it should be able to mint

package/test/trees/JBController/payReservedTokenToTerminal.tree

@@ -0,0 +1,8 @@
+TestExecutePayReservedTokenToTerminal_Local
+├── when caller is not itself
+│   └── it will revert
+└── when caller is itself
+    ├── given allowance EQ zero after pay
+    │   └── it will not revert
+    └── given allowance DNEQ zero after pay
+        └── it will revert

package/test/trees/JBController/receiveMigrationFrom.tree

@@ -0,0 +1,4 @@
+TestReceiveMigrationFrom
+└── when caller supports the correct interface
+    └── given that the caller is also controllerOf projectId
+        └── it should set metadata

package/test/trees/JBController/sendReservedTokensToSplitsOf.tree

@@ -0,0 +1,12 @@
+TestSendReservedTokensToSplitsOf_Local
+├── when the project has no reserved token splits
+│   └── it will mint to the project owner
+└── when the project has reserved token splits
+    ├── given a hook is configured
+    │   └── it will mint to hook and call its processSplitWith function
+    ├── given a beneficiary is configured
+    │   └── it will mint for the beneficiary
+    ├── given the projectId of split is nonzero and a beneficiary and hook are not configured
+    │   └── it will mint to the owner of the project
+    └── given projectId is zero and nothing is configured
+        └── it will mint to whoever called sendReservedTokens

package/test/trees/JBController/setMetadataOf.tree

@@ -0,0 +1,5 @@
+TestSetMetadataOf_Local
+├── when caller is owner or has permission
+│   └── it should set metadata and emit SetMetadata
+└── when caller is not owner or has permission
+    └── it should revert

package/test/trees/JBController/setSplitGroupsOf.tree

@@ -0,0 +1,5 @@
+TestSetSplitGroupsOf_Local
+├── when caller is permissioned
+│   └── it will set splits
+└── when caller is not permissioned
+    └── it will revert UNAUTHORIZED

package/test/trees/JBController/setTokenFor.tree

@@ -0,0 +1,5 @@
+TestSetTokenFor_Local
+├── when caller is permissioned
+│   └── it will set token
+└── when caller is not permissioned
+    └── it will revert UNAUTHORIZED

package/test/trees/JBController/transferCreditsFrom.tree

@@ -0,0 +1,8 @@
+TestTransferCreditsFrom_Local
+├── when caller is permissioned
+│   ├── given ruleset allows credit transfers
+│   │   └── it will call JBTokens to transfer the credits
+│   └── given ruleset does not allow credit transfers
+│       └── it will revert CREDIT_TRANSFERS_PAUSED
+└── when caller is not permissioned
+    └── it will revert UNAUTHORIZED

package/test/trees/JBDirectory/primaryTerminalOf.tree

@@ -0,0 +1,8 @@
+TestPrimaryTerminalOf_Local
+├── when there are no terminals supporting the input token
+│   └── it will return the zero address
+└── when there is at least one supporting terminal
+    ├── given there are multiple terminals with proper accountingContextForTokenOf
+    │   └── it will check each terminals accountingContextForTokenOf and return the first
+    └── given there are multiple terminals but none with the proper accountingContextForTokenOf
+        └── it will return the zero address

package/test/trees/JBDirectory/setControllerOf.tree

@@ -0,0 +1,11 @@
+TestSetControllerOf_Local
+├── when caller does not have any permission
+│   └── it should revert
+└── when caller isAllowedToSetFirstController or has permission
+    ├── given that a project doesn't exist
+    │   └── it should revert
+    └── given that the project exists
+        ├── given that the current controller is not setControllerAllowed
+        │   └── it should revert
+        └── given that the current controller is setControllerAllowed
+            └── it should set controllerOf and emit SetController

package/test/trees/JBDirectory/setPrimaryTerminalOf.tree

@@ -0,0 +1,15 @@
+TestSetPrimaryTerminalOf_Local
+├── when caller has no permission
+│   └── it should revert with UNAUTHORIZED()
+└── when caller has permission
+    ├── given that there is no accountingContextForTokenOf
+    │   └── it should revert with TOKEN_NOT_ACCEPTED
+    └── given that there is an accountingContextForTokenOf
+        ├── given that the terminal has already been added
+        │   └── it should not add the terminal
+        └── given that the terminal has not been added
+            ├── given that the project is not allowed to set terminals
+            │   └── it should revert with SET_TERMINALS_NOT_ALLOWED
+            └── given that the project is allowed to set terminals
+                ├── it should set the terminal and emit AddTerminal
+                └── it should set the terminal as primary and emit SetPrimaryTerminal

package/test/trees/JBDirectory/setTerminalsOf.tree

@@ -0,0 +1,11 @@
+TestSetTerminalsOf_Local
+├── when caller has no permission
+│   └── it should revert with UNAUTHORIZED()
+└── when caller has permission
+    ├── given that not setTerminalsAllowed
+    │   └── it should revert with revert SET_TERMINALS_NOT_ALLOWED()
+    └── given that setTerminalsAllowed
+        ├── given that duplicate terminals were added
+        │   └── it should revert with DUPLICATE_TERMINALS()
+        └── given that duplicate terminals were not added
+            └── it should set terminals and emit SetTerminals

package/test/trees/JBERC20/initialize.tree

@@ -0,0 +1,7 @@
+TestInitialize_Local
+├── when a name is already set
+│   └── it will revert
+├── when name_ EQ nothing
+│   └── it will revert
+└── when name is valid and not already set
+    └── it will set the name and symbol and transfer ownership

package/test/trees/JBERC20/name.tree

@@ -0,0 +1,5 @@
+TestName_Local
+├── When a name is set
+│   └── it will return the name
+└── When a name is not set
+    └── it will return an empty string

package/test/trees/JBERC20/nonces.tree

@@ -0,0 +1,5 @@
+TestNonces_Local
+├── When a user has not called permit
+│   └── it will return zero
+└── When a user has called permit
+    └── it will return a nonce GT zero

package/test/trees/JBERC20/symbol.tree

@@ -0,0 +1,5 @@
+TestSymbol_Local
+├── When a symbol is set
+│   └── it will return a non-empty string
+└── When a symbol is not set
+    └── it will return an empty string

package/test/trees/JBFeelessAddresses/setFeelessAddress.tree

@@ -0,0 +1,5 @@
+TestSetFeelessAddress_Local
+├── when caller is owner
+│   └── it should set isFeeless and emit SetFeelessAddress
+└── when caller is not owner
+    └── it should revert

package/test/trees/JBFeelessAddresses/supportsInterface.tree

@@ -0,0 +1,5 @@
+TestSupportsInterface_Local
+├── when it supports either IJBFeelessAddresses or IERC165
+│   └── it should return true
+└── when it doesnt support either IJBFeelessAddresses or IERC165
+    └── it should return false

package/test/trees/JBFundAccessLimits/payoutLimitOf.tree

@@ -0,0 +1,5 @@
+TestPayoutLimitOf_Local
+├── when the project has the specific payout limit
+│   └── it will return the uint256 payoutLimit
+└── when the project doesnt have the specific payout limit
+    └── it will return 0

package/test/trees/JBFundAccessLimits/payoutLimitsOf.tree

@@ -0,0 +1,8 @@
+TestPayoutLimitsOf_Local
+└── when a project has payout limits
+    ├── given they are configured for a specific token
+    │   └── it will return them
+    ├── given they are configured for a specific terminal
+    │   └── it will return them
+    └── given they are configured for a specific rulesetId
+        └── it will return them

package/test/trees/JBFundAccessLimits/setFundAccessLimitsFor.tree

@@ -0,0 +1,18 @@
+TestSetFundAccessLimitsFor_Local
+├── when caller is not controller
+│   └── it will revert
+└── when caller is controller of project
+    ├── given payoutLimit amount is gt uint224
+    │   └── it will revert INVALID_PAYOUT_LIMIT
+    ├── given payoutLimit currency is gt uint32
+    │   └── it will revert INVALID_PAYOUT_LIMIT_CURRENCY
+    ├── given payoutLimit currency is not given in ascending order
+    │   └── it will revert INVALID_PAYOUT_LIMIT_CURRENCY_ORDERING
+    ├── given surplusAllowance amount gt uint224
+    │   └── it will revert INVALID_SURPLUS_ALLOWANCE
+    ├── given surplusAllowance currency gt uint32
+    │   └── it will revert INVALID_PAYOUT_LIMIT_CURRENCY
+    ├── given surplus allowance currencies are not ascending order
+    │   └── it will revert INVALID_SURPLUS_ALLOWANCE_CURRENCY_ORDERING
+    └── given valid config
+        └── it will set packed properties and emit SetFundAccessLimits

package/test/trees/JBFundAccessLimits/surplusAllowanceOf.tree

@@ -0,0 +1,5 @@
+TestSurplusAllowanceOf_Local
+├── when a project has the specific surplus configured
+│   └── it will return uin256 surplusAllowance
+└── when it doesnt have the specific surplus configured
+    └── it will return 0

package/test/trees/JBFundAccessLimits/surplusAllowancesOf.tree

@@ -0,0 +1,8 @@
+TestSurplusAllowancesOf_Local
+└── when a project has specified surplus allowances
+    ├── given they are specified for a specific ruleset
+    │   └── it will return them
+    ├── given they are specified for a specific terminal
+    │   └── it will return them
+    └── given they are specified for a specific token
+        └── it will return them

package/test/trees/JBMetadataResolver/getDataFor.tree

@@ -0,0 +1,8 @@
+TestGetDataFor_Local
+├── when metadata length LTEQ MIN_METADATA_LENGTH
+│   └── it will return false and empty bytes
+└── when metadata length GT MIN_METADATA_LENGTH
+    ├── given id is found
+    │   └── it will return found EQ true and targetData
+    └── given id is not found
+        └── it will return found EQ false and empty bytes targetData

package/test/trees/JBMultiTerminal/accountingContextsOf.tree

@@ -0,0 +1,5 @@
+TestAccountingContextsFor_Local
+├── when accounting contexts are set
+│   └── it will return contexts
+└── when accounting contexts are not set
+    └── it will return an empty array

package/test/trees/JBMultiTerminal/addAccountingContextsFor.tree

@@ -0,0 +1,10 @@
+TestAddAccountingContextsFor_Local
+├── when caller is not permissioned
+│   └── it will revert UNAUTHORIZED
+├── when caller is permissioned
+│   ├── given the context is already set
+│   │   └── it will revert ACCOUNTING_CONTEXT_ALREADY_SET
+│   └── given happypath
+│       └── it will set the context and emit SetAccountingContext
+└── when caller is controller
+    └── it will alsoGrantAccess